Update LinuxKernelConf version to 1.4.

19 files changed, 3489 insertions, 773 deletions

diff --git a/scripts/kconfig/Makefile b/scripts/kconfig/Makefile
index 5a0d7e5..b918300 100644
--- a/scripts/kconfig/Makefile
+++ b/scripts/kconfig/Makefile
@@ -1,181 +1,198 @@
-VERSION=1.3
+VERSION=1.4
 CC=gcc
 CXX=g++
 CFLAGS=-O0 -Wall -g -fPIC
-CXXFLAGS=$(CFLAGS) -I$(HOSTQTDIR)/include
+CXXFLAGS=$(CFLAGS) -I$(QTDIR)/include
 LDFLAGS=
-LXXFLAGS=$(LDFLAGS) -L$(HOSTQTDIR)/lib -Wl,-rpath,$(HOSTQTDIR)/lib
+LXXFLAGS=$(LDFLAGS) -L$(QTDIR)/lib -Wl,-rpath,$(QTDIR)/lib
 LEX=flex
 LFLAGS=-L
 YACC=bison
 YFLAGS=-l
-#YFLAGS=-d -t -v -l
-ifndef HOSTQTDIR
-HOSTQTDIR=/usr/share/qt
+#YFLAGS=-t -v -l
+ifndef QTDIR
+QTDIR=/usr/share/qt3
 endif
-MOC=$(wildcard $(HOSTQTDIR)/bin/moc)
+MOC=$(wildcard $(QTDIR)/bin/moc)
+GTKCFLAGS=`pkg-config gtk+-2.0 gmodule-2.0 libglade-2.0 --cflags`
+GTKLDFLAGS=`pkg-config gtk+-2.0 gmodule-2.0 libglade-2.0 --libs`
 
 parse_SRC=zconf.y
 conf_SRC=conf.c $(parse_SRC)
 mconf_SRC=mconf.c $(parse_SRC)
 qconf_SRC=qconf.cc
+gconf_SRC=gconf.c kconfig_load.c
 HDR=expr.h lkc.h lkc_proto.h qconf.h
 OTHER=README lkc-language.txt Makefile.kernel \
 	kconfig.i extconf.rb example
 INST=zconf.y zconf.l confdata.c expr.c symbol.c menu.c \
-	conf.c mconf.c qconf.cc kconfig_load.c images.c $(HDR)
+	conf.c mconf.c qconf.cc gconf.c gconf.glade kconfig_load.c images.c $(HDR)
 INSTGEN=lex.zconf.c zconf.tab.c
 
 #DEBUG=1
 ifdef DEBUG
 CFLAGS+=-DLKC_DIRECT_LINK
 qconf_SRC+=$(parse_SRC)
 else
 qconf_SRC+=kconfig_load.c
 endif
 
 SRC=$(conf_SRC) $(mconf_SRC) $(qconf_SRC)
 CSRC=$(filter %.c, $(SRC))
 YSRC=$(filter %.y, $(SRC))
 LSRC=$(filter %.l, $(SRC))
 
 parse_OBJ=$(filter %.o, \
 		$(patsubst %.c,%.o, \
 		$(patsubst %.y,%.tab.o, \
 		$(patsubst %.l,lex.%.o, \
 			$(parse_SRC)))))
 conf_OBJ=$(filter %.o, \
 		$(patsubst %.c,%.o, \
 		$(patsubst %.y,%.tab.o, \
 		$(patsubst %.l,lex.%.o, \
 			$(conf_SRC)))))
 mconf_OBJ=$(filter %.o, \
 		$(patsubst %.c,%.o, \
 		$(patsubst %.y,%.tab.o, \
 		$(patsubst %.l,lex.%.o, \
 			$(mconf_SRC)))))
 qconf_OBJ=$(filter %.o, \
 		$(patsubst %.c,%.o, \
 		$(patsubst %.cc,%.o, \
 		$(patsubst %.y,%.tab.o, \
 		$(patsubst %.l,lex.%.o, \
 			$(qconf_SRC))))))
+gconf_OBJ=$(filter %.o, \
+		$(patsubst %.c,%.o, \
+		$(patsubst %.y,%.tab.o, \
+		$(patsubst %.l,lex.%.o, \
+			$(gconf_SRC)))))
 OBJ=$(conf_OBJ) $(mconf_OBJ) $(qconf_OBJ)
 
 ifeq ($(MOC),)
 all: conf mconf
 else
 all: conf mconf qconf libkconfig.so
 endif
 
 lkc_deps := lkc.h lkc_proto.h lkc_defs.h expr.h
 
 zconf.tab.c: zconf.y
 zconf.tab.h: zconf.y
 lex.zconf.c: zconf.l
 zconf.tab.o: zconf.tab.c lex.zconf.c confdata.c expr.c symbol.c menu.c $(lkc_deps)
 #lex.zconf.o: lex.zconf.c zconf.tab.h $(lkc_deps)
 #confdata.o: confdata.c $(lkc_deps)
 #expr.o: expr.c $(lkc_deps)
 #symbol.o: symbol.c $(lkc_deps)
 #menu.o: menu.c $(lkc_deps)
 kconfig_load.o: kconfig_load.c $(lkc_deps)
 conf.o: conf.c $(lkc_deps)
 mconf.o: mconf.c $(lkc_deps)
 qconf.moc: qconf.h
 qconf.o: qconf.cc qconf.moc images.c $(lkc_deps)
+gconf.o: gconf.c $(lkc_deps)
 
 mconf: $(mconf_OBJ)
 	$(CC) $(LDFLAGS) $^ -o $@
 
 conf: $(conf_OBJ)
 	$(CC) $(LDFLAGS) $^ -o $@
 
 ifeq ($(MOC),)
 qconf:
 	@echo Unable to find the QT installation. Please make sure that the
-	@echo QT development package is correctly installed and the HOSTQTDIR
+	@echo QT development package is correctly installed and the QTDIR
 	@echo environment variable is set to the correct location.
 	@false
 else
 qconf: $(qconf_OBJ)
-	$(CXX) $(LXXFLAGS) $^ -lqt -o $@
+	$(CXX) $(LXXFLAGS) $^ -lqt-mt -o $@
 endif
 
+gconf.o: gconf.c
+	$(CC) $(CFLAGS) $(GTKCFLAGS) -c $< -o $@
+
+gconf: $(gconf_OBJ)
+	$(CC) $(LDFLAGS) $(GTKLDFLAGS) $^ -o $@
+
 libkconfig.so: $(parse_OBJ)
 	$(CC) -shared $^ -o $@
 
 lkc_defs.h: lkc_proto.h
 	sed < $< > $@ 's/P(\([^,]*\),.*/#define \1 (\*\1_p)/'
 
 clean:
 	rm -f $(OBJ) conf qconf mconf *.moc lex.* *.tab.? *.output
 	rm -rf .ruby .python
 
 tgz:
 	mkdir tmp
 	mkdir tmp/lkc-$(VERSION)
 	cp -ra Makefile $(sort $(SRC) $(HDR) $(OTHER) $(INST)) tmp/lkc-$(VERSION)
 	tar -cpvz -C tmp --exclude CVS -f lkc-$(VERSION).tar.gz lkc-$(VERSION)
 	rm -rf tmp
 
 %.tab.c %.tab.h: %.y
 	$(YACC) $(YFLAGS) -b $* -p $* $<
 
 lex.%.c: %.l
 	$(LEX) $(LFLAGS) -P$* $<
 
 %.moc: %.h
-	$(HOSTQTDIR)/bin/moc -i $< -o $@
+	$(QTDIR)/bin/moc -i $< -o $@
 
 %.o: %.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
 %.o: %.cc
 	$(CXX) $(CXXFLAGS) -c $< -o $@
 
 ifdef KERNELSRC
 install: $(INSTGEN)
-	set -x; cp $(sort $(INST)) $(KERNELSRC)/scripts/kconfig; \
-	for f in $(INSTGEN); do cp $$f $(KERNELSRC)/scripts/kconfig/$${f}_shipped; done; \
-	cp Makefile.kernel $(KERNELSRC)/scripts/kconfig/Makefile
+	set -x; cp --remove-destination $(sort $(INST)) $(KERNELSRC)/scripts/kconfig; \
+	for f in $(INSTGEN); do cp --remove-destination $$f $(KERNELSRC)/scripts/kconfig/$${f}_shipped; done; \
+	cp --remove-destination Makefile.kernel $(KERNELSRC)/scripts/kconfig/Makefile; \
+	cp --remove-destination lkc-language.txt $(KERNELSRC)/Documentation/kbuild/kconfig-language.txt
 
 diff: $(INSTGEN)
-	for f in $(sort $(INST)); do diff -u $(KERNELSRC)/scripts/kconfig/$$f $$f; done; \
-	for f in $(INSTGEN); do diff -u $(KERNELSRC)/scripts/kconfig/$${f}_shipped $$f; done; \
-	diff -u $(KERNELSRC)/scripts/kconfig/Makefile Makefile.kernel
+	for f in $(sort $(INST)); do diff -Nu $(KERNELSRC)/scripts/kconfig/$$f $$f; done; \
+	for f in $(INSTGEN); do diff -Nu $(KERNELSRC)/scripts/kconfig/$${f}_shipped $$f; done; \
+	diff -Nu $(KERNELSRC)/scripts/kconfig/Makefile Makefile.kernel; \
+	diff -Nu lkc-language.txt $(KERNELSRC)/Documentation/kbuild/kconfig-language.txt
 else
 install:
 	@echo "Please use KERNELSRC=<path/to/linux-kernel> to install"
 endif
 
 ruby: .ruby libkconfig.so .ruby/kconfig.so
 
 .ruby:
 	mkdir .ruby
 
 .ruby/kconfig_wrap.c: kconfig.i kconfig_load.c expr.h lkc_proto.h
 	swig -ruby -o $@ $<
 
 .ruby/Makefile: extconf.rb
 	cd .ruby; ruby ../extconf.rb
 
 .ruby/kconfig.so: .ruby/kconfig_wrap.c .ruby/Makefile
 	make -C .ruby
 
 
 PYTHON_INCLUDE=$(shell python -c "import sys; print '-I'+sys.prefix+'/include/python'+sys.version[:3]")
 
 python: .python .python/kconfig.py .python/_kconfig.so
 
 .python:
 	mkdir .python
 
 .python/kconfig_wrap.c .python/kconfig.py: kconfig.i kconfig_load.c expr.h lkc_proto.h
 	swig -python -o .python/kconfig_wrap.c kconfig.i
 
 .python/_kconfig.so: .python/kconfig_wrap.c
 	cd .python; $(CC) $(CFLAGS) -shared kconfig_wrap.c -o _kconfig.so -I.. $(PYTHON_INCLUDE)
 
 
 .PHONY: all tgz clean ruby python
diff --git a/scripts/kconfig/Makefile.kernel b/scripts/kconfig/Makefile.kernel
index 22724a7..bae5e29 100644
--- a/scripts/kconfig/Makefile.kernel
+++ b/scripts/kconfig/Makefile.kernel
@@ -1,95 +1,133 @@
 #################
 #
 # Shared Makefile for the various lkc executables:
 # conf:	  Used for defconfig, oldconfig and related targets
 # mconf:  Used for the mconfig target.
 #         Utilizes the lxdialog package
 # qconf:  Used for the xconfig target
 #         Based on QT which needs to be installed to compile it
+# gconf:  Used for the gconfig target
+#         Based on GTK which needs to be installed to compile it
 #
+#################
 
 # object files used by all lkc flavours
 libkconfig-objs := zconf.tab.o
 
-host-progs	:= conf mconf qconf
+host-progs	:= conf mconf qconf gconf
 conf-objs	:= conf.o  libkconfig.so
 mconf-objs	:= mconf.o libkconfig.so
 
-qconf-objs	:= kconfig_load.o
+ifeq ($(MAKECMDGOALS),$(obj)/qconf)
 qconf-cxxobjs	:= qconf.o
+qconf-objs	:= kconfig_load.o
+endif
 
-clean-files	:= libkconfig.so lkc_defs.h qconf.moc .tmp_qtcheck \
-		   zconf.tab.c zconf.tab.h lex.zconf.c
+ifeq ($(MAKECMDGOALS),$(obj)/gconf)
+gconf-objs	:= gconf.o kconfig_load.o
+endif
 
-include $(TOPDIR)/Rules.make
+clean-files	:= libkconfig.so lkc_defs.h qconf.moc .tmp_qtcheck \
+		   .tmp_gtkcheck zconf.tab.c zconf.tab.h lex.zconf.c
 
 # generated files seem to need this to find local include files
 HOSTCFLAGS_lex.zconf.o	:= -I$(src)
 HOSTCFLAGS_zconf.tab.o	:= -I$(src)
 
 HOSTLOADLIBES_qconf	= -L$(QTDIR)/lib -Wl,-rpath,$(QTDIR)/lib -l$(QTLIB) -ldl
 HOSTCXXFLAGS_qconf.o	= -I$(QTDIR)/include 
 
-$(obj)/conf.o $(obj)/mconf.o $(obj)/qconf.o: $(obj)/zconf.tab.h
+HOSTLOADLIBES_gconf	= `pkg-config gtk+-2.0 gmodule-2.0 libglade-2.0 --libs`
+HOSTCFLAGS_gconf.o	= `pkg-config gtk+-2.0 gmodule-2.0 libglade-2.0 --cflags`
+
+$(obj)/conf.o $(obj)/mconf.o $(obj)/qconf.o $(obj)/gconf.o: $(obj)/zconf.tab.h
 
 $(obj)/qconf.o: $(obj)/.tmp_qtcheck
 
 ifeq ($(MAKECMDGOALS),$(obj)/qconf)
 MOC = $(QTDIR)/bin/moc
 -include $(obj)/.tmp_qtcheck
 
 # QT needs some extra effort...
 $(obj)/.tmp_qtcheck:
-	@set -e; for d in $$QTDIR /usr/share/qt /usr/lib/qt3; do \
+	@set -e; for d in $$QTDIR /usr/share/qt* /usr/lib/qt*; do \
 	  if [ -f $$d/include/qconfig.h ]; then DIR=$$d; break; fi; \
 	done; \
 	if [ -z "$$DIR" ]; then \
 	  echo "*"; \
 	  echo "* Unable to find the QT installation. Please make sure that the"; \
 	  echo "* QT development package is correctly installed and the QTDIR"; \
 	  echo "* environment variable is set to the correct location."; \
 	  echo "*"; \
 	  false; \
 	fi; \
 	LIB=qt; \
 	if [ -f $$DIR/lib/libqt-mt.so ]; then LIB=qt-mt; fi; \
 	echo "QTDIR=$$DIR" > $@; echo "QTLIB=$$LIB" >> $@; \
 	if [ ! -x $$DIR/bin/moc -a -x /usr/bin/moc ]; then \
 	  echo "*"; \
 	  echo "* Unable to find $$DIR/bin/moc, using /usr/bin/moc instead."; \
 	  echo "*"; \
 	  echo "MOC=/usr/bin/moc" >> $@; \
 	fi
 endif
 
+$(obj)/gconf.o: $(obj)/.tmp_gtkcheck
+
+ifeq ($(MAKECMDGOALS),$(obj)/gconf)
+-include $(obj)/.tmp_gtkcheck
+
+# GTK needs some extra effort, too...
+$(obj)/.tmp_gtkcheck:
+	@if `pkg-config gtk+-2.0 gmodule-2.0 libglade-2.0 --exists`; then		\
+		if `pkg-config gtk+-2.0 --atleast-version=2.0.0`; then			\
+			touch $@;								\
+		else									\
+			echo "*"; 							\
+			echo "* GTK+ is present but version >= 2.0.0 is required.";	\
+			echo "*";							\
+			false;								\
+		fi									\
+	else										\
+		echo "*"; 								\
+		echo "* Unable to find the GTK+ installation. Please make sure that"; 	\
+		echo "* the GTK+ 2.0 development package is correctly installed..."; 	\
+		echo "* You need gtk+-2.0, glib-2.0 and libglade-2.0."; 		\
+		echo "*"; 								\
+		false;									\
+	fi
+endif
+
 $(obj)/zconf.tab.o: $(obj)/lex.zconf.c
 
 $(obj)/kconfig_load.o: $(obj)/lkc_defs.h
 
 $(obj)/qconf.o: $(obj)/qconf.moc $(obj)/lkc_defs.h
 
+$(obj)/gconf.o: $(obj)/lkc_defs.h
+
 $(obj)/%.moc: $(src)/%.h
 	$(MOC) -i $< -o $@
 
 $(obj)/lkc_defs.h: $(src)/lkc_proto.h
 	sed < $< > $@ 's/P(\([^,]*\),.*/#define \1 (\*\1_p)/'
 
 
 ###
 # The following requires flex/bison
 # By default we use the _shipped versions, uncomment the following line if
 # you are modifying the flex/bison src.
 # LKC_GENPARSER := 1
 
 ifdef LKC_GENPARSER
 
 $(obj)/zconf.tab.c: $(obj)/zconf.y 
 $(obj)/zconf.tab.h: $(obj)/zconf.tab.c
 
 %.tab.c: %.y
 	bison -t -d -v -b $* -p $(notdir $*) $<
 
 lex.%.c: %.l
 	flex -P$(notdir $*) -o$@ $<
 
 endif
diff --git a/scripts/kconfig/conf.c b/scripts/kconfig/conf.c
index 1602d5f..3c27a78 100644
--- a/scripts/kconfig/conf.c
+++ b/scripts/kconfig/conf.c
@@ -1,568 +1,566 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <time.h>
 #include <sys/stat.h>
 
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 
 static void conf(struct menu *menu);
 static void check_conf(struct menu *menu);
 
 enum {
 	ask_all,
 	ask_new,
 	ask_silent,
 	set_default,
 	set_yes,
 	set_mod,
 	set_no,
 	set_random
 } input_mode = ask_all;
 
 static int indent = 1;
 static int valid_stdin = 1;
 static int conf_cnt;
 static char line[128];
 static struct menu *rootEntry;
 
 static char nohelp_text[] = "Sorry, no help available for this option yet.\n";
 
-#if 0
-static void printc(int ch)
-{
-	static int sep = 0;
-
-	if (!sep) {
-		putchar('[');
-		sep = 1;
-	} else if (ch)
-		putchar('/');
-	if (!ch) {
-		putchar(']');
-		putchar(' ');
-		sep = 0;
-	} else
-		putchar(ch);
-}
-#endif
-
-static void printo(const char *o)
-{
-	static int sep = 0;
-
-	if (!sep) {
-		putchar('(');
-		sep = 1;
-	} else if (o) {
-		putchar(',');
-		putchar(' ');
-	}
-	if (!o) {
-		putchar(')');
-		putchar(' ');
-		sep = 0;
-	} else
-		printf("%s", o);
-}
-
 static void strip(char *str)
 {
 	char *p = str;
 	int l;
 
 	while ((isspace(*p)))
 		p++;
 	l = strlen(p);
 	if (p != str)
 		memmove(str, p, l + 1);
 	if (!l)
 		return;
 	p = str + l - 1;
 	while ((isspace(*p)))
 		*p-- = 0;
 }
 
+static void check_stdin(void)
+{
+	if (!valid_stdin && input_mode == ask_silent) {
+		printf("aborted!\n\n");
+		printf("Console input/output is redirected. ");
+		printf("Run 'make oldconfig' to update configuration.\n\n");
+		exit(1);
+	}
+}
+
 static void conf_askvalue(struct symbol *sym, const char *def)
 {
 	enum symbol_type type = sym_get_type(sym);
 	tristate val;
 
 	if (!sym_has_value(sym))
 		printf("(NEW) ");
 
 	line[0] = '\n';
 	line[1] = 0;
 
+	if (!sym_is_changable(sym)) {
+		printf("%s\n", def);
+		line[0] = '\n';
+		line[1] = 0;
+		return;
+	}
+
 	switch (input_mode) {
 	case ask_new:
 	case ask_silent:
 		if (sym_has_value(sym)) {
 			printf("%s\n", def);
 			return;
 		}
-		if (!valid_stdin && input_mode == ask_silent) {
-			printf("aborted!\n\n");
-			printf("Console input/output is redirected. ");
-			printf("Run 'make oldconfig' to update configuration.\n\n");
-			exit(1);
-		}
+		check_stdin();
 	case ask_all:
 		fflush(stdout);
 		fgets(line, 128, stdin);
 		return;
 	case set_default:
 		printf("%s\n", def);
 		return;
 	default:
 		break;
 	}
 
 	switch (type) {
 	case S_INT:
 	case S_HEX:
 	case S_STRING:
 		printf("%s\n", def);
 		return;
 	default:
 		;
 	}
 	switch (input_mode) {
 	case set_yes:
 		if (sym_tristate_within_range(sym, yes)) {
 			line[0] = 'y';
 			line[1] = '\n';
 			line[2] = 0;
 			break;
 		}
 	case set_mod:
 		if (type == S_TRISTATE) {
 			if (sym_tristate_within_range(sym, mod)) {
 				line[0] = 'm';
 				line[1] = '\n';
 				line[2] = 0;
 				break;
 			}
 		} else {
 			if (sym_tristate_within_range(sym, yes)) {
 				line[0] = 'y';
 				line[1] = '\n';
 				line[2] = 0;
 				break;
 			}
 		}
 	case set_no:
 		if (sym_tristate_within_range(sym, no)) {
 			line[0] = 'n';
 			line[1] = '\n';
 			line[2] = 0;
 			break;
 		}
 	case set_random:
 		do {
 			val = (tristate)(random() % 3);
 		} while (!sym_tristate_within_range(sym, val));
 		switch (val) {
 		case no: line[0] = 'n'; break;
 		case mod: line[0] = 'm'; break;
 		case yes: line[0] = 'y'; break;
 		}
 		line[1] = '\n';
 		line[2] = 0;
 		break;
 	default:
 		break;
 	}
 	printf("%s", line);
 }
 
 int conf_string(struct menu *menu)
 {
 	struct symbol *sym = menu->sym;
 	const char *def, *help;
 
 	while (1) {
 		printf("%*s%s ", indent - 1, "", menu->prompt->text);
 		printf("(%s) ", sym->name);
 		def = sym_get_string_value(sym);
 		if (sym_get_string_value(sym))
 			printf("[%s] ", def);
 		conf_askvalue(sym, def);
 		switch (line[0]) {
 		case '\n':
 			break;
 		case '?':
 			/* print help */
 			if (line[1] == 0) {
 				help = nohelp_text;
 				if (menu->sym->help)
 					help = menu->sym->help;
 				printf("\n%s\n", menu->sym->help);
 				def = NULL;
 				break;
 			}
 		default:
 			line[strlen(line)-1] = 0;
 			def = line;
 		}
 		if (def && sym_set_string_value(sym, def))
 			return 0;
 	}
 }
 
 static int conf_sym(struct menu *menu)
 {
 	struct symbol *sym = menu->sym;
 	int type;
 	tristate oldval, newval;
 	const char *help;
 
 	while (1) {
 		printf("%*s%s ", indent - 1, "", menu->prompt->text);
 		if (sym->name)
 			printf("(%s) ", sym->name);
 		type = sym_get_type(sym);
 		putchar('[');
 		oldval = sym_get_tristate_value(sym);
 		switch (oldval) {
 		case no:
 			putchar('N');
 			break;
 		case mod:
 			putchar('M');
 			break;
 		case yes:
 			putchar('Y');
 			break;
 		}
 		if (oldval != no && sym_tristate_within_range(sym, no))
 			printf("/n");
 		if (oldval != mod && sym_tristate_within_range(sym, mod))
 			printf("/m");
 		if (oldval != yes && sym_tristate_within_range(sym, yes))
 			printf("/y");
 		if (sym->help)
 			printf("/?");
 		printf("] ");
 		conf_askvalue(sym, sym_get_string_value(sym));
 		strip(line);
 
 		switch (line[0]) {
 		case 'n':
 		case 'N':
 			newval = no;
 			if (!line[1] || !strcmp(&line[1], "o"))
 				break;
 			continue;
 		case 'm':
 		case 'M':
 			newval = mod;
 			if (!line[1])
 				break;
 			continue;
 		case 'y':
 		case 'Y':
 			newval = yes;
 			if (!line[1] || !strcmp(&line[1], "es"))
 				break;
 			continue;
 		case 0:
 			newval = oldval;
 			break;
 		case '?':
 			goto help;
 		default:
 			continue;
 		}
 		if (sym_set_tristate_value(sym, newval))
 			return 0;
 help:
 		help = nohelp_text;
 		if (sym->help)
 			help = sym->help;
 		printf("\n%s\n", help);
 	}
 }
 
 static int conf_choice(struct menu *menu)
 {
 	struct symbol *sym, *def_sym;
-	struct menu *cmenu, *def_menu;
-	const char *help;
-	int type, len;
+	struct menu *child;
+	int type;
 	bool is_new;
 
 	sym = menu->sym;
 	type = sym_get_type(sym);
 	is_new = !sym_has_value(sym);
 	if (sym_is_changable(sym)) {
 		conf_sym(menu);
 		sym_calc_value(sym);
 		switch (sym_get_tristate_value(sym)) {
 		case no:
 			return 1;
 		case mod:
 			return 0;
 		case yes:
 			break;
 		}
 	} else {
-		sym->def = sym->curr;
-		if (S_TRI(sym->curr) == mod) {
+		switch (sym_get_tristate_value(sym)) {
+		case no:
+			return 1;
+		case mod:
 			printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
 			return 0;
+		case yes:
+			break;
 		}
 	}
 
 	while (1) {
-		printf("%*s%s ", indent - 1, "", menu_get_prompt(menu));
+		int cnt, def;
+
+		printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
 		def_sym = sym_get_choice_value(sym);
-		def_menu = NULL;
-		for (cmenu = menu->list; cmenu; cmenu = cmenu->next) {
-			if (!menu_is_visible(cmenu))
+		cnt = def = 0;
+		line[0] = '0';
+		line[1] = 0;
+		for (child = menu->list; child; child = child->next) {
+			if (!menu_is_visible(child))
 				continue;
-			printo(menu_get_prompt(cmenu));
-			if (cmenu->sym == def_sym)
-				def_menu = cmenu;
-		}
-		printo(NULL);
-		if (def_menu)
-			printf("[%s] ", menu_get_prompt(def_menu));
-		else {
+			if (!child->sym) {
+				printf("%*c %s\n", indent, '*', menu_get_prompt(child));
+				continue;
+			}
+			cnt++;
+			if (child->sym == def_sym) {
+				def = cnt;
+				printf("%*c", indent, '>');
+			} else
+				printf("%*c", indent, ' ');
+			printf(" %d. %s", cnt, menu_get_prompt(child));
+			if (child->sym->name)
+				printf(" (%s)", child->sym->name);
+			if (!sym_has_value(child->sym))
+				printf(" (NEW)");
 			printf("\n");
-			return 1;
 		}
+		printf("%*schoice", indent - 1, "");
+		if (cnt == 1) {
+			printf("[1]: 1\n");
+			goto conf_childs;
+		}
+		printf("[1-%d", cnt);
+		if (sym->help)
+			printf("?");
+		printf("]: ");
 		switch (input_mode) {
 		case ask_new:
 		case ask_silent:
+			if (!is_new) {
+				cnt = def;
+				printf("%d\n", cnt);
+				break;
+			}
+			check_stdin();
 		case ask_all:
-			if (is_new)
-				sym->flags |= SYMBOL_NEW;
-			conf_askvalue(sym, menu_get_prompt(def_menu));
+			fflush(stdout);
+			fgets(line, 128, stdin);
 			strip(line);
+			if (line[0] == '?') {
+				printf("\n%s\n", menu->sym->help ?
+					menu->sym->help : nohelp_text);
+				continue;
+			}
+			if (!line[0])
+				cnt = def;
+			else if (isdigit(line[0]))
+				cnt = atoi(line);
+			else
+				continue;
+			break;
+		case set_random:
+			def = (random() % cnt) + 1;
+		case set_default:
+		case set_yes:
+		case set_mod:
+		case set_no:
+			cnt = def;
+			printf("%d\n", cnt);
 			break;
-		default:
-			line[0] = 0;
-			printf("\n");
 		}
-		if (line[0] == '?' && !line[1]) {
-			help = nohelp_text;
-			if (menu->sym->help)
-				help = menu->sym->help;
-			printf("\n%s\n", help);
-			continue;
+
+	conf_childs:
+		for (child = menu->list; child; child = child->next) {
+			if (!child->sym || !menu_is_visible(child))
+				continue;
+			if (!--cnt)
+				break;
 		}
-		if (line[0]) {
-			len = strlen(line);
-			line[len] = 0;
-
-			def_menu = NULL;
-			for (cmenu = menu->list; cmenu; cmenu = cmenu->next) {
-				if (!cmenu->sym || !menu_is_visible(cmenu))
-					continue;
-				if (!strncasecmp(line, menu_get_prompt(cmenu), len)) {
-					def_menu = cmenu;
-					break;
-				}
-			}
+		if (!child)
+			continue;
+		if (line[strlen(line) - 1] == '?') {
+			printf("\n%s\n", child->sym->help ?
+				child->sym->help : nohelp_text);
+			continue;
 		}
-		if (def_menu) {
-			sym_set_choice_value(sym, def_menu->sym);
-			if (def_menu->list) {
-				indent += 2;
-				conf(def_menu->list);
-				indent -= 2;
-			}
-			return 1;
+		sym_set_choice_value(sym, child->sym);
+		if (child->list) {
+			indent += 2;
+			conf(child->list);
+			indent -= 2;
 		}
+		return 1;
 	}
 }
 
 static void conf(struct menu *menu)
 {
 	struct symbol *sym;
 	struct property *prop;
 	struct menu *child;
 
 	if (!menu_is_visible(menu))
 		return;
 
 	sym = menu->sym;
 	prop = menu->prompt;
 	if (prop) {
 		const char *prompt;
 
 		switch (prop->type) {
 		case P_MENU:
 			if (input_mode == ask_silent && rootEntry != menu) {
 				check_conf(menu);
 				return;
 			}
 		case P_COMMENT:
 			prompt = menu_get_prompt(menu);
 			if (prompt)
 				printf("%*c\n%*c %s\n%*c\n",
 					indent, '*',
 					indent, '*', prompt,
 					indent, '*');
 		default:
 			;
 		}
 	}
 
 	if (!sym)
 		goto conf_childs;
 
 	if (sym_is_choice(sym)) {
 		conf_choice(menu);
-		if (S_TRI(sym->curr) != mod)
+		if (sym->curr.tri != mod)
 			return;
 		goto conf_childs;
 	}
 
 	switch (sym->type) {
 	case S_INT:
 	case S_HEX:
 	case S_STRING:
 		conf_string(menu);
 		break;
 	default:
 		conf_sym(menu);
 		break;
 	}
 
 conf_childs:
 	if (sym)
 		indent += 2;
 	for (child = menu->list; child; child = child->next)
 		conf(child);
 	if (sym)
 		indent -= 2;
 }
 
 static void check_conf(struct menu *menu)
 {
 	struct symbol *sym;
 	struct menu *child;
 
 	if (!menu_is_visible(menu))
 		return;
 
 	sym = menu->sym;
-	if (!sym)
-		goto conf_childs;
-
-	if (sym_is_choice(sym)) {
-		if (!sym_has_value(sym)) {
+	if (sym) {
+		if (sym_is_changable(sym) && !sym_has_value(sym)) {
 			if (!conf_cnt++)
 				printf("*\n* Restart config...\n*\n");
 			rootEntry = menu_get_parent_menu(menu);
 			conf(rootEntry);
 		}
-		if (sym_get_tristate_value(sym) != mod)
+		if (sym_is_choice(sym) && sym_get_tristate_value(sym) != mod)
 			return;
-		goto conf_childs;
 	}
 
-	if (!sym_has_value(sym)) {
-		if (!conf_cnt++)
-			printf("*\n* Restart config...\n*\n");
-		rootEntry = menu_get_parent_menu(menu);
-		conf(rootEntry);
-	}
-
-conf_childs:
 	for (child = menu->list; child; child = child->next)
 		check_conf(child);
 }
 
 int main(int ac, char **av)
 {
 	const char *name;
 	struct stat tmpstat;
 
 	if (ac > 1 && av[1][0] == '-') {
 		switch (av[1][1]) {
 		case 'o':
 			input_mode = ask_new;
 			break;
 		case 's':
 			input_mode = ask_silent;
 			valid_stdin = isatty(0) && isatty(1) && isatty(2);
 			break;
 		case 'd':
 			input_mode = set_default;
 			break;
 		case 'n':
 			input_mode = set_no;
 			break;
 		case 'm':
 			input_mode = set_mod;
 			break;
 		case 'y':
 			input_mode = set_yes;
 			break;
 		case 'r':
 			input_mode = set_random;
 			srandom(time(NULL));
 			break;
 		case 'h':
 		case '?':
 			printf("%s [-o|-s] config\n", av[0]);
 			exit(0);
 		}
 		name = av[2];
 	} else
 		name = av[1];
 	conf_parse(name);
 	//zconfdump(stdout);
 	switch (input_mode) {
 	case set_default:
 		name = conf_get_default_confname();
 		if (conf_read(name)) {
 			printf("***\n"
 				"*** Can't find default configuration \"%s\"!\n"
 				"***\n", name);
 			exit(1);
 		}
 		break;
 	case ask_silent:
 		if (stat(".config", &tmpstat)) {
 			printf("***\n"
-				"*** You have not yet configured your kernel!\n"
+				"*** You have not yet configured!\n"
 				"***\n"
 				"*** Please run some configurator (e.g. \"make oldconfig\" or\n"
 				"*** \"make menuconfig\" or \"make xconfig\").\n"
 				"***\n");
 			exit(1);
 		}
 	case ask_all:
 	case ask_new:
 		conf_read(NULL);
 		break;
 	default:
 		break;
 	}
 
 	if (input_mode != ask_silent) {
 		rootEntry = &rootmenu;
 		conf(&rootmenu);
 		if (input_mode == ask_all) {
 			input_mode = ask_silent;
 			valid_stdin = 1;
 		}
 	}
 	do {
 		conf_cnt = 0;
 		check_conf(&rootmenu);
 	} while (conf_cnt);
 	conf_write(NULL);
 	return 0;
 }
diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c
index 9bf7af9..f3796ce 100644
--- a/scripts/kconfig/confdata.c
+++ b/scripts/kconfig/confdata.c
@@ -1,378 +1,422 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <sys/stat.h>
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 
 const char conf_def_filename[] = ".config";
 
 const char conf_defname[] = "arch/$ARCH/defconfig";
 
 const char *conf_confnames[] = {
 	".config",
-	"/lib/modules/$UNAME_RELEASE/.config",
-	"/etc/kernel-config",
-	"/boot/config-$UNAME_RELEASE",
 	conf_defname,
 	NULL,
 };
 
 static char *conf_expand_value(const char *in)
 {
 	struct symbol *sym;
 	const char *src;
 	static char res_value[SYMBOL_MAXLENGTH];
 	char *dst, name[SYMBOL_MAXLENGTH];
 
 	res_value[0] = 0;
 	dst = name;
 	while ((src = strchr(in, '$'))) {
 		strncat(res_value, in, src - in);
 		src++;
 		dst = name;
 		while (isalnum(*src) || *src == '_')
 			*dst++ = *src++;
 		*dst = 0;
 		sym = sym_lookup(name, 0);
 		sym_calc_value(sym);
 		strcat(res_value, sym_get_string_value(sym));
 		in = src;
 	}
 	strcat(res_value, in);
 
 	return res_value;
 }
 
 char *conf_get_default_confname(void)
 {
 	struct stat buf;
 	static char fullname[PATH_MAX+1];
 	char *env, *name;
 
 	name = conf_expand_value(conf_defname);
 	env = getenv(SRCTREE);
 	if (env) {
 		sprintf(fullname, "%s/%s", env, name);
 		if (!stat(fullname, &buf))
 			return fullname;
 	}
 	return name;
 }
 
 int conf_read(const char *name)
 {
 	FILE *in = NULL;
 	char line[1024];
 	char *p, *p2;
 	int lineno = 0;
 	struct symbol *sym;
 	struct property *prop;
 	struct expr *e;
 	int i;
 
 	if (name) {
 		in = zconf_fopen(name);
 	} else {
 		const char **names = conf_confnames;
 		while ((name = *names++)) {
 			name = conf_expand_value(name);
 			in = zconf_fopen(name);
 			if (in) {
 				printf("#\n"
 				       "# using defaults found in %s\n"
 				       "#\n", name);
 				break;
 			}
 		}
 	}
 
 	if (!in)
 		return 1;
 
 	for_all_symbols(i, sym) {
 		sym->flags |= SYMBOL_NEW | SYMBOL_CHANGED;
 		sym->flags &= ~SYMBOL_VALID;
 		switch (sym->type) {
 		case S_INT:
 		case S_HEX:
 		case S_STRING:
-			if (S_VAL(sym->def))
-				free(S_VAL(sym->def));
+			if (sym->user.val)
+				free(sym->user.val);
 		default:
-			S_VAL(sym->def) = NULL;
-			S_TRI(sym->def) = no;
+			sym->user.val = NULL;
+			sym->user.tri = no;
 		}
 	}
 
 	while (fgets(line, sizeof(line), in)) {
 		lineno++;
 		switch (line[0]) {
 		case '#':
 			if (memcmp(line + 2, "CONFIG_", 7))
 				continue;
 			p = strchr(line + 9, ' ');
 			if (!p)
 				continue;
 			*p++ = 0;
 			if (strncmp(p, "is not set", 10))
 				continue;
 			sym = sym_lookup(line + 9, 0);
 			switch (sym->type) {
 			case S_BOOLEAN:
 			case S_TRISTATE:
-				sym->def = symbol_no.curr;
+				sym->user = symbol_no.curr;
 				sym->flags &= ~SYMBOL_NEW;
 				break;
 			default:
 				;
 			}
 			break;
 		case 'C':
 			if (memcmp(line, "CONFIG_", 7))
 				continue;
 			p = strchr(line + 7, '=');
 			if (!p)
 				continue;
 			*p++ = 0;
 			p2 = strchr(p, '\n');
 			if (p2)
 				*p2 = 0;
 			sym = sym_find(line + 7);
 			if (!sym) {
 				fprintf(stderr, "%s:%d: trying to assign nonexistent symbol %s\n", name, lineno, line + 7);
 				break;
 			}
 			switch (sym->type) {
 			case S_TRISTATE:
 				if (p[0] == 'm') {
-					S_TRI(sym->def) = mod;
+					sym->user.tri = mod;
 					sym->flags &= ~SYMBOL_NEW;
 					break;
 				}
 			case S_BOOLEAN:
 				if (p[0] == 'y') {
-					S_TRI(sym->def) = yes;
+					sym->user.tri = yes;
 					sym->flags &= ~SYMBOL_NEW;
 					break;
 				}
 				if (p[0] == 'n') {
-					S_TRI(sym->def) = no;
+					sym->user.tri = no;
 					sym->flags &= ~SYMBOL_NEW;
 					break;
 				}
 				break;
 			case S_STRING:
 				if (*p++ != '"')
 					break;
 				for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
 					if (*p2 == '"') {
 						*p2 = 0;
 						break;
 					}
 					memmove(p2, p2 + 1, strlen(p2));
 				}
 				if (!p2) {
 					fprintf(stderr, "%s:%d: invalid string found\n", name, lineno);
 					exit(1);
 				}
 			case S_INT:
 			case S_HEX:
 				if (sym_string_valid(sym, p)) {
-					S_VAL(sym->def) = strdup(p);
+					sym->user.val = strdup(p);
 					sym->flags &= ~SYMBOL_NEW;
 				} else {
 					fprintf(stderr, "%s:%d: symbol value '%s' invalid for %s\n", name, lineno, p, sym->name);
 					exit(1);
 				}
 				break;
 			default:
 				;
 			}
 			if (sym_is_choice_value(sym)) {
-				prop = sym_get_choice_prop(sym);
-				switch (S_TRI(sym->def)) {
+				struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
+				switch (sym->user.tri) {
 				case mod:
-					if (S_TRI(prop->def->def) == yes)
+					if (cs->user.tri == yes)
 						/* warn? */;
 					break;
 				case yes:
-					if (S_TRI(prop->def->def) != no)
+					if (cs->user.tri != no)
 						/* warn? */;
-					S_VAL(prop->def->def) = sym;
+					cs->user.val = sym;
 					break;
 				case no:
 					break;
 				}
-				S_TRI(prop->def->def) = S_TRI(sym->def);
+				cs->user.tri = sym->user.tri;
 			}
 			break;
 		case '\n':
 			break;
 		default:
 			continue;
 		}
 	}
 	fclose(in);
 
 	for_all_symbols(i, sym) {
+		sym_calc_value(sym);
+		if (sym_has_value(sym)) {
+			if (sym->visible == no)
+				sym->flags |= SYMBOL_NEW;
+			switch (sym->type) {
+			case S_STRING:
+			case S_INT:
+			case S_HEX:
+				if (!sym_string_within_range(sym, sym->user.val))
+					sym->flags |= SYMBOL_NEW;
+			default:
+				break;
+			}
+		}
 		if (!sym_is_choice(sym))
 			continue;
 		prop = sym_get_choice_prop(sym);
 		sym->flags &= ~SYMBOL_NEW;
-		for (e = prop->dep; e; e = e->left.expr)
-			sym->flags |= e->right.sym->flags & SYMBOL_NEW;
+		for (e = prop->expr; e; e = e->left.expr)
+			if (e->right.sym->visible != no)
+				sym->flags |= e->right.sym->flags & SYMBOL_NEW;
 	}
 
 	sym_change_count = 1;
 
 	return 0;
 }
 
 int conf_write(const char *name)
 {
 	FILE *out, *out_h;
 	struct symbol *sym;
 	struct menu *menu;
-	char oldname[128];
+	const char *basename;
+	char dirname[128], tmpname[128], newname[128];
 	int type, l;
 	const char *str;
 
-	out = fopen(".tmpconfig", "w");
+	dirname[0] = 0;
+	if (name && name[0]) {
+		char *slash = strrchr(name, '/');
+		if (slash) {
+			int size = slash - name + 1;
+			memcpy(dirname, name, size);
+			dirname[size] = 0;
+			if (slash[1])
+				basename = slash + 1;
+			else
+				basename = conf_def_filename;
+		} else
+			basename = name;
+	} else
+		basename = conf_def_filename;
+
+	sprintf(newname, "%s.tmpconfig.%d", dirname, getpid());
+	out = fopen(newname, "w");
 	if (!out)
 		return 1;
-	out_h = fopen(".tmpconfig.h", "w");
-	if (!out_h)
-		return 1;
+	out_h = NULL;
+	if (!name) {
+		out_h = fopen(".tmpconfig.h", "w");
+		if (!out_h)
+			return 1;
+	}
 	fprintf(out, "#\n"
 		     "# Automatically generated make config: don't edit\n"
 		     "#\n");
-	fprintf(out_h, "/*\n"
-		       " * Automatically generated C config: don't edit\n"
-		       " */\n"
-		       "#define AUTOCONF_INCLUDED\n");
+	if (out_h)
+		fprintf(out_h, "/*\n"
+			       " * Automatically generated C config: don't edit\n"
+			       " */\n"
+			       "#define AUTOCONF_INCLUDED\n");
 
 	if (!sym_change_count)
 		sym_clear_all_valid();
 
 	menu = rootmenu.list;
 	while (menu) {
 		sym = menu->sym;
 		if (!sym) {
 			if (!menu_is_visible(menu))
 				goto next;
 			str = menu_get_prompt(menu);
 			fprintf(out, "\n"
 				     "#\n"
 				     "# %s\n"
 				     "#\n", str);
-			fprintf(out_h, "\n"
-				       "/*\n"
-				       " * %s\n"
-				       " */\n", str);
+			if (out_h)
+				fprintf(out_h, "\n"
+					       "/*\n"
+					       " * %s\n"
+					       " */\n", str);
 		} else if (!(sym->flags & SYMBOL_CHOICE)) {
 			sym_calc_value(sym);
 			if (!(sym->flags & SYMBOL_WRITE))
 				goto next;
 			sym->flags &= ~SYMBOL_WRITE;
 			type = sym->type;
 			if (type == S_TRISTATE) {
 				sym_calc_value(modules_sym);
-				if (S_TRI(modules_sym->curr) == no)
+				if (modules_sym->curr.tri == no)
 					type = S_BOOLEAN;
 			}
 			switch (type) {
 			case S_BOOLEAN:
 			case S_TRISTATE:
 				switch (sym_get_tristate_value(sym)) {
 				case no:
 					fprintf(out, "# CONFIG_%s is not set\n", sym->name);
-					fprintf(out_h, "#undef CONFIG_%s\n", sym->name);
+					if (out_h)
+						fprintf(out_h, "#undef CONFIG_%s\n", sym->name);
 					break;
 				case mod:
 					fprintf(out, "CONFIG_%s=m\n", sym->name);
-					fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
+					if (out_h)
+						fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
 					break;
 				case yes:
 					fprintf(out, "CONFIG_%s=y\n", sym->name);
-					fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
+					if (out_h)
+						fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
 					break;
 				}
 				break;
 			case S_STRING:
 				// fix me
 				str = sym_get_string_value(sym);
 				fprintf(out, "CONFIG_%s=\"", sym->name);
-				fprintf(out_h, "#define CONFIG_%s \"", sym->name);
+				if (out_h)
+					fprintf(out_h, "#define CONFIG_%s \"", sym->name);
 				do {
 					l = strcspn(str, "\"\\");
 					if (l) {
 						fwrite(str, l, 1, out);
-						fwrite(str, l, 1, out_h);
+						if (out_h)
+							fwrite(str, l, 1, out_h);
 					}
 					str += l;
 					while (*str == '\\' || *str == '"') {
 						fprintf(out, "\\%c", *str);
-						fprintf(out_h, "\\%c", *str);
+						if (out_h)
+							fprintf(out_h, "\\%c", *str);
 						str++;
 					}
 				} while (*str);
 				fputs("\"\n", out);
-				fputs("\"\n", out_h);
+				if (out_h)
+					fputs("\"\n", out_h);
 				break;
 			case S_HEX:
 				str = sym_get_string_value(sym);
 				if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
 					fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
-					fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
+					if (out_h)
+						fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
 					break;
 				}
 			case S_INT:
 				str = sym_get_string_value(sym);
 				fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
-				fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
+				if (out_h)
+					fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
 				break;
 			}
 		}
 
 	next:
 		if (menu->list) {
 			menu = menu->list;
 			continue;
 		}
 		if (menu->next)
 			menu = menu->next;
 		else while ((menu = menu->parent)) {
 			if (menu->next) {
 				menu = menu->next;
 				break;
 			}
 		}
 	}
 	fclose(out);
-	fclose(out_h);
-
-	if (!name) {
+	if (out_h) {
+		fclose(out_h);
 		rename(".tmpconfig.h", "include/linux/autoconf.h");
-		name = conf_def_filename;
-		file_write_dep(NULL);
-	} else
-		unlink(".tmpconfig.h");
-
-	sprintf(oldname, "%s.old", name);
-	rename(name, oldname);
-	if (rename(".tmpconfig", name))
+	}
+	if (!name || basename != conf_def_filename) {
+		if (!name)
+			name = conf_def_filename;
+		sprintf(tmpname, "%s.old", name);
+		rename(name, tmpname);
+	}
+	sprintf(tmpname, "%s%s", dirname, basename);
+	if (rename(newname, tmpname))
 		return 1;
 
 	sym_change_count = 0;
 
 	return 0;
 }
diff --git a/scripts/kconfig/expr.c b/scripts/kconfig/expr.c
index d1af2a5..3f15ae8 100644
--- a/scripts/kconfig/expr.c
+++ b/scripts/kconfig/expr.c
@@ -1,1054 +1,1083 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 
 struct expr *expr_alloc_symbol(struct symbol *sym)
 {
 	struct expr *e = malloc(sizeof(*e));
 	memset(e, 0, sizeof(*e));
 	e->type = E_SYMBOL;
 	e->left.sym = sym;
 	return e;
 }
 
 struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
 {
 	struct expr *e = malloc(sizeof(*e));
 	memset(e, 0, sizeof(*e));
 	e->type = type;
 	e->left.expr = ce;
 	return e;
 }
 
 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2)
 {
 	struct expr *e = malloc(sizeof(*e));
 	memset(e, 0, sizeof(*e));
 	e->type = type;
 	e->left.expr = e1;
 	e->right.expr = e2;
 	return e;
 }
 
 struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
 {
 	struct expr *e = malloc(sizeof(*e));
 	memset(e, 0, sizeof(*e));
 	e->type = type;
 	e->left.sym = s1;
 	e->right.sym = s2;
 	return e;
 }
 
 struct expr *expr_alloc_and(struct expr *e1, struct expr *e2)
 {
 	if (!e1)
 		return e2;
 	return e2 ? expr_alloc_two(E_AND, e1, e2) : e1;
 }
 
+struct expr *expr_alloc_or(struct expr *e1, struct expr *e2)
+{
+	if (!e1)
+		return e2;
+	return e2 ? expr_alloc_two(E_OR, e1, e2) : e1;
+}
+
 struct expr *expr_copy(struct expr *org)
 {
 	struct expr *e;
 
 	if (!org)
 		return NULL;
 
 	e = malloc(sizeof(*org));
 	memcpy(e, org, sizeof(*org));
 	switch (org->type) {
 	case E_SYMBOL:
 		e->left = org->left;
 		break;
 	case E_NOT:
 		e->left.expr = expr_copy(org->left.expr);
 		break;
 	case E_EQUAL:
 	case E_UNEQUAL:
 		e->left.sym = org->left.sym;
 		e->right.sym = org->right.sym;
 		break;
 	case E_AND:
 	case E_OR:
 	case E_CHOICE:
 		e->left.expr = expr_copy(org->left.expr);
 		e->right.expr = expr_copy(org->right.expr);
 		break;
 	default:
 		printf("can't copy type %d\n", e->type);
 		free(e);
 		e = NULL;
 		break;
 	}
 
 	return e;
 }
 
 void expr_free(struct expr *e)
 {
 	if (!e)
 		return;
 
 	switch (e->type) {
 	case E_SYMBOL:
 		break;
 	case E_NOT:
 		expr_free(e->left.expr);
 		return;
 	case E_EQUAL:
 	case E_UNEQUAL:
 		break;
 	case E_OR:
 	case E_AND:
 		expr_free(e->left.expr);
 		expr_free(e->right.expr);
 		break;
 	default:
 		printf("how to free type %d?\n", e->type);
 		break;
 	}
 	free(e);
 }
 
 static int trans_count;
 
 #define e1 (*ep1)
 #define e2 (*ep2)
 
 static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2)
 {
 	if (e1->type == type) {
 		__expr_eliminate_eq(type, &e1->left.expr, &e2);
 		__expr_eliminate_eq(type, &e1->right.expr, &e2);
 		return;
 	}
 	if (e2->type == type) {
 		__expr_eliminate_eq(type, &e1, &e2->left.expr);
 		__expr_eliminate_eq(type, &e1, &e2->right.expr);
 		return;
 	}
 	if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
 	    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 (type) {
 	case E_OR:
 		e1 = expr_alloc_symbol(&symbol_no);
 		e2 = expr_alloc_symbol(&symbol_no);
 		break;
 	case E_AND:
 		e1 = expr_alloc_symbol(&symbol_yes);
 		e2 = expr_alloc_symbol(&symbol_yes);
 		break;
 	default:
 		;
 	}
 }
 
 void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
 {
-	if (!e1 || !e2 || e1->type != e2->type)
+	if (!e1 || !e2)
 		return;
-	__expr_eliminate_eq(e1->type, ep1, ep2);
+	switch (e1->type) {
+	case E_OR:
+	case E_AND:
+		__expr_eliminate_eq(e1->type, ep1, ep2);
+	default:
+		;
+	}
+	if (e1->type != e2->type) switch (e2->type) {
+	case E_OR:
+	case E_AND:
+		__expr_eliminate_eq(e2->type, ep1, ep2);
+	default:
+		;
+	}
 	e1 = expr_eliminate_yn(e1);
 	e2 = expr_eliminate_yn(e2);
 }
 
 #undef e1
 #undef e2
 
 int expr_eq(struct expr *e1, struct expr *e2)
 {
 	int res, old_count;
 
 	if (e1->type != e2->type)
 		return 0;
 	switch (e1->type) {
 	case E_EQUAL:
 	case E_UNEQUAL:
 		return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
 	case E_SYMBOL:
 		return e1->left.sym == e2->left.sym;
 	case E_NOT:
 		return expr_eq(e1->left.expr, e2->left.expr);
 	case E_AND:
 	case E_OR:
 		e1 = expr_copy(e1);
 		e2 = expr_copy(e2);
 		old_count = trans_count;
 		expr_eliminate_eq(&e1, &e2);
 		res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
 		       e1->left.sym == e2->left.sym);
 		expr_free(e1);
 		expr_free(e2);
 		trans_count = old_count;
 		return res;
 	case E_CHOICE:
+	case E_RANGE:
 	case E_NONE:
 		/* panic */;
 	}
 
 	print_expr(0, e1, 0);
 	printf(" = ");
 	print_expr(0, e2, 0);
 	printf(" ?\n");
 
 	return 0;
 }
 
 struct expr *expr_eliminate_yn(struct expr *e)
 {
 	struct expr *tmp;
 
 	if (e) switch (e->type) {
 	case E_AND:
 		e->left.expr = expr_eliminate_yn(e->left.expr);
 		e->right.expr = expr_eliminate_yn(e->right.expr);
 		if (e->left.expr->type == E_SYMBOL) {
 			if (e->left.expr->left.sym == &symbol_no) {
 				expr_free(e->left.expr);
 				expr_free(e->right.expr);
 				e->type = E_SYMBOL;
 				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->type == E_SYMBOL) {
 			if (e->right.expr->left.sym == &symbol_no) {
 				expr_free(e->left.expr);
 				expr_free(e->right.expr);
 				e->type = E_SYMBOL;
 				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 E_OR:
 		e->left.expr = expr_eliminate_yn(e->left.expr);
 		e->right.expr = expr_eliminate_yn(e->right.expr);
 		if (e->left.expr->type == E_SYMBOL) {
 			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->type = E_SYMBOL;
 				e->left.sym = &symbol_yes;
 				e->right.expr = NULL;
 				return e;
 			}
 		}
 		if (e->right.expr->type == E_SYMBOL) {
 			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->type = E_SYMBOL;
 				e->left.sym = &symbol_yes;
 				e->right.expr = NULL;
 				return e;
 			}
 		}
 		break;
 	default:
 		;
 	}
 	return e;
 }
 
 /*
  * bool FOO!=n => FOO
  */
 struct expr *expr_trans_bool(struct expr *e)
 {
 	if (!e)
 		return NULL;
 	switch (e->type) {
 	case E_AND:
 	case E_OR:
 	case E_NOT:
 		e->left.expr = expr_trans_bool(e->left.expr);
 		e->right.expr = expr_trans_bool(e->right.expr);
 		break;
 	case E_UNEQUAL:
 		// FOO!=n -> FOO
 		if (e->left.sym->type == S_TRISTATE) {
 			if (e->right.sym == &symbol_no) {
 				e->type = E_SYMBOL;
 				e->right.sym = NULL;
 			}
 		}
 		break;
 	default:
 		;
 	}
 	return e;
 }
 
 /*
  * e1 || e2 -> ?
  */
 struct expr *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->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
 		return NULL;
 	if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
 		return NULL;
 	if (e1->type == E_NOT) {
 		tmp = e1->left.expr;
 		if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
 			return NULL;
 		sym1 = tmp->left.sym;
 	} else
 		sym1 = e1->left.sym;
 	if (e2->type == E_NOT) {
 		if (e2->left.expr->type != E_SYMBOL)
 			return NULL;
 		sym2 = e2->left.expr->left.sym;
 	} else
 		sym2 = e2->left.sym;
 	if (sym1 != sym2)
 		return NULL;
 	if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
 		return NULL;
 	if (sym1->type == S_TRISTATE) {
 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
 		    ((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(E_UNEQUAL, sym1, &symbol_no);
 		}
 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
 		    ((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(E_UNEQUAL, sym1, &symbol_mod);
 		}
 		if (e1->type == E_EQUAL && e2->type == E_EQUAL &&
 		    ((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(E_UNEQUAL, sym1, &symbol_yes);
 		}
 	}
 	if (sym1->type == S_BOOLEAN && sym1 == sym2) {
 		if ((e1->type == E_NOT && e1->left.expr->type == E_SYMBOL && e2->type == E_SYMBOL) ||
 		    (e2->type == E_NOT && e2->left.expr->type == E_SYMBOL && e1->type == E_SYMBOL))
 			return expr_alloc_symbol(&symbol_yes);
 	}
 
 	printf("optimize ");
 	print_expr(0, e1, 0);
 	printf(" || ");
 	print_expr(0, e2, 0);
 	printf(" ?\n");
 	return NULL;
 }
 
 struct expr *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->type != E_EQUAL && e1->type != E_UNEQUAL && e1->type != E_SYMBOL && e1->type != E_NOT)
 		return NULL;
 	if (e2->type != E_EQUAL && e2->type != E_UNEQUAL && e2->type != E_SYMBOL && e2->type != E_NOT)
 		return NULL;
 	if (e1->type == E_NOT) {
 		tmp = e1->left.expr;
 		if (tmp->type != E_EQUAL && tmp->type != E_UNEQUAL && tmp->type != E_SYMBOL)
 			return NULL;
 		sym1 = tmp->left.sym;
 	} else
 		sym1 = e1->left.sym;
 	if (e2->type == E_NOT) {
 		if (e2->left.expr->type != E_SYMBOL)
 			return NULL;
 		sym2 = e2->left.expr->left.sym;
 	} else
 		sym2 = e2->left.sym;
 	if (sym1 != sym2)
 		return NULL;
 	if (sym1->type != S_BOOLEAN && sym1->type != S_TRISTATE)
 		return NULL;
 
 	if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_yes) ||
 	    (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_yes))
 		// (a) && (a='y') -> (a='y')
 		return expr_alloc_comp(E_EQUAL, sym1, &symbol_yes);
 
 	if ((e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_no) ||
 	    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_no))
 		// (a) && (a!='n') -> (a)
 		return expr_alloc_symbol(sym1);
 
 	if (sym1->type == S_TRISTATE) {
 		if (e1->type == E_EQUAL && e2->type == E_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(E_EQUAL, sym1, sym2)
 							     : expr_alloc_symbol(&symbol_no);
 		}
 		if (e1->type == E_UNEQUAL && e2->type == E_EQUAL) {
 			// (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(E_EQUAL, sym1, sym2)
 							     : expr_alloc_symbol(&symbol_no);
 		}
 		if (e1->type == E_UNEQUAL && e2->type == E_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(E_EQUAL, sym1, &symbol_mod);
 
 		if (e1->type == E_UNEQUAL && e2->type == E_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(E_EQUAL, sym1, &symbol_no);
 
 		if (e1->type == E_UNEQUAL && e2->type == E_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(E_EQUAL, sym1, &symbol_yes);
 
 		if ((e1->type == E_SYMBOL && e2->type == E_EQUAL && e2->right.sym == &symbol_mod) ||
 		    (e2->type == E_SYMBOL && e1->type == E_EQUAL && e1->right.sym == &symbol_mod) ||
 		    (e1->type == E_SYMBOL && e2->type == E_UNEQUAL && e2->right.sym == &symbol_yes) ||
 		    (e2->type == E_SYMBOL && e1->type == E_UNEQUAL && e1->right.sym == &symbol_yes))
 			return NULL;
 	}
 	printf("optimize ");
 	print_expr(0, e1, 0);
 	printf(" && ");
 	print_expr(0, e2, 0);
 	printf(" ?\n");
 	return NULL;
 }
 
 static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct expr **ep2)
 {
 #define e1 (*ep1)
 #define e2 (*ep2)
 	struct expr *tmp;
 
 	if (e1->type == type) {
 		expr_eliminate_dups1(type, &e1->left.expr, &e2);
 		expr_eliminate_dups1(type, &e1->right.expr, &e2);
 		return;
 	}
 	if (e2->type == type) {
 		expr_eliminate_dups1(type, &e1, &e2->left.expr);
 		expr_eliminate_dups1(type, &e1, &e2->right.expr);
 		return;
 	}
 	if (e1 == e2)
 		return;
 
 	switch (e1->type) {
 	case E_OR: case E_AND:
 		expr_eliminate_dups1(e1->type, &e1, &e1);
 	default:
 		;
 	}
 
 	switch (type) {
 	case E_OR:
 		tmp = expr_join_or(e1, e2);
 		if (tmp) {
 			expr_free(e1); expr_free(e2);
 			e1 = expr_alloc_symbol(&symbol_no);
 			e2 = tmp;
 			trans_count++;
 		}
 		break;
 	case E_AND:
 		tmp = expr_join_and(e1, e2);
 		if (tmp) {
 			expr_free(e1); expr_free(e2);
 			e1 = expr_alloc_symbol(&symbol_yes);
 			e2 = tmp;
 			trans_count++;
 		}
 		break;
 	default:
 		;
 	}
 #undef e1
 #undef e2
 }
 
 static void expr_eliminate_dups2(enum expr_type type, struct expr **ep1, struct expr **ep2)
 {
 #define e1 (*ep1)
 #define e2 (*ep2)
 	struct expr *tmp, *tmp1, *tmp2;
 
 	if (e1->type == type) {
 		expr_eliminate_dups2(type, &e1->left.expr, &e2);
 		expr_eliminate_dups2(type, &e1->right.expr, &e2);
 		return;
 	}
 	if (e2->type == type) {
 		expr_eliminate_dups2(type, &e1, &e2->left.expr);
 		expr_eliminate_dups2(type, &e1, &e2->right.expr);
 	}
 	if (e1 == e2)
 		return;
 
 	switch (e1->type) {
 	case E_OR:
 		expr_eliminate_dups2(e1->type, &e1, &e1);
 		// (FOO || BAR) && (!FOO && !BAR) -> n
 		tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
 		tmp2 = expr_copy(e2);
 		tmp = expr_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 E_AND:
 		expr_eliminate_dups2(e1->type, &e1, &e1);
 		// (FOO && BAR) || (!FOO || !BAR) -> y
 		tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
 		tmp2 = expr_copy(e2);
 		tmp = expr_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;
 	default:
 		;
 	}
 #undef e1
 #undef e2
 }
 
 struct expr *expr_eliminate_dups(struct expr *e)
 {
 	int oldcount;
 	if (!e)
 		return e;
 
 	oldcount = trans_count;
 	while (1) {
 		trans_count = 0;
 		switch (e->type) {
 		case E_OR: case E_AND:
 			expr_eliminate_dups1(e->type, &e, &e);
 			expr_eliminate_dups2(e->type, &e, &e);
 		default:
 			;
 		}
 		if (!trans_count)
 			break;
 		e = expr_eliminate_yn(e);
 	}
 	trans_count = oldcount;
 	return e;
 }
 
 struct expr *expr_transform(struct expr *e)
 {
 	struct expr *tmp;
 
 	if (!e)
 		return NULL;
 	switch (e->type) {
 	case E_EQUAL:
 	case E_UNEQUAL:
 	case E_SYMBOL:
 	case E_CHOICE:
 		break;
 	default:
 		e->left.expr = expr_transform(e->left.expr);
 		e->right.expr = expr_transform(e->right.expr);
 	}
 
 	switch (e->type) {
 	case E_EQUAL:
 		if (e->left.sym->type != S_BOOLEAN)
 			break;
 		if (e->right.sym == &symbol_no) {
 			e->type = E_NOT;
 			e->left.expr = expr_alloc_symbol(e->left.sym);
 			e->right.sym = NULL;
 			break;
 		}
 		if (e->right.sym == &symbol_mod) {
 			printf("boolean symbol %s tested for 'm'? test forced to 'n'\n", e->left.sym->name);
 			e->type = E_SYMBOL;
 			e->left.sym = &symbol_no;
 			e->right.sym = NULL;
 			break;
 		}
 		if (e->right.sym == &symbol_yes) {
 			e->type = E_SYMBOL;
 			e->right.sym = NULL;
 			break;
 		}
 		break;
 	case E_UNEQUAL:
 		if (e->left.sym->type != S_BOOLEAN)
 			break;
 		if (e->right.sym == &symbol_no) {
 			e->type = E_SYMBOL;
 			e->right.sym = NULL;
 			break;
 		}
 		if (e->right.sym == &symbol_mod) {
 			printf("boolean symbol %s tested for 'm'? test forced to 'y'\n", e->left.sym->name);
 			e->type = E_SYMBOL;
 			e->left.sym = &symbol_yes;
 			e->right.sym = NULL;
 			break;
 		}
 		if (e->right.sym == &symbol_yes) {
 			e->type = E_NOT;
 			e->left.expr = expr_alloc_symbol(e->left.sym);
 			e->right.sym = NULL;
 			break;
 		}
 		break;
 	case E_NOT:
 		switch (e->left.expr->type) {
 		case E_NOT:
 			// !!a -> a
 			tmp = e->left.expr->left.expr;
 			free(e->left.expr);
 			free(e);
 			e = tmp;
 			e = expr_transform(e);
 			break;
 		case E_EQUAL:
 		case E_UNEQUAL:
 			// !a='x' -> a!='x'
 			tmp = e->left.expr;
 			free(e);
 			e = tmp;
 			e->type = e->type == E_EQUAL ? E_UNEQUAL : E_EQUAL;
 			break;
 		case E_OR:
 			// !(a || b) -> !a && !b
 			tmp = e->left.expr;
 			e->type = E_AND;
 			e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
 			tmp->type = E_NOT;
 			tmp->right.expr = NULL;
 			e = expr_transform(e);
 			break;
 		case E_AND:
 			// !(a && b) -> !a || !b
 			tmp = e->left.expr;
 			e->type = E_OR;
 			e->right.expr = expr_alloc_one(E_NOT, tmp->right.expr);
 			tmp->type = E_NOT;
 			tmp->right.expr = NULL;
 			e = expr_transform(e);
 			break;
 		case E_SYMBOL:
 			if (e->left.expr->left.sym == &symbol_yes) {
 				// !'y' -> 'n'
 				tmp = e->left.expr;
 				free(e);
 				e = tmp;
 				e->type = E_SYMBOL;
 				e->left.sym = &symbol_no;
 				break;
 			}
 			if (e->left.expr->left.sym == &symbol_mod) {
 				// !'m' -> 'm'
 				tmp = e->left.expr;
 				free(e);
 				e = tmp;
 				e->type = E_SYMBOL;
 				e->left.sym = &symbol_mod;
 				break;
 			}
 			if (e->left.expr->left.sym == &symbol_no) {
 				// !'n' -> 'y'
 				tmp = e->left.expr;
 				free(e);
 				e = tmp;
 				e->type = E_SYMBOL;
 				e->left.sym = &symbol_yes;
 				break;
 			}
 			break;
 		default:
 			;
 		}
 		break;
 	default:
 		;
 	}
 	return e;
 }
 
 int expr_contains_symbol(struct expr *dep, struct symbol *sym)
 {
 	if (!dep)
 		return 0;
 
 	switch (dep->type) {
 	case E_AND:
 	case E_OR:
 		return expr_contains_symbol(dep->left.expr, sym) ||
 		       expr_contains_symbol(dep->right.expr, sym);
 	case E_SYMBOL:
 		return dep->left.sym == sym;
 	case E_EQUAL:
 	case E_UNEQUAL:
 		return dep->left.sym == sym ||
 		       dep->right.sym == sym;
 	case E_NOT:
 		return expr_contains_symbol(dep->left.expr, sym);
 	default:
 		;
 	}
 	return 0;
 }
 
 bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
 {
 	if (!dep)
 		return false;
 
 	switch (dep->type) {
 	case E_AND:
 		return expr_depends_symbol(dep->left.expr, sym) ||
 		       expr_depends_symbol(dep->right.expr, sym);
 	case E_SYMBOL:
 		return dep->left.sym == sym;
 	case E_EQUAL:
 		if (dep->left.sym == sym) {
 			if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod)
 				return true;
 		}
 		break;
 	case E_UNEQUAL:
 		if (dep->left.sym == sym) {
 			if (dep->right.sym == &symbol_no)
 				return true;
 		}
 		break;
 	default:
 		;
 	}
  	return false;
 }
 
 struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
 {
 	struct expr *tmp = NULL;
 	expr_extract_eq(E_AND, &tmp, ep1, ep2);
 	if (tmp) {
 		*ep1 = expr_eliminate_yn(*ep1);
 		*ep2 = expr_eliminate_yn(*ep2);
 	}
 	return tmp;
 }
 
 struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
 {
 	struct expr *tmp = NULL;
 	expr_extract_eq(E_OR, &tmp, ep1, ep2);
 	if (tmp) {
 		*ep1 = expr_eliminate_yn(*ep1);
 		*ep2 = expr_eliminate_yn(*ep2);
 	}
 	return tmp;
 }
 
 void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2)
 {
 #define e1 (*ep1)
 #define e2 (*ep2)
 	if (e1->type == type) {
 		expr_extract_eq(type, ep, &e1->left.expr, &e2);
 		expr_extract_eq(type, ep, &e1->right.expr, &e2);
 		return;
 	}
 	if (e2->type == type) {
 		expr_extract_eq(type, ep, ep1, &e2->left.expr);
 		expr_extract_eq(type, ep, ep1, &e2->right.expr);
 		return;
 	}
 	if (expr_eq(e1, e2)) {
 		*ep = *ep ? expr_alloc_two(type, *ep, e1) : e1;
 		expr_free(e2);
 		if (type == E_AND) {
 			e1 = expr_alloc_symbol(&symbol_yes);
 			e2 = expr_alloc_symbol(&symbol_yes);
 		} else if (type == E_OR) {
 			e1 = expr_alloc_symbol(&symbol_no);
 			e2 = expr_alloc_symbol(&symbol_no);
 		}
 	}
 #undef e1
 #undef e2
 }
 
 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
 {
 	struct expr *e1, *e2;
 
 	if (!e) {
 		e = expr_alloc_symbol(sym);
 		if (type == E_UNEQUAL)
 			e = expr_alloc_one(E_NOT, e);
 		return e;
 	}
 	switch (e->type) {
 	case E_AND:
 		e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
 		e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
 		if (sym == &symbol_yes)
 			e = expr_alloc_two(E_AND, e1, e2);
 		if (sym == &symbol_no)
 			e = expr_alloc_two(E_OR, e1, e2);
 		if (type == E_UNEQUAL)
 			e = expr_alloc_one(E_NOT, e);
 		return e;
 	case E_OR:
 		e1 = expr_trans_compare(e->left.expr, E_EQUAL, sym);
 		e2 = expr_trans_compare(e->right.expr, E_EQUAL, sym);
 		if (sym == &symbol_yes)
 			e = expr_alloc_two(E_OR, e1, e2);
 		if (sym == &symbol_no)
 			e = expr_alloc_two(E_AND, e1, e2);
 		if (type == E_UNEQUAL)
 			e = expr_alloc_one(E_NOT, e);
 		return e;
 	case E_NOT:
 		return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
 	case E_UNEQUAL:
 	case E_EQUAL:
 		if (type == E_EQUAL) {
 			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(E_NOT, expr_copy(e));
 		} else {
 			if (sym == &symbol_yes)
 				return expr_alloc_one(E_NOT, expr_copy(e));
 			if (sym == &symbol_mod)
 				return expr_alloc_symbol(&symbol_yes);
 			if (sym == &symbol_no)
 				return expr_copy(e);
 		}
 		break;
 	case E_SYMBOL:
 		return expr_alloc_comp(type, e->left.sym, sym);
 	case E_CHOICE:
+	case E_RANGE:
 	case E_NONE:
 		/* panic */;
 	}
 	return NULL;
 }
 
 tristate expr_calc_value(struct expr *e)
 {
 	tristate val1, val2;
 	const char *str1, *str2;
 
 	if (!e)
 		return yes;
 
 	switch (e->type) {
 	case E_SYMBOL:
 		sym_calc_value(e->left.sym);
-		return S_TRI(e->left.sym->curr);
+		return e->left.sym->curr.tri;
 	case E_AND:
 		val1 = expr_calc_value(e->left.expr);
 		val2 = expr_calc_value(e->right.expr);
 		return E_AND(val1, val2);
 	case E_OR:
 		val1 = expr_calc_value(e->left.expr);
 		val2 = expr_calc_value(e->right.expr);
 		return E_OR(val1, val2);
 	case E_NOT:
 		val1 = expr_calc_value(e->left.expr);
 		return E_NOT(val1);
 	case E_EQUAL:
 		sym_calc_value(e->left.sym);
 		sym_calc_value(e->right.sym);
 		str1 = sym_get_string_value(e->left.sym);
 		str2 = sym_get_string_value(e->right.sym);
 		return !strcmp(str1, str2) ? yes : no;
 	case E_UNEQUAL:
 		sym_calc_value(e->left.sym);
 		sym_calc_value(e->right.sym);
 		str1 = sym_get_string_value(e->left.sym);
 		str2 = sym_get_string_value(e->right.sym);
 		return !strcmp(str1, str2) ? no : yes;
 	default:
 		printf("expr_calc_value: %d?\n", e->type);
 		return no;
 	}
 }
 
 int expr_compare_type(enum expr_type t1, enum expr_type t2)
 {
 #if 0
 	return 1;
 #else
 	if (t1 == t2)
 		return 0;
 	switch (t1) {
 	case E_EQUAL:
 	case E_UNEQUAL:
 		if (t2 == E_NOT)
 			return 1;
 	case E_NOT:
 		if (t2 == E_AND)
 			return 1;
 	case E_AND:
 		if (t2 == E_OR)
 			return 1;
 	case E_OR:
 		if (t2 == E_CHOICE)
 			return 1;
 	case E_CHOICE:
 		if (t2 == 0)
 			return 1;
 	default:
 		return -1;
 	}
 	printf("[%dgt%d?]", t1, t2);
 	return 0;
 #endif
 }
 
 void expr_print(struct expr *e, void (*fn)(void *, const char *), void *data, int prevtoken)
 {
 	if (!e) {
 		fn(data, "y");
 		return;
 	}
 
 	if (expr_compare_type(prevtoken, e->type) > 0)
 		fn(data, "(");
 	switch (e->type) {
 	case E_SYMBOL:
 		if (e->left.sym->name)
 			fn(data, e->left.sym->name);
 		else
 			fn(data, "<choice>");
 		break;
 	case E_NOT:
 		fn(data, "!");
 		expr_print(e->left.expr, fn, data, E_NOT);
 		break;
 	case E_EQUAL:
 		fn(data, e->left.sym->name);
 		fn(data, "=");
 		fn(data, e->right.sym->name);
 		break;
 	case E_UNEQUAL:
 		fn(data, e->left.sym->name);
 		fn(data, "!=");
 		fn(data, e->right.sym->name);
 		break;
 	case E_OR:
 		expr_print(e->left.expr, fn, data, E_OR);
 		fn(data, " || ");
 		expr_print(e->right.expr, fn, data, E_OR);
 		break;
 	case E_AND:
 		expr_print(e->left.expr, fn, data, E_AND);
 		fn(data, " && ");
 		expr_print(e->right.expr, fn, data, E_AND);
 		break;
 	case E_CHOICE:
+		fn(data, e->right.sym->name);
 		if (e->left.expr) {
-			expr_print(e->left.expr, fn, data, E_CHOICE);
 			fn(data, " ^ ");
+			expr_print(e->left.expr, fn, data, E_CHOICE);
 		}
+		break;
+	case E_RANGE:
+		fn(data, "[");
+		fn(data, e->left.sym->name);
+		fn(data, " ");
 		fn(data, e->right.sym->name);
+		fn(data, "]");
 		break;
 	default:
 	  {
 		char buf[32];
 		sprintf(buf, "<unknown type %d>", e->type);
 		fn(data, buf);
 		break;
 	  }
 	}
 	if (expr_compare_type(prevtoken, e->type) > 0)
 		fn(data, ")");
 }
 
 static void expr_print_file_helper(void *data, const char *str)
 {
 	fwrite(str, strlen(str), 1, data);
 }
 
 void expr_fprint(struct expr *e, FILE *out)
 {
 	expr_print(e, expr_print_file_helper, out, E_NONE);
 }
 
 void print_expr(int mask, struct expr *e, int prevtoken)
 {
 	if (!(cdebug & mask))
 		return;
 	expr_fprint(e, stdout);
 }
 
diff --git a/scripts/kconfig/expr.h b/scripts/kconfig/expr.h
index 896a296..cc616f1 100644
--- a/scripts/kconfig/expr.h
+++ b/scripts/kconfig/expr.h
@@ -1,245 +1,194 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #ifndef EXPR_H
 #define EXPR_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #include <stdio.h>
 #ifndef __cplusplus
 #include <stdbool.h>
 #endif
 
 struct file {
 	struct file *next;
 	struct file *parent;
-#ifdef CML1
-	struct statement *stmt;
-	struct statement *last_stmt;
-#endif
 	char *name;
 	int lineno;
 	int flags;
 };
 
 #define FILE_BUSY		0x0001
 #define FILE_SCANNED		0x0002
 #define FILE_PRINTED		0x0004
 
 typedef enum tristate {
 	no, mod, yes
 } tristate;
 
 enum expr_type {
-	E_NONE, E_OR, E_AND, E_NOT, E_EQUAL, E_UNEQUAL, E_CHOICE, E_SYMBOL
+	E_NONE, E_OR, E_AND, E_NOT, E_EQUAL, E_UNEQUAL, E_CHOICE, E_SYMBOL, E_RANGE
 };
 
 union expr_data {
 	struct expr *expr;
 	struct symbol *sym;
 };
 
 struct expr {
-#ifdef CML1
-	int token;
-#else
 	enum expr_type type;
-#endif
 	union expr_data left, right;
 };
 
-#define E_TRI(ev)	((ev).tri)
-#define E_EXPR(ev)	((ev).expr)
-#define E_CALC(ev)	(E_TRI(ev) = expr_calc_value(E_EXPR(ev)))
-
 #define E_OR(dep1, dep2)	(((dep1)>(dep2))?(dep1):(dep2))
 #define E_AND(dep1, dep2)	(((dep1)<(dep2))?(dep1):(dep2))
 #define E_NOT(dep)		(2-(dep))
 
 struct expr_value {
 	struct expr *expr;
 	tristate tri;
 };
 
-#define S_VAL(sv)	((sv).value)
-#define S_TRI(sv)	((sv).tri)
-#define S_EQ(sv1, sv2)	(S_VAL(sv1) == S_VAL(sv2) || !strcmp(S_VAL(sv1), S_VAL(sv2)))
-
 struct symbol_value {
-	void *value;
+	void *val;
 	tristate tri;
 };
 
 enum symbol_type {
 	S_UNKNOWN, S_BOOLEAN, S_TRISTATE, S_INT, S_HEX, S_STRING, S_OTHER
 };
 
 struct symbol {
 	struct symbol *next;
 	char *name;
 	char *help;
-#ifdef CML1
-	int type;
-#else
 	enum symbol_type type;
-#endif
-	struct symbol_value curr, def;
+	struct symbol_value curr, user;
 	tristate visible;
 	int flags;
 	struct property *prop;
 	struct expr *dep, *dep2;
-	struct menu *menu;
+	struct expr_value rev_dep;
 };
 
 #define for_all_symbols(i, sym) for (i = 0; i < 257; i++) for (sym = symbol_hash[i]; sym; sym = sym->next) if (sym->type != S_OTHER)
 
-#ifdef CML1
-#define SYMBOL_UNKNOWN		S_UNKNOWN
-#define SYMBOL_BOOLEAN		S_BOOLEAN
-#define SYMBOL_TRISTATE		S_TRISTATE
-#define SYMBOL_INT		S_INT
-#define SYMBOL_HEX		S_HEX
-#define SYMBOL_STRING		S_STRING
-#define SYMBOL_OTHER		S_OTHER
-#endif
-
 #define SYMBOL_YES		0x0001
 #define SYMBOL_MOD		0x0002
 #define SYMBOL_NO		0x0004
 #define SYMBOL_CONST		0x0007
 #define SYMBOL_CHECK		0x0008
 #define SYMBOL_CHOICE		0x0010
 #define SYMBOL_CHOICEVAL	0x0020
 #define SYMBOL_PRINTED		0x0040
 #define SYMBOL_VALID		0x0080
 #define SYMBOL_OPTIONAL		0x0100
 #define SYMBOL_WRITE		0x0200
 #define SYMBOL_CHANGED		0x0400
 #define SYMBOL_NEW		0x0800
 #define SYMBOL_AUTO		0x1000
+#define SYMBOL_CHECKED		0x2000
+#define SYMBOL_CHECK_DONE	0x4000
+#define SYMBOL_WARNED		0x8000
 
 #define SYMBOL_MAXLENGTH	256
 #define SYMBOL_HASHSIZE		257
 #define SYMBOL_HASHMASK		0xff
 
 enum prop_type {
-	P_UNKNOWN, P_PROMPT, P_COMMENT, P_MENU, P_ROOTMENU, P_DEFAULT, P_CHOICE
+	P_UNKNOWN, P_PROMPT, P_COMMENT, P_MENU, P_DEFAULT, P_CHOICE, P_SELECT, P_RANGE
 };
 
 struct property {
 	struct property *next;
 	struct symbol *sym;
-#ifdef CML1
-	int token;
-#else
 	enum prop_type type;
-#endif
 	const char *text;
-	struct symbol *def;
 	struct expr_value visible;
-	struct expr *dep;
-	struct expr *dep2;
+	struct expr *expr;
 	struct menu *menu;
 	struct file *file;
 	int lineno;
-#ifdef CML1
-	struct property *next_pos;
-#endif
 };
 
 #define for_all_properties(sym, st, tok) \
 	for (st = sym->prop; st; st = st->next) \
 		if (st->type == (tok))
-#define for_all_prompts(sym, st) for_all_properties(sym, st, P_PROMPT)
 #define for_all_defaults(sym, st) for_all_properties(sym, st, P_DEFAULT)
 #define for_all_choices(sym, st) for_all_properties(sym, st, P_CHOICE)
+#define for_all_prompts(sym, st) \
+	for (st = sym->prop; st; st = st->next) \
+		if (st->text)
 
 struct menu {
 	struct menu *next;
 	struct menu *parent;
 	struct menu *list;
 	struct symbol *sym;
 	struct property *prompt;
 	struct expr *dep;
 	unsigned int flags;
 	//char *help;
 	struct file *file;
 	int lineno;
 	void *data;
 };
 
 #define MENU_CHANGED		0x0001
+#define MENU_ROOT		0x0002
 
 #ifndef SWIG
 
 extern struct file *file_list;
 extern struct file *current_file;
 struct file *lookup_file(const char *name);
 
 extern struct symbol symbol_yes, symbol_no, symbol_mod;
 extern struct symbol *modules_sym;
 extern int cdebug;
-extern int print_type;
 struct expr *expr_alloc_symbol(struct symbol *sym);
-#ifdef CML1
-struct expr *expr_alloc_one(int token, struct expr *ce);
-struct expr *expr_alloc_two(int token, struct expr *e1, struct expr *e2);
-struct expr *expr_alloc_comp(int token, struct symbol *s1, struct symbol *s2);
-#else
 struct expr *expr_alloc_one(enum expr_type type, struct expr *ce);
 struct expr *expr_alloc_two(enum expr_type type, struct expr *e1, struct expr *e2);
 struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2);
-#endif
 struct expr *expr_alloc_and(struct expr *e1, struct expr *e2);
+struct expr *expr_alloc_or(struct expr *e1, struct expr *e2);
 struct expr *expr_copy(struct expr *org);
 void expr_free(struct expr *e);
 int expr_eq(struct expr *e1, struct expr *e2);
 void expr_eliminate_eq(struct expr **ep1, struct expr **ep2);
 tristate expr_calc_value(struct expr *e);
 struct expr *expr_eliminate_yn(struct expr *e);
 struct expr *expr_trans_bool(struct expr *e);
 struct expr *expr_eliminate_dups(struct expr *e);
 struct expr *expr_transform(struct expr *e);
 int expr_contains_symbol(struct expr *dep, struct symbol *sym);
 bool expr_depends_symbol(struct expr *dep, struct symbol *sym);
 struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2);
 struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2);
 void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2);
 struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym);
 
 void expr_fprint(struct expr *e, FILE *out);
 void print_expr(int mask, struct expr *e, int prevtoken);
 
-#ifdef CML1
-static inline int expr_is_yes(struct expr *e)
-{
-	return !e || (e->token == WORD && e->left.sym == &symbol_yes);
-}
-
-static inline int expr_is_no(struct expr *e)
-{
-	return e && (e->token == WORD && e->left.sym == &symbol_no);
-}
-#else
 static inline int expr_is_yes(struct expr *e)
 {
 	return !e || (e->type == E_SYMBOL && e->left.sym == &symbol_yes);
 }
 
 static inline int expr_is_no(struct expr *e)
 {
 	return e && (e->type == E_SYMBOL && e->left.sym == &symbol_no);
 }
 #endif
-#endif
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* EXPR_H */
diff --git a/scripts/kconfig/gconf.c b/scripts/kconfig/gconf.c
new file mode 100644
index 0000000..3227180
--- a/dev/null
+++ b/scripts/kconfig/gconf.c
@@ -0,0 +1,1618 @@
+/* Hey EMACS -*- linux-c -*- */
+/*
+ *
+ * Copyright (C) 2002-2003 Romain Lievin <roms@lpg.ticalc.org>
+ * Released under the terms of the GNU GPL v2.0.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "lkc.h"
+#include "images.c"
+
+#include <glade/glade.h>
+#include <gtk/gtk.h>
+#include <glib.h>
+#include <gdk/gdkkeysyms.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <stdlib.h>
+
+//#define DEBUG
+
+enum {
+	SINGLE_VIEW, SPLIT_VIEW, FULL_VIEW
+};
+
+static gint view_mode = SPLIT_VIEW;
+static gboolean show_name = TRUE;
+static gboolean show_range = TRUE;
+static gboolean show_value = TRUE;
+static gboolean show_all = FALSE;
+static gboolean show_debug = FALSE;
+static gboolean resizeable = FALSE;
+
+static gboolean config_changed = FALSE;
+
+static char nohelp_text[] =
+    "Sorry, no help available for this option yet.\n";
+
+GtkWidget *main_wnd = NULL;
+GtkWidget *tree1_w = NULL;	// left  frame
+GtkWidget *tree2_w = NULL;	// right frame
+GtkWidget *text_w = NULL;
+GtkWidget *hpaned = NULL;
+GtkWidget *vpaned = NULL;
+GtkWidget *back_btn = NULL;
+
+GtkTextTag *tag1, *tag2;
+GdkColor color;
+
+GtkTreeStore *tree1, *tree2, *tree;
+GtkTreeModel *model1, *model2;
+static GtkTreeIter *parents[256] = { 0 };
+static gint indent;
+
+static struct menu *current;
+
+enum {
+	COL_OPTION, COL_NAME, COL_NO, COL_MOD, COL_YES, COL_VALUE,
+	COL_MENU, COL_COLOR, COL_EDIT, COL_PIXBUF,
+	COL_PIXVIS, COL_BTNVIS, COL_BTNACT, COL_BTNINC, COL_BTNRAD,
+	COL_NUMBER
+};
+
+static void display_list(void);
+static void display_tree(struct menu *menu);
+static void display_tree_part(void);
+static void update_tree(struct menu *src, GtkTreeIter * dst);
+static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row);
+static gchar **fill_row(struct menu *menu);
+
+
+/* Helping/Debugging Functions */
+
+
+const char *dbg_print_stype(int val)
+{
+	static char buf[256];
+
+	bzero(buf, 256);
+
+	if (val == S_UNKNOWN)
+		strcpy(buf, "unknown");
+	if (val == S_BOOLEAN)
+		strcpy(buf, "boolean");
+	if (val == S_TRISTATE)
+		strcpy(buf, "tristate");
+	if (val == S_INT)
+		strcpy(buf, "int");
+	if (val == S_HEX)
+		strcpy(buf, "hex");
+	if (val == S_STRING)
+		strcpy(buf, "string");
+	if (val == S_OTHER)
+		strcpy(buf, "other");
+
+#ifdef DEBUG
+	printf("%s", buf);
+#endif
+
+	return buf;
+}
+
+const char *dbg_print_flags(int val)
+{
+	static char buf[256] = { 0 };
+
+	bzero(buf, 256);
+
+	if (val & SYMBOL_YES)
+		strcat(buf, "yes/");
+	if (val & SYMBOL_MOD)
+		strcat(buf, "mod/");
+	if (val & SYMBOL_NO)
+		strcat(buf, "no/");
+	if (val & SYMBOL_CONST)
+		strcat(buf, "const/");
+	if (val & SYMBOL_CHECK)
+		strcat(buf, "check/");
+	if (val & SYMBOL_CHOICE)
+		strcat(buf, "choice/");
+	if (val & SYMBOL_CHOICEVAL)
+		strcat(buf, "choiceval/");
+	if (val & SYMBOL_PRINTED)
+		strcat(buf, "printed/");
+	if (val & SYMBOL_VALID)
+		strcat(buf, "valid/");
+	if (val & SYMBOL_OPTIONAL)
+		strcat(buf, "optional/");
+	if (val & SYMBOL_WRITE)
+		strcat(buf, "write/");
+	if (val & SYMBOL_CHANGED)
+		strcat(buf, "changed/");
+	if (val & SYMBOL_NEW)
+		strcat(buf, "new/");
+	if (val & SYMBOL_AUTO)
+		strcat(buf, "auto/");
+
+	buf[strlen(buf) - 1] = '\0';
+#ifdef DEBUG
+	printf("%s", buf);
+#endif
+
+	return buf;
+}
+
+const char *dbg_print_ptype(int val)
+{
+	static char buf[256];
+
+	bzero(buf, 256);
+
+	if (val == P_UNKNOWN)
+		strcpy(buf, "unknown");
+	if (val == P_PROMPT)
+		strcpy(buf, "prompt");
+	if (val == P_COMMENT)
+		strcpy(buf, "comment");
+	if (val == P_MENU)
+		strcpy(buf, "menu");
+	if (val == P_DEFAULT)
+		strcpy(buf, "default");
+	if (val == P_CHOICE)
+		strcpy(buf, "choice");
+
+#ifdef DEBUG
+	printf("%s", buf);
+#endif
+
+	return buf;
+}
+
+
+/* Main Window Initialization */
+
+
+void init_main_window(const gchar * glade_file)
+{
+	GladeXML *xml;
+	GtkWidget *widget;
+	GtkTextBuffer *txtbuf;
+	char title[256];
+	GdkPixmap *pixmap;
+	GdkBitmap *mask;
+	GtkStyle *style;
+
+	xml = glade_xml_new(glade_file, "window1", NULL);
+	if (!xml)
+		g_error("GUI loading failed !\n");
+	glade_xml_signal_autoconnect(xml);
+
+	main_wnd = glade_xml_get_widget(xml, "window1");
+	hpaned = glade_xml_get_widget(xml, "hpaned1");
+	vpaned = glade_xml_get_widget(xml, "vpaned1");
+	tree1_w = glade_xml_get_widget(xml, "treeview1");
+	tree2_w = glade_xml_get_widget(xml, "treeview2");
+	text_w = glade_xml_get_widget(xml, "textview3");
+
+	back_btn = glade_xml_get_widget(xml, "button1");
+	gtk_widget_set_sensitive(back_btn, FALSE);
+
+	widget = glade_xml_get_widget(xml, "show_name1");
+	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
+				       show_name);
+
+	widget = glade_xml_get_widget(xml, "show_range1");
+	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
+				       show_range);
+
+	widget = glade_xml_get_widget(xml, "show_data1");
+	gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
+				       show_value);
+
+	style = gtk_widget_get_style(main_wnd);
+	widget = glade_xml_get_widget(xml, "toolbar1");
+
+	pixmap = gdk_pixmap_create_from_xpm_d(main_wnd->window, &mask,
+					      &style->bg[GTK_STATE_NORMAL],
+					      (gchar **) xpm_single_view);
+	gtk_image_set_from_pixmap(GTK_IMAGE
+				  (((GtkToolbarChild
+				     *) (g_list_nth(GTK_TOOLBAR(widget)->
+						    children,
+						    5)->data))->icon),
+				  pixmap, mask);
+	pixmap =
+	    gdk_pixmap_create_from_xpm_d(main_wnd->window, &mask,
+					 &style->bg[GTK_STATE_NORMAL],
+					 (gchar **) xpm_split_view);
+	gtk_image_set_from_pixmap(GTK_IMAGE
+				  (((GtkToolbarChild
+				     *) (g_list_nth(GTK_TOOLBAR(widget)->
+						    children,
+						    6)->data))->icon),
+				  pixmap, mask);
+	pixmap =
+	    gdk_pixmap_create_from_xpm_d(main_wnd->window, &mask,
+					 &style->bg[GTK_STATE_NORMAL],
+					 (gchar **) xpm_tree_view);
+	gtk_image_set_from_pixmap(GTK_IMAGE
+				  (((GtkToolbarChild
+				     *) (g_list_nth(GTK_TOOLBAR(widget)->
+						    children,
+						    7)->data))->icon),
+				  pixmap, mask);
+
+	switch (view_mode) {
+	case SINGLE_VIEW:
+		widget = glade_xml_get_widget(xml, "button4");
+		gtk_button_clicked(GTK_BUTTON(widget));
+		break;
+	case SPLIT_VIEW:
+		widget = glade_xml_get_widget(xml, "button5");
+		gtk_button_clicked(GTK_BUTTON(widget));
+		break;
+	case FULL_VIEW:
+		widget = glade_xml_get_widget(xml, "button6");
+		gtk_button_clicked(GTK_BUTTON(widget));
+		break;
+	}
+
+	txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
+	tag1 = gtk_text_buffer_create_tag(txtbuf, "mytag1",
+					  "foreground", "red",
+					  "weight", PANGO_WEIGHT_BOLD,
+					  NULL);
+	tag2 = gtk_text_buffer_create_tag(txtbuf, "mytag2",
+					  /*"style", PANGO_STYLE_OBLIQUE, */
+					  NULL);
+
+	sprintf(title, "Build Configuration")
+	gtk_window_set_title(GTK_WINDOW(main_wnd), title);
+
+	gtk_widget_show(main_wnd);
+}
+
+void init_tree_model(void)
+{
+	gint i;
+
+	tree = tree2 = gtk_tree_store_new(COL_NUMBER,
+					  G_TYPE_STRING, G_TYPE_STRING,
+					  G_TYPE_STRING, G_TYPE_STRING,
+					  G_TYPE_STRING, G_TYPE_STRING,
+					  G_TYPE_POINTER, GDK_TYPE_COLOR,
+					  G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF,
+					  G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
+					  G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
+					  G_TYPE_BOOLEAN);
+	model2 = GTK_TREE_MODEL(tree2);
+
+	for (parents[0] = NULL, i = 1; i < 256; i++)
+		parents[i] = (GtkTreeIter *) g_malloc(sizeof(GtkTreeIter));
+
+	tree1 = gtk_tree_store_new(COL_NUMBER,
+				   G_TYPE_STRING, G_TYPE_STRING,
+				   G_TYPE_STRING, G_TYPE_STRING,
+				   G_TYPE_STRING, G_TYPE_STRING,
+				   G_TYPE_POINTER, GDK_TYPE_COLOR,
+				   G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF,
+				   G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
+				   G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
+				   G_TYPE_BOOLEAN);
+	model1 = GTK_TREE_MODEL(tree1);
+}
+
+void init_left_tree(void)
+{
+	GtkTreeView *view = GTK_TREE_VIEW(tree1_w);
+	GtkCellRenderer *renderer;
+	GtkTreeSelection *sel;
+
+	gtk_tree_view_set_model(view, model1);
+	gtk_tree_view_set_headers_visible(view, TRUE);
+	gtk_tree_view_set_rules_hint(view, FALSE);
+
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_insert_column_with_attributes(view, -1,
+						    "Options", renderer,
+						    "text", COL_OPTION,
+						    "foreground-gdk",
+						    COL_COLOR, NULL);
+
+	sel = gtk_tree_view_get_selection(view);
+	gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
+	gtk_widget_realize(tree1_w);
+}
+
+static void renderer_edited(GtkCellRendererText * cell,
+			    const gchar * path_string,
+			    const gchar * new_text, gpointer user_data);
+static void renderer_toggled(GtkCellRendererToggle * cellrenderertoggle,
+			     gchar * arg1, gpointer user_data);
+
+void init_right_tree(void)
+{
+	GtkTreeView *view = GTK_TREE_VIEW(tree2_w);
+	GtkCellRenderer *renderer;
+	GtkTreeSelection *sel;
+	GtkTreeViewColumn *column;
+	gint i;
+
+	gtk_tree_view_set_model(view, model2);
+	gtk_tree_view_set_headers_visible(view, TRUE);
+	gtk_tree_view_set_rules_hint(view, FALSE);
+
+	column = gtk_tree_view_column_new();
+	gtk_tree_view_append_column(view, column);
+	gtk_tree_view_column_set_title(column, "Options");
+
+	renderer = gtk_cell_renderer_pixbuf_new();
+	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
+					renderer, FALSE);
+	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
+					    renderer,
+					    "pixbuf", COL_PIXBUF,
+					    "visible", COL_PIXVIS, NULL);
+	renderer = gtk_cell_renderer_toggle_new();
+	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
+					renderer, FALSE);
+	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
+					    renderer,
+					    "active", COL_BTNACT,
+					    "inconsistent", COL_BTNINC,
+					    "visible", COL_BTNVIS, 
+					    "radio", COL_BTNRAD, NULL);
+	/*g_signal_connect(G_OBJECT(renderer), "toggled",
+	   G_CALLBACK(renderer_toggled), NULL); */
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
+					renderer, FALSE);
+	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
+					    renderer,
+					    "text", COL_OPTION,
+					    "foreground-gdk",
+					    COL_COLOR, NULL);
+
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_insert_column_with_attributes(view, -1,
+						    "Name", renderer,
+						    "text", COL_NAME,
+						    "foreground-gdk",
+						    COL_COLOR, NULL);
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_insert_column_with_attributes(view, -1,
+						    "N", renderer,
+						    "text", COL_NO,
+						    "foreground-gdk",
+						    COL_COLOR, NULL);
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_insert_column_with_attributes(view, -1,
+						    "M", renderer,
+						    "text", COL_MOD,
+						    "foreground-gdk",
+						    COL_COLOR, NULL);
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_insert_column_with_attributes(view, -1,
+						    "Y", renderer,
+						    "text", COL_YES,
+						    "foreground-gdk",
+						    COL_COLOR, NULL);
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_insert_column_with_attributes(view, -1,
+						    "Value", renderer,
+						    "text", COL_VALUE,
+						    "editable",
+						    COL_EDIT,
+						    "foreground-gdk",
+						    COL_COLOR, NULL);
+	g_signal_connect(G_OBJECT(renderer), "edited",
+			 G_CALLBACK(renderer_edited), NULL);
+
+	column = gtk_tree_view_get_column(view, COL_NAME);
+	gtk_tree_view_column_set_visible(column, show_name);
+	column = gtk_tree_view_get_column(view, COL_NO);
+	gtk_tree_view_column_set_visible(column, show_range);
+	column = gtk_tree_view_get_column(view, COL_MOD);
+	gtk_tree_view_column_set_visible(column, show_range);
+	column = gtk_tree_view_get_column(view, COL_YES);
+	gtk_tree_view_column_set_visible(column, show_range);
+	column = gtk_tree_view_get_column(view, COL_VALUE);
+	gtk_tree_view_column_set_visible(column, show_value);
+
+	if (resizeable) {
+		for (i = 0; i < COL_VALUE; i++) {
+			column = gtk_tree_view_get_column(view, i);
+			gtk_tree_view_column_set_resizable(column, TRUE);
+		}
+	}
+
+	sel = gtk_tree_view_get_selection(view);
+	gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
+}
+
+
+/* Utility Functions */
+
+
+static void text_insert_help(struct menu *menu)
+{
+	GtkTextBuffer *buffer;
+	GtkTextIter start, end;
+	const char *prompt = menu_get_prompt(menu);
+	gchar *name;
+	const char *help = nohelp_text;
+
+	if (!menu->sym)
+		help = "";
+	else if (menu->sym->help)
+		help = menu->sym->help;
+
+	if (menu->sym && menu->sym->name)
+		name = g_strdup_printf(menu->sym->name);
+	else
+		name = g_strdup("");
+
+	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
+	gtk_text_buffer_get_bounds(buffer, &start, &end);
+	gtk_text_buffer_delete(buffer, &start, &end);
+	gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
+
+	gtk_text_buffer_get_end_iter(buffer, &end);
+	gtk_text_buffer_insert_with_tags(buffer, &end, prompt, -1, tag1,
+					 NULL);
+	gtk_text_buffer_insert_at_cursor(buffer, " ", 1);
+	gtk_text_buffer_get_end_iter(buffer, &end);
+	gtk_text_buffer_insert_with_tags(buffer, &end, name, -1, tag1,
+					 NULL);
+	gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
+	gtk_text_buffer_get_end_iter(buffer, &end);
+	gtk_text_buffer_insert_with_tags(buffer, &end, help, -1, tag2,
+					 NULL);
+}
+
+
+static void text_insert_msg(const char *title, const char *message)
+{
+	GtkTextBuffer *buffer;
+	GtkTextIter start, end;
+	const char *msg = message;
+
+	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
+	gtk_text_buffer_get_bounds(buffer, &start, &end);
+	gtk_text_buffer_delete(buffer, &start, &end);
+	gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
+
+	gtk_text_buffer_get_end_iter(buffer, &end);
+	gtk_text_buffer_insert_with_tags(buffer, &end, title, -1, tag1,
+					 NULL);
+	gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
+	gtk_text_buffer_get_end_iter(buffer, &end);
+	gtk_text_buffer_insert_with_tags(buffer, &end, msg, -1, tag2,
+					 NULL);
+}
+
+
+/* Main Windows Callbacks */
+
+void on_save1_activate(GtkMenuItem * menuitem, gpointer user_data);
+gboolean on_window1_delete_event(GtkWidget * widget, GdkEvent * event,
+				 gpointer user_data)
+{
+	GtkWidget *dialog, *label;
+	gint result;
+
+	if (config_changed == FALSE)
+		return FALSE;
+
+	dialog = gtk_dialog_new_with_buttons("Warning !",
+					     GTK_WINDOW(main_wnd),
+					     (GtkDialogFlags)
+					     (GTK_DIALOG_MODAL |
+					      GTK_DIALOG_DESTROY_WITH_PARENT),
+					     GTK_STOCK_OK,
+					     GTK_RESPONSE_YES,
+					     GTK_STOCK_NO,
+					     GTK_RESPONSE_NO,
+					     GTK_STOCK_CANCEL,
+					     GTK_RESPONSE_CANCEL, NULL);
+	gtk_dialog_set_default_response(GTK_DIALOG(dialog),
+					GTK_RESPONSE_CANCEL);
+
+	label = gtk_label_new("\nSave configuration ?\n");
+	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), label);
+	gtk_widget_show(label);
+
+	result = gtk_dialog_run(GTK_DIALOG(dialog));
+	switch (result) {
+	case GTK_RESPONSE_YES:
+		on_save1_activate(NULL, NULL);
+		return FALSE;
+	case GTK_RESPONSE_NO:
+		return FALSE;
+	case GTK_RESPONSE_CANCEL:
+	case GTK_RESPONSE_DELETE_EVENT:
+	default:
+		gtk_widget_destroy(dialog);
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+void on_window1_destroy(GtkObject * object, gpointer user_data)
+{
+	gtk_main_quit();
+}
+
+
+void
+on_window1_size_request(GtkWidget * widget,
+			GtkRequisition * requisition, gpointer user_data)
+{
+	static gint old_h = 0;
+	gint w, h;
+
+	if (widget->window == NULL)
+		gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h);
+	else
+		gdk_window_get_size(widget->window, &w, &h);
+
+	if (h == old_h)
+		return;
+	old_h = h;
+
+	gtk_paned_set_position(GTK_PANED(vpaned), 2 * h / 3);
+}
+
+
+/* Menu & Toolbar Callbacks */
+
+
+static void
+load_filename(GtkFileSelection * file_selector, gpointer user_data)
+{
+	const gchar *fn;
+
+	fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
+					     (user_data));
+
+	if (conf_read(fn))
+		text_insert_msg("Error", "Unable to load configuration !");
+	else
+		display_tree(&rootmenu);
+}
+
+void on_load1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkWidget *fs;
+
+	fs = gtk_file_selection_new("Load file...");
+	g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
+			 "clicked",
+			 G_CALLBACK(load_filename), (gpointer) fs);
+	g_signal_connect_swapped(GTK_OBJECT
+				 (GTK_FILE_SELECTION(fs)->ok_button),
+				 "clicked", G_CALLBACK(gtk_widget_destroy),
+				 (gpointer) fs);
+	g_signal_connect_swapped(GTK_OBJECT
+				 (GTK_FILE_SELECTION(fs)->cancel_button),
+				 "clicked", G_CALLBACK(gtk_widget_destroy),
+				 (gpointer) fs);
+	gtk_widget_show(fs);
+}
+
+
+void on_save1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	if (conf_write(NULL))
+		text_insert_msg("Error", "Unable to save configuration !");
+
+	config_changed = FALSE;
+}
+
+
+static void
+store_filename(GtkFileSelection * file_selector, gpointer user_data)
+{
+	const gchar *fn;
+
+	fn = gtk_file_selection_get_filename(GTK_FILE_SELECTION
+					     (user_data));
+
+	if (conf_write(fn))
+		text_insert_msg("Error", "Unable to save configuration !");
+
+	gtk_widget_destroy(GTK_WIDGET(user_data));
+}
+
+void on_save_as1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkWidget *fs;
+
+	fs = gtk_file_selection_new("Save file as...");
+	g_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(fs)->ok_button),
+			 "clicked",
+			 G_CALLBACK(store_filename), (gpointer) fs);
+	g_signal_connect_swapped(GTK_OBJECT
+				 (GTK_FILE_SELECTION(fs)->ok_button),
+				 "clicked", G_CALLBACK(gtk_widget_destroy),
+				 (gpointer) fs);
+	g_signal_connect_swapped(GTK_OBJECT
+				 (GTK_FILE_SELECTION(fs)->cancel_button),
+				 "clicked", G_CALLBACK(gtk_widget_destroy),
+				 (gpointer) fs);
+	gtk_widget_show(fs);
+}
+
+
+void on_quit1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	if (!on_window1_delete_event(NULL, NULL, NULL))
+		gtk_widget_destroy(GTK_WIDGET(main_wnd));
+}
+
+
+void on_show_name1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkTreeViewColumn *col;
+
+	show_name = GTK_CHECK_MENU_ITEM(menuitem)->active;
+	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NAME);
+	if (col)
+		gtk_tree_view_column_set_visible(col, show_name);
+}
+
+
+void on_show_range1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkTreeViewColumn *col;
+
+	show_range = GTK_CHECK_MENU_ITEM(menuitem)->active;
+	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NO);
+	if (col)
+		gtk_tree_view_column_set_visible(col, show_range);
+	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_MOD);
+	if (col)
+		gtk_tree_view_column_set_visible(col, show_range);
+	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_YES);
+	if (col)
+		gtk_tree_view_column_set_visible(col, show_range);
+
+}
+
+
+void on_show_data1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkTreeViewColumn *col;
+
+	show_value = GTK_CHECK_MENU_ITEM(menuitem)->active;
+	col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_VALUE);
+	if (col)
+		gtk_tree_view_column_set_visible(col, show_value);
+}
+
+
+void
+on_show_all_options1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	show_all = GTK_CHECK_MENU_ITEM(menuitem)->active;
+
+	gtk_tree_store_clear(tree2);
+	display_tree(&rootmenu);	// instead of update_tree for speed reasons
+}
+
+
+void
+on_show_debug_info1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	show_debug = GTK_CHECK_MENU_ITEM(menuitem)->active;
+	update_tree(&rootmenu, NULL);
+}
+
+
+void on_introduction1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkWidget *dialog;
+	const gchar *intro_text =
+	    "Welcome to gkc, the GTK+ graphical configuration tool\n"
+	    "for Linux.\n"
+	    "For each option, a blank box indicates the feature is disabled, a\n"
+	    "check indicates it is enabled, and a dot indicates that it is to\n"
+	    "be compiled as a module.  Clicking on the box will cycle through the three states.\n"
+	    "\n"
+	    "If you do not see an option (e.g., a device driver) that you\n"
+	    "believe should be present, try turning on Show All Options\n"
+	    "under the Options menu.\n"
+	    "Although there is no cross reference yet to help you figure out\n"
+	    "what other options must be enabled to support the option you\n"
+	    "are interested in, you can still view the help of a grayed-out\n"
+	    "option.\n"
+	    "\n"
+	    "Toggling Show Debug Info under the Options menu will show \n"
+	    "the dependencies, which you can then match by examining other options.";
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
+					GTK_DIALOG_DESTROY_WITH_PARENT,
+					GTK_MESSAGE_INFO,
+					GTK_BUTTONS_CLOSE, intro_text);
+	g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
+				 G_CALLBACK(gtk_widget_destroy),
+				 GTK_OBJECT(dialog));
+	gtk_widget_show_all(dialog);
+}
+
+
+void on_about1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkWidget *dialog;
+	const gchar *about_text =
+	    "gkc is copyright (c) 2002 Romain Lievin <roms@lpg.ticalc.org>.\n"
+	    "Based on the source code from Roman Zippel.\n";
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
+					GTK_DIALOG_DESTROY_WITH_PARENT,
+					GTK_MESSAGE_INFO,
+					GTK_BUTTONS_CLOSE, about_text);
+	g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
+				 G_CALLBACK(gtk_widget_destroy),
+				 GTK_OBJECT(dialog));
+	gtk_widget_show_all(dialog);
+}
+
+
+void on_license1_activate(GtkMenuItem * menuitem, gpointer user_data)
+{
+	GtkWidget *dialog;
+	const gchar *license_text =
+	    "gkc is released under the terms of the GNU GPL v2.\n"
+	    "For more information, please see the source code or\n"
+	    "visit http://www.fsf.org/licenses/licenses.html\n";
+
+	dialog = gtk_message_dialog_new(GTK_WINDOW(main_wnd),
+					GTK_DIALOG_DESTROY_WITH_PARENT,
+					GTK_MESSAGE_INFO,
+					GTK_BUTTONS_CLOSE, license_text);
+	g_signal_connect_swapped(GTK_OBJECT(dialog), "response",
+				 G_CALLBACK(gtk_widget_destroy),
+				 GTK_OBJECT(dialog));
+	gtk_widget_show_all(dialog);
+}
+
+
+void on_back_pressed(GtkButton * button, gpointer user_data)
+{
+	enum prop_type ptype;
+
+	current = current->parent;
+	ptype = current->prompt ? current->prompt->type : P_UNKNOWN;
+	if (ptype != P_MENU)
+		current = current->parent;
+	display_tree_part();
+
+	if (current == &rootmenu)
+		gtk_widget_set_sensitive(back_btn, FALSE);
+}
+
+
+void on_load_pressed(GtkButton * button, gpointer user_data)
+{
+	on_load1_activate(NULL, user_data);
+}
+
+
+void on_save_pressed(GtkButton * button, gpointer user_data)
+{
+	on_save1_activate(NULL, user_data);
+}
+
+
+void on_single_clicked(GtkButton * button, gpointer user_data)
+{
+	view_mode = SINGLE_VIEW;
+	gtk_paned_set_position(GTK_PANED(hpaned), 0);
+	gtk_widget_hide(tree1_w);
+	current = &rootmenu;
+	display_tree_part();
+}
+
+
+void on_split_clicked(GtkButton * button, gpointer user_data)
+{
+	gint w, h;
+	view_mode = SPLIT_VIEW;
+	gtk_widget_show(tree1_w);
+	gtk_window_get_default_size(GTK_WINDOW(main_wnd), &w, &h);
+	gtk_paned_set_position(GTK_PANED(hpaned), w / 2);
+	if (tree2)	
+		gtk_tree_store_clear(tree2);
+	display_list();
+}
+
+
+void on_full_clicked(GtkButton * button, gpointer user_data)
+{
+	view_mode = FULL_VIEW;
+	gtk_paned_set_position(GTK_PANED(hpaned), 0);
+	gtk_widget_hide(tree1_w);
+	if (tree2)
+		gtk_tree_store_clear(tree2);
+	display_tree(&rootmenu);
+	gtk_widget_set_sensitive(back_btn, FALSE);
+}
+
+
+void on_collapse_pressed(GtkButton * button, gpointer user_data)
+{
+	gtk_tree_view_collapse_all(GTK_TREE_VIEW(tree2_w));
+}
+
+
+void on_expand_pressed(GtkButton * button, gpointer user_data)
+{
+	gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
+}
+
+
+/* CTree Callbacks */
+
+/* Change hex/int/string value in the cell */
+static void renderer_edited(GtkCellRendererText * cell,
+			    const gchar * path_string,
+			    const gchar * new_text, gpointer user_data)
+{
+	GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
+	GtkTreeIter iter;
+	const char *old_def, *new_def;
+	struct menu *menu;
+	struct symbol *sym;
+
+	if (!gtk_tree_model_get_iter(model2, &iter, path))
+		return;
+
+	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
+	sym = menu->sym;
+
+	gtk_tree_model_get(model2, &iter, COL_VALUE, &old_def, -1);
+	new_def = new_text;
+
+	sym_set_string_value(sym, new_def);
+
+	config_changed = TRUE;
+	update_tree(&rootmenu, NULL);
+
+	gtk_tree_path_free(path);
+}
+
+/* Change the value of a symbol and update the tree */
+static void change_sym_value(struct menu *menu, gint col)
+{
+	struct symbol *sym = menu->sym;
+	tristate oldval, newval;
+
+	if (!sym)
+		return;
+
+	if (col == COL_NO)
+		newval = no;
+	else if (col == COL_MOD)
+		newval = mod;
+	else if (col == COL_YES)
+		newval = yes;
+	else
+		return;
+
+	switch (sym_get_type(sym)) {
+	case S_BOOLEAN:
+	case S_TRISTATE:
+		oldval = sym_get_tristate_value(sym);
+		if (!sym_tristate_within_range(sym, newval))
+			newval = yes;
+		sym_set_tristate_value(sym, newval);
+		config_changed = TRUE;
+		if (view_mode == FULL_VIEW)
+			update_tree(&rootmenu, NULL);
+		else if (view_mode == SPLIT_VIEW) {
+			update_tree(current, NULL);
+			display_list();
+		}
+		else if (view_mode == SINGLE_VIEW)
+			display_tree_part();	//fixme: keep exp/coll
+		break;
+	case S_INT:
+	case S_HEX:
+	case S_STRING:
+	default:
+		break;
+	}
+}
+
+static void toggle_sym_value(struct menu *menu)
+{
+	const tristate next_val[3] = { no, mod, yes };
+	tristate newval;
+
+	if (!menu->sym)
+		return;
+
+	newval = next_val[(sym_get_tristate_value(menu->sym) + 1) % 3];
+	if (!sym_tristate_within_range(menu->sym, newval))
+		newval = yes;
+	sym_set_tristate_value(menu->sym, newval);
+	if (view_mode == FULL_VIEW)
+		update_tree(&rootmenu, NULL);
+	else if (view_mode == SPLIT_VIEW) {
+		update_tree(current, NULL);
+		display_list();
+	}
+	else if (view_mode == SINGLE_VIEW)
+		display_tree_part();	//fixme: keep exp/coll
+}
+
+static void renderer_toggled(GtkCellRendererToggle * cell,
+			     gchar * path_string, gpointer user_data)
+{
+	GtkTreePath *path, *sel_path = NULL;
+	GtkTreeIter iter, sel_iter;
+	GtkTreeSelection *sel;
+	struct menu *menu;
+
+	path = gtk_tree_path_new_from_string(path_string);
+	if (!gtk_tree_model_get_iter(model2, &iter, path))
+		return;
+
+	sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree2_w));
+	if (gtk_tree_selection_get_selected(sel, NULL, &sel_iter))
+		sel_path = gtk_tree_model_get_path(model2, &sel_iter);
+	if (!sel_path)
+		goto out1;
+	if (gtk_tree_path_compare(path, sel_path))
+		goto out2;
+
+	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
+	toggle_sym_value(menu);
+
+      out2:
+	gtk_tree_path_free(sel_path);
+      out1:
+	gtk_tree_path_free(path);
+}
+
+static gint column2index(GtkTreeViewColumn * column)
+{
+	gint i;
+
+	for (i = 0; i < COL_NUMBER; i++) {
+		GtkTreeViewColumn *col;
+
+		col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), i);
+		if (col == column)
+			return i;
+	}
+
+	return -1;
+}
+
+
+//#define GTK_BUG_FIXED // uncomment it for GTK+ >= 2.1.4 (2.2)
+
+/* User click: update choice (full) or goes down (single) */
+gboolean
+on_treeview2_button_press_event(GtkWidget * widget,
+				GdkEventButton * event, gpointer user_data)
+{
+	GtkTreeView *view = GTK_TREE_VIEW(widget);
+	GtkTreePath *path;
+	GtkTreeViewColumn *column;
+	GtkTreeIter iter;
+	struct menu *menu;
+	gint col;
+
+#ifdef GTK_BUG_FIXED
+	gint tx = (gint) event->x;
+	gint ty = (gint) event->y;
+	gint cx, cy;
+
+	gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
+				      &cy);
+#else
+	gtk_tree_view_get_cursor(view, &path, &column);
+#endif
+	if (path == NULL)
+		return FALSE;
+
+	gtk_tree_model_get_iter(model2, &iter, path);
+	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
+
+	col = column2index(column);
+	if (event->type == GDK_2BUTTON_PRESS) {
+		enum prop_type ptype;
+		ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
+
+		if (ptype == P_MENU && view_mode != FULL_VIEW && col == COL_OPTION) {
+			// goes down into menu
+			current = menu;
+			display_tree_part();
+			gtk_widget_set_sensitive(back_btn, TRUE);
+		} else if ((col == COL_OPTION)) {
+			toggle_sym_value(menu);
+			gtk_tree_view_expand_row(view, path, TRUE);
+		}
+	} else {
+		if (col == COL_VALUE) {
+			toggle_sym_value(menu);
+			gtk_tree_view_expand_row(view, path, TRUE);
+		} else if (col == COL_NO || col == COL_MOD
+			   || col == COL_YES) {
+			change_sym_value(menu, col);
+			gtk_tree_view_expand_row(view, path, TRUE);
+		}
+	}
+
+	return FALSE;
+}
+
+/* Key pressed: update choice */
+gboolean
+on_treeview2_key_press_event(GtkWidget * widget,
+			     GdkEventKey * event, gpointer user_data)
+{
+	GtkTreeView *view = GTK_TREE_VIEW(widget);
+	GtkTreePath *path;
+	GtkTreeViewColumn *column;
+	GtkTreeIter iter;
+	struct menu *menu;
+	gint col;
+
+	gtk_tree_view_get_cursor(view, &path, &column);
+	if (path == NULL)
+		return FALSE;
+
+	if (event->keyval == GDK_space) {
+		if (gtk_tree_view_row_expanded(view, path))
+			gtk_tree_view_collapse_row(view, path);
+		else
+			gtk_tree_view_expand_row(view, path, FALSE);
+		return TRUE;
+	}
+	if (event->keyval == GDK_KP_Enter) {
+	}
+	if (widget == tree1_w)
+		return FALSE;
+
+	gtk_tree_model_get_iter(model2, &iter, path);
+	gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
+
+	if (!strcasecmp(event->string, "n"))
+		col = COL_NO;
+	else if (!strcasecmp(event->string, "m"))
+		col = COL_MOD;
+	else if (!strcasecmp(event->string, "y"))
+		col = COL_YES;
+	else
+		col = -1;
+	change_sym_value(menu, col);
+
+	return FALSE;
+}
+
+
+/* Row selection changed: update help */
+void
+on_treeview2_cursor_changed(GtkTreeView * treeview, gpointer user_data)
+{
+	GtkTreeSelection *selection;
+	GtkTreeIter iter;
+	struct menu *menu;
+
+	selection = gtk_tree_view_get_selection(treeview);
+	if (gtk_tree_selection_get_selected(selection, &model2, &iter)) {
+		gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
+		text_insert_help(menu);
+	}
+}
+
+
+/* User click: display sub-tree in the right frame. */
+gboolean
+on_treeview1_button_press_event(GtkWidget * widget,
+				GdkEventButton * event, gpointer user_data)
+{
+	GtkTreeView *view = GTK_TREE_VIEW(widget);
+	GtkTreePath *path;
+	GtkTreeViewColumn *column;
+	GtkTreeIter iter;
+	struct menu *menu;
+
+	gint tx = (gint) event->x;
+	gint ty = (gint) event->y;
+	gint cx, cy;
+
+	gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
+				      &cy);
+	if (path == NULL)
+		return FALSE;
+
+	gtk_tree_model_get_iter(model1, &iter, path);
+	gtk_tree_model_get(model1, &iter, COL_MENU, &menu, -1);
+
+	if (event->type == GDK_2BUTTON_PRESS) {
+		toggle_sym_value(menu);
+		current = menu;
+		display_tree_part();
+	} else {
+		current = menu;
+		display_tree_part();
+	}
+
+	gtk_widget_realize(tree2_w);
+	gtk_tree_view_set_cursor(view, path, NULL, FALSE);
+	gtk_widget_grab_focus(GTK_TREE_VIEW(tree2_w));
+
+	return FALSE;
+}
+
+
+/* Conf management */
+
+
+/* Fill a row of strings */
+static gchar **fill_row(struct menu *menu)
+{
+	static gchar *row[COL_NUMBER] = { 0 };
+	struct symbol *sym = menu->sym;
+	const char *def;
+	int stype;
+	tristate val;
+	enum prop_type ptype;
+	int i;
+
+	for (i = COL_OPTION; i <= COL_COLOR; i++)
+		g_free(row[i]);
+	bzero(row, sizeof(row));
+
+	row[COL_OPTION] =
+	    g_strdup_printf("%s %s", menu_get_prompt(menu),
+			    sym ? (sym->
+				   flags & SYMBOL_NEW ? "(NEW)" : "") :
+			    "");
+
+	if (show_all && !menu_is_visible(menu))
+		row[COL_COLOR] = g_strdup("DarkGray");
+	else
+		row[COL_COLOR] = g_strdup("Black");
+
+	ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
+	switch (ptype) {
+	case P_MENU:
+		row[COL_PIXBUF] = (gchar *) xpm_menu;
+		if (view_mode != FULL_VIEW)
+			row[COL_PIXVIS] = GINT_TO_POINTER(TRUE);
+		row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
+		break;
+	case P_COMMENT:
+		row[COL_PIXBUF] = (gchar *) xpm_void;
+		row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
+		row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
+		break;
+	default:
+		row[COL_PIXBUF] = (gchar *) xpm_void;
+		row[COL_PIXVIS] = GINT_TO_POINTER(FALSE);
+		row[COL_BTNVIS] = GINT_TO_POINTER(TRUE);
+		break;
+	}
+
+	if (!sym)
+		return row;
+	row[COL_NAME] = g_strdup(sym->name);
+
+	sym_calc_value(sym);
+	sym->flags &= ~SYMBOL_CHANGED;
+
+	if (sym_is_choice(sym)) {	// parse childs for getting final value
+		struct menu *child;
+		struct symbol *def_sym = sym_get_choice_value(sym);
+		struct menu *def_menu = NULL;
+
+		row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
+
+		for (child = menu->list; child; child = child->next) {
+			if (menu_is_visible(child)
+			    && child->sym == def_sym)
+				def_menu = child;
+		}
+
+		if (def_menu)
+			row[COL_VALUE] =
+			    g_strdup(menu_get_prompt(def_menu));
+	}
+	if(sym->flags & SYMBOL_CHOICEVAL)
+		row[COL_BTNRAD] = GINT_TO_POINTER(TRUE);
+
+	stype = sym_get_type(sym);
+	switch (stype) {
+	case S_BOOLEAN:
+		if (sym_is_choice(sym))
+			break;
+	case S_TRISTATE:
+		val = sym_get_tristate_value(sym);
+		switch (val) {
+		case no:
+			row[COL_NO] = g_strdup("N");
+			row[COL_VALUE] = g_strdup("N");
+			row[COL_BTNACT] = GINT_TO_POINTER(FALSE);
+			row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
+			break;
+		case mod:
+			row[COL_MOD] = g_strdup("M");
+			row[COL_VALUE] = g_strdup("M");
+			row[COL_BTNINC] = GINT_TO_POINTER(TRUE);
+			break;
+		case yes:
+			row[COL_YES] = g_strdup("Y");
+			row[COL_VALUE] = g_strdup("Y");
+			row[COL_BTNACT] = GINT_TO_POINTER(TRUE);
+			row[COL_BTNINC] = GINT_TO_POINTER(FALSE);
+			break;
+		}
+
+		if (val != no && sym_tristate_within_range(sym, no))
+			row[COL_NO] = g_strdup("_");
+		if (val != mod && sym_tristate_within_range(sym, mod))
+			row[COL_MOD] = g_strdup("_");
+		if (val != yes && sym_tristate_within_range(sym, yes))
+			row[COL_YES] = g_strdup("_");
+		break;
+	case S_INT:
+	case S_HEX:
+	case S_STRING:
+		def = sym_get_string_value(sym);
+		row[COL_VALUE] = g_strdup(def);
+		row[COL_EDIT] = GINT_TO_POINTER(TRUE);
+		row[COL_BTNVIS] = GINT_TO_POINTER(FALSE);
+		break;
+	}
+
+	return row;
+}
+
+
+/* Set the node content with a row of strings */
+static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row)
+{
+	GdkColor color;
+	gboolean success;
+	GdkPixbuf *pix;
+
+	pix = gdk_pixbuf_new_from_xpm_data((const char **)
+					   row[COL_PIXBUF]);
+
+	gdk_color_parse(row[COL_COLOR], &color);
+	gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1,
+				  FALSE, FALSE, &success);
+
+	gtk_tree_store_set(tree, node,
+			   COL_OPTION, row[COL_OPTION],
+			   COL_NAME, row[COL_NAME],
+			   COL_NO, row[COL_NO],
+			   COL_MOD, row[COL_MOD],
+			   COL_YES, row[COL_YES],
+			   COL_VALUE, row[COL_VALUE],
+			   COL_MENU, (gpointer) menu,
+			   COL_COLOR, &color,
+			   COL_EDIT, GPOINTER_TO_INT(row[COL_EDIT]),
+			   COL_PIXBUF, pix,
+			   COL_PIXVIS, GPOINTER_TO_INT(row[COL_PIXVIS]),
+			   COL_BTNVIS, GPOINTER_TO_INT(row[COL_BTNVIS]),
+			   COL_BTNACT, GPOINTER_TO_INT(row[COL_BTNACT]),
+			   COL_BTNINC, GPOINTER_TO_INT(row[COL_BTNINC]),
+			   COL_BTNRAD, GPOINTER_TO_INT(row[COL_BTNRAD]),
+			   -1);
+
+	g_object_unref(pix);
+}
+
+
+/* Add a node to the tree */
+static void place_node(struct menu *menu, char **row)
+{
+	GtkTreeIter *parent = parents[indent - 1];
+	GtkTreeIter *node = parents[indent];
+
+	gtk_tree_store_append(tree, node, parent);
+	set_node(node, menu, row);
+}
+
+
+/* Find a node in the GTK+ tree */
+static GtkTreeIter found;
+
+/*
+ * Find a menu in the GtkTree starting at parent.
+ */
+GtkTreeIter *gtktree_iter_find_node(GtkTreeIter * parent,
+				    struct menu *tofind)
+{
+	GtkTreeIter iter;
+	GtkTreeIter *child = &iter;
+	gboolean valid;
+	GtkTreeIter *ret;
+
+	valid = gtk_tree_model_iter_children(model2, child, parent);
+	while (valid) {
+		struct menu *menu;
+
+		gtk_tree_model_get(model2, child, 6, &menu, -1);
+
+		if (menu == tofind) {
+			memcpy(&found, child, sizeof(GtkTreeIter));
+			return &found;
+		}
+
+		ret = gtktree_iter_find_node(child, tofind);
+		if (ret)
+			return ret;
+
+		valid = gtk_tree_model_iter_next(model2, child);
+	}
+
+	return NULL;
+}
+
+
+/*
+ * Update the tree by adding/removing entries
+ * Does not change other nodes
+ */
+static void update_tree(struct menu *src, GtkTreeIter * dst)
+{
+	struct menu *child1;
+	GtkTreeIter iter, tmp;
+	GtkTreeIter *child2 = &iter;
+	gboolean valid;
+	GtkTreeIter *sibling;
+	struct symbol *sym;
+	struct property *prop;
+	struct menu *menu1, *menu2;
+	static GtkTreePath *path = NULL;
+
+	if (src == &rootmenu)
+		indent = 1;
+
+	valid = gtk_tree_model_iter_children(model2, child2, dst);
+	for (child1 = src->list; child1; child1 = child1->next) {
+
+		prop = child1->prompt;
+		sym = child1->sym;
+
+	      reparse:
+		menu1 = child1;
+		if (valid)
+			gtk_tree_model_get(model2, child2, COL_MENU,
+					   &menu2, -1);
+		else
+			menu2 = NULL;	// force adding of a first child
+
+#ifdef DEBUG
+		printf("%*c%s | %s\n", indent, ' ',
+		       menu1 ? menu_get_prompt(menu1) : "nil",
+		       menu2 ? menu_get_prompt(menu2) : "nil");
+#endif
+
+		if (!menu_is_visible(child1) && !show_all) {	// remove node
+			if (gtktree_iter_find_node(dst, menu1) != NULL) {
+				memcpy(&tmp, child2, sizeof(GtkTreeIter));
+				valid = gtk_tree_model_iter_next(model2,
+								 child2);
+				gtk_tree_store_remove(tree2, &tmp);
+				if (!valid)
+					return;	// next parent 
+				else
+					goto reparse;	// next child
+			} else
+				continue;
+		}
+
+		if (menu1 != menu2) {
+			if (gtktree_iter_find_node(dst, menu1) == NULL) {	// add node
+				if (!valid && !menu2)
+					sibling = NULL;
+				else
+					sibling = child2;
+				gtk_tree_store_insert_before(tree2,
+							     child2,
+							     dst, sibling);
+				set_node(child2, menu1, fill_row(menu1));
+				if (menu2 == NULL)
+					valid = TRUE;
+			} else {	// remove node
+				memcpy(&tmp, child2, sizeof(GtkTreeIter));
+				valid = gtk_tree_model_iter_next(model2,
+								 child2);
+				gtk_tree_store_remove(tree2, &tmp);
+				if (!valid)
+					return;	// next parent 
+				else
+					goto reparse;	// next child
+			}
+		} else if (sym && (sym->flags & SYMBOL_CHANGED)) {
+			set_node(child2, menu1, fill_row(menu1));
+		}
+
+		indent++;
+		update_tree(child1, child2);
+		indent--;
+
+		valid = gtk_tree_model_iter_next(model2, child2);
+	}
+}
+
+
+/* Display the whole tree (single/split/full view) */
+static void display_tree(struct menu *menu)
+{
+	struct symbol *sym;
+	struct property *prop;
+	struct menu *child;
+	enum prop_type ptype;
+
+	if (menu == &rootmenu) {
+		indent = 1;
+		current = &rootmenu;
+	}
+
+	for (child = menu->list; child; child = child->next) {
+		prop = child->prompt;
+		sym = child->sym;
+		ptype = prop ? prop->type : P_UNKNOWN;
+
+		if (sym)
+			sym->flags &= ~SYMBOL_CHANGED;
+
+		if ((view_mode == SPLIT_VIEW) && !(child->flags & MENU_ROOT) &&
+		    (tree == tree1))
+			continue;
+
+		if ((view_mode == SPLIT_VIEW) && (child->flags & MENU_ROOT) &&
+		    (tree == tree2))
+			continue;
+
+		if (menu_is_visible(child) || show_all)
+			place_node(child, fill_row(child));
+#ifdef DEBUG
+		printf("%*c%s: ", indent, ' ', menu_get_prompt(child));
+		dbg_print_ptype(ptype);
+		printf(" | ");
+		if (sym) {
+			dbg_print_stype(sym->type);
+			printf(" | ");
+			dbg_print_flags(sym->flags);
+			printf("\n");
+		} else
+			printf("\n");
+#endif
+		if ((view_mode != FULL_VIEW) && (ptype == P_MENU)
+		    && (tree == tree2))
+			continue;
+
+		if (((menu != &rootmenu) && !(menu->flags & MENU_ROOT)) ||
+		    (view_mode == FULL_VIEW)
+		    || (view_mode == SPLIT_VIEW)) {
+			indent++;
+			display_tree(child);
+			indent--;
+		}
+	}
+}
+
+/* Display a part of the tree starting at current node (single/split view) */
+static void display_tree_part(void)
+{
+	if (tree2)
+		gtk_tree_store_clear(tree2);
+	display_tree(current);
+	gtk_tree_view_expand_all(GTK_TREE_VIEW(tree2_w));
+}
+
+/* Display the list in the left frame (split view) */
+static void display_list(void)
+{
+	if (tree1)
+		gtk_tree_store_clear(tree1);
+
+	tree = tree1;
+	display_tree(current = &rootmenu);
+	gtk_tree_view_expand_all(GTK_TREE_VIEW(tree1_w));
+	tree = tree2;
+}
+
+static void fixup_rootmenu(struct menu *menu)
+{
+	struct menu *child;
+
+	if (!menu->prompt || menu->prompt->type != P_MENU)
+		return;
+	menu->flags |= MENU_ROOT;
+	for (child = menu->list; child; child = child->next)
+		fixup_rootmenu(child);
+}
+
+
+/* Main */
+
+
+int main(int ac, char *av[])
+{
+	const char *name;
+	gchar *cur_dir, *exe_path;
+	gchar *glade_file;
+
+#ifndef LKC_DIRECT_LINK
+	kconfig_load();
+#endif
+
+	/* GTK stuffs */
+	gtk_set_locale();
+	gtk_init(&ac, &av);
+	glade_init();
+
+	//add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
+	//add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
+
+	/* Determine GUI path */
+	cur_dir = g_get_current_dir();
+	exe_path = g_strdup(av[0]);
+	exe_path[0] = '/';
+	glade_file = g_strconcat(cur_dir, exe_path, ".glade", NULL);
+	g_free(cur_dir);
+	g_free(exe_path);
+
+	/* Load the interface and connect signals */
+	init_main_window(glade_file);
+	init_tree_model();
+	init_left_tree();
+	init_right_tree();
+
+	/* Conf stuffs */
+	if (ac > 1 && av[1][0] == '-') {
+		switch (av[1][1]) {
+		case 'a':
+			//showAll = 1;
+			break;
+		case 'h':
+		case '?':
+			printf("%s <config>\n", av[0]);
+			exit(0);
+		}
+		name = av[2];
+	} else
+		name = av[1];
+
+	conf_parse(name);
+	fixup_rootmenu(&rootmenu);
+	conf_read(NULL);
+
+	switch (view_mode) {
+	case SINGLE_VIEW:
+		display_tree_part();
+		break;
+	case SPLIT_VIEW:
+		display_list();
+		break;
+	case FULL_VIEW:
+		display_tree(&rootmenu);
+		break;
+	}
+
+	gtk_main();
+
+	return 0;
+}
diff --git a/scripts/kconfig/gconf.glade b/scripts/kconfig/gconf.glade
new file mode 100644
index 0000000..1e1736d
--- a/dev/null
+++ b/scripts/kconfig/gconf.glade
@@ -0,0 +1,543 @@
+<?xml version="1.0" standalone="no"?> <!--*- mode: xml -*-->
+<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.org/glade-2.0.dtd">
+
+<glade-interface>
+
+<widget class="GtkWindow" id="window1">
+  <property name="visible">True</property>
+  <property name="title" translatable="yes">Gtk Kernel Configurator</property>
+  <property name="type">GTK_WINDOW_TOPLEVEL</property>
+  <property name="window_position">GTK_WIN_POS_NONE</property>
+  <property name="modal">False</property>
+  <property name="default_width">640</property>
+  <property name="default_height">480</property>
+  <property name="resizable">True</property>
+  <property name="destroy_with_parent">False</property>
+  <signal name="destroy" handler="on_window1_destroy" object="window1"/>
+  <signal name="size_request" handler="on_window1_size_request" object="vpaned1" last_modification_time="Fri, 11 Jan 2002 16:17:11 GMT"/>
+  <signal name="delete_event" handler="on_window1_delete_event" object="window1" last_modification_time="Sun, 09 Mar 2003 19:42:46 GMT"/>
+
+  <child>
+    <widget class="GtkVBox" id="vbox1">
+      <property name="visible">True</property>
+      <property name="homogeneous">False</property>
+      <property name="spacing">0</property>
+
+      <child>
+	<widget class="GtkMenuBar" id="menubar1">
+	  <property name="visible">True</property>
+
+	  <child>
+	    <widget class="GtkMenuItem" id="file1">
+	      <property name="visible">True</property>
+	      <property name="label" translatable="yes">_File</property>
+	      <property name="use_underline">True</property>
+
+	      <child>
+		<widget class="GtkMenu" id="file1_menu">
+
+		  <child>
+		    <widget class="GtkImageMenuItem" id="load1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Load a config file</property>
+		      <property name="label" translatable="yes">_Load</property>
+		      <property name="use_underline">True</property>
+		      <signal name="activate" handler="on_load1_activate"/>
+		      <accelerator key="L" modifiers="GDK_CONTROL_MASK" signal="activate"/>
+
+		      <child internal-child="image">
+			<widget class="GtkImage" id="image27">
+			  <property name="visible">True</property>
+			  <property name="stock">gtk-open</property>
+			  <property name="icon_size">1</property>
+			  <property name="xalign">0.5</property>
+			  <property name="yalign">0.5</property>
+			  <property name="xpad">0</property>
+			  <property name="ypad">0</property>
+			</widget>
+		      </child>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkImageMenuItem" id="save1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Save the config in .config</property>
+		      <property name="label" translatable="yes">_Save</property>
+		      <property name="use_underline">True</property>
+		      <signal name="activate" handler="on_save1_activate"/>
+		      <accelerator key="S" modifiers="GDK_CONTROL_MASK" signal="activate"/>
+
+		      <child internal-child="image">
+			<widget class="GtkImage" id="image28">
+			  <property name="visible">True</property>
+			  <property name="stock">gtk-save</property>
+			  <property name="icon_size">1</property>
+			  <property name="xalign">0.5</property>
+			  <property name="yalign">0.5</property>
+			  <property name="xpad">0</property>
+			  <property name="ypad">0</property>
+			</widget>
+		      </child>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkImageMenuItem" id="save_as1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Save the config in a file</property>
+		      <property name="label" translatable="yes">Save _as</property>
+		      <property name="use_underline">True</property>
+		      <signal name="activate" handler="on_save_as1_activate"/>
+
+		      <child internal-child="image">
+			<widget class="GtkImage" id="image29">
+			  <property name="visible">True</property>
+			  <property name="stock">gtk-save-as</property>
+			  <property name="icon_size">1</property>
+			  <property name="xalign">0.5</property>
+			  <property name="yalign">0.5</property>
+			  <property name="xpad">0</property>
+			  <property name="ypad">0</property>
+			</widget>
+		      </child>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkMenuItem" id="separator1">
+		      <property name="visible">True</property>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkImageMenuItem" id="quit1">
+		      <property name="visible">True</property>
+		      <property name="label" translatable="yes">_Quit</property>
+		      <property name="use_underline">True</property>
+		      <signal name="activate" handler="on_quit1_activate"/>
+		      <accelerator key="Q" modifiers="GDK_CONTROL_MASK" signal="activate"/>
+
+		      <child internal-child="image">
+			<widget class="GtkImage" id="image30">
+			  <property name="visible">True</property>
+			  <property name="stock">gtk-quit</property>
+			  <property name="icon_size">1</property>
+			  <property name="xalign">0.5</property>
+			  <property name="yalign">0.5</property>
+			  <property name="xpad">0</property>
+			  <property name="ypad">0</property>
+			</widget>
+		      </child>
+		    </widget>
+		  </child>
+		</widget>
+	      </child>
+	    </widget>
+	  </child>
+
+	  <child>
+	    <widget class="GtkMenuItem" id="options1">
+	      <property name="visible">True</property>
+	      <property name="label" translatable="yes">_Options</property>
+	      <property name="use_underline">True</property>
+
+	      <child>
+		<widget class="GtkMenu" id="options1_menu">
+
+		  <child>
+		    <widget class="GtkCheckMenuItem" id="show_name1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Show name</property>
+		      <property name="label" translatable="yes">Show _name</property>
+		      <property name="use_underline">True</property>
+		      <property name="active">False</property>
+		      <signal name="activate" handler="on_show_name1_activate"/>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkCheckMenuItem" id="show_range1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Show range (Y/M/N)</property>
+		      <property name="label" translatable="yes">Show _range</property>
+		      <property name="use_underline">True</property>
+		      <property name="active">False</property>
+		      <signal name="activate" handler="on_show_range1_activate"/>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkCheckMenuItem" id="show_data1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Show value of the option</property>
+		      <property name="label" translatable="yes">Show _data</property>
+		      <property name="use_underline">True</property>
+		      <property name="active">False</property>
+		      <signal name="activate" handler="on_show_data1_activate"/>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkMenuItem" id="separator2">
+		      <property name="visible">True</property>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkCheckMenuItem" id="show_all_options1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Show all options</property>
+		      <property name="label" translatable="yes">Show all _options</property>
+		      <property name="use_underline">True</property>
+		      <property name="active">False</property>
+		      <signal name="activate" handler="on_show_all_options1_activate"/>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkCheckMenuItem" id="show_debug_info1">
+		      <property name="visible">True</property>
+		      <property name="tooltip" translatable="yes">Show masked options</property>
+		      <property name="label" translatable="yes">Show _debug info</property>
+		      <property name="use_underline">True</property>
+		      <property name="active">False</property>
+		      <signal name="activate" handler="on_show_debug_info1_activate"/>
+		    </widget>
+		  </child>
+		</widget>
+	      </child>
+	    </widget>
+	  </child>
+
+	  <child>
+	    <widget class="GtkMenuItem" id="help1">
+	      <property name="visible">True</property>
+	      <property name="label" translatable="yes">_Help</property>
+	      <property name="use_underline">True</property>
+
+	      <child>
+		<widget class="GtkMenu" id="help1_menu">
+
+		  <child>
+		    <widget class="GtkImageMenuItem" id="introduction1">
+		      <property name="visible">True</property>
+		      <property name="label" translatable="yes">_Introduction</property>
+		      <property name="use_underline">True</property>
+		      <signal name="activate" handler="on_introduction1_activate" last_modification_time="Fri, 15 Nov 2002 20:26:30 GMT"/>
+		      <accelerator key="I" modifiers="GDK_CONTROL_MASK" signal="activate"/>
+
+		      <child internal-child="image">
+			<widget class="GtkImage" id="image31">
+			  <property name="visible">True</property>
+			  <property name="stock">gtk-dialog-question</property>
+			  <property name="icon_size">1</property>
+			  <property name="xalign">0.5</property>
+			  <property name="yalign">0.5</property>
+			  <property name="xpad">0</property>
+			  <property name="ypad">0</property>
+			</widget>
+		      </child>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkImageMenuItem" id="about1">
+		      <property name="visible">True</property>
+		      <property name="label" translatable="yes">_About</property>
+		      <property name="use_underline">True</property>
+		      <signal name="activate" handler="on_about1_activate" last_modification_time="Fri, 15 Nov 2002 20:26:30 GMT"/>
+		      <accelerator key="A" modifiers="GDK_CONTROL_MASK" signal="activate"/>
+
+		      <child internal-child="image">
+			<widget class="GtkImage" id="image32">
+			  <property name="visible">True</property>
+			  <property name="stock">gtk-properties</property>
+			  <property name="icon_size">1</property>
+			  <property name="xalign">0.5</property>
+			  <property name="yalign">0.5</property>
+			  <property name="xpad">0</property>
+			  <property name="ypad">0</property>
+			</widget>
+		      </child>
+		    </widget>
+		  </child>
+
+		  <child>
+		    <widget class="GtkImageMenuItem" id="license1">
+		      <property name="visible">True</property>
+		      <property name="label" translatable="yes">_License</property>
+		      <property name="use_underline">True</property>
+		      <signal name="activate" handler="on_license1_activate" last_modification_time="Fri, 15 Nov 2002 20:26:30 GMT"/>
+
+		      <child internal-child="image">
+			<widget class="GtkImage" id="image33">
+			  <property name="visible">True</property>
+			  <property name="stock">gtk-justify-fill</property>
+			  <property name="icon_size">1</property>
+			  <property name="xalign">0.5</property>
+			  <property name="yalign">0.5</property>
+			  <property name="xpad">0</property>
+			  <property name="ypad">0</property>
+			</widget>
+		      </child>
+		    </widget>
+		  </child>
+		</widget>
+	      </child>
+	    </widget>
+	  </child>
+	</widget>
+	<packing>
+	  <property name="padding">0</property>
+	  <property name="expand">False</property>
+	  <property name="fill">False</property>
+	</packing>
+      </child>
+
+      <child>
+	<widget class="GtkHandleBox" id="handlebox1">
+	  <property name="visible">True</property>
+	  <property name="shadow_type">GTK_SHADOW_OUT</property>
+	  <property name="handle_position">GTK_POS_LEFT</property>
+	  <property name="snap_edge">GTK_POS_TOP</property>
+
+	  <child>
+	    <widget class="GtkToolbar" id="toolbar1">
+	      <property name="visible">True</property>
+	      <property name="orientation">GTK_ORIENTATION_HORIZONTAL</property>
+	      <property name="toolbar_style">GTK_TOOLBAR_BOTH</property>
+	      <property name="tooltips">True</property>
+
+	      <child>
+		<widget class="button" id="button1">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Goes up of one level (single view)</property>
+		  <property name="label" translatable="yes">Back</property>
+		  <property name="use_underline">True</property>
+		  <property name="stock_pixmap">gtk-undo</property>
+		  <signal name="pressed" handler="on_back_pressed"/>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="GtkVSeparator" id="vseparator1">
+		  <property name="visible">True</property>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="button" id="button2">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Load a config file</property>
+		  <property name="label" translatable="yes">Load</property>
+		  <property name="use_underline">True</property>
+		  <property name="stock_pixmap">gtk-open</property>
+		  <signal name="pressed" handler="on_load_pressed"/>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="button" id="button3">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Save a config file</property>
+		  <property name="label" translatable="yes">Save</property>
+		  <property name="use_underline">True</property>
+		  <property name="stock_pixmap">gtk-save</property>
+		  <signal name="pressed" handler="on_save_pressed"/>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="GtkVSeparator" id="vseparator2">
+		  <property name="visible">True</property>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="button" id="button4">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Single view</property>
+		  <property name="label" translatable="yes">Single</property>
+		  <property name="use_underline">True</property>
+		  <property name="stock_pixmap">gtk-missing-image</property>
+		  <signal name="clicked" handler="on_single_clicked" last_modification_time="Sun, 12 Jan 2003 14:28:39 GMT"/>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="button" id="button5">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Split view</property>
+		  <property name="label" translatable="yes">Split</property>
+		  <property name="use_underline">True</property>
+		  <property name="stock_pixmap">gtk-missing-image</property>
+		  <signal name="clicked" handler="on_split_clicked" last_modification_time="Sun, 12 Jan 2003 14:28:45 GMT"/>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="button" id="button6">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Full view</property>
+		  <property name="label" translatable="yes">Full</property>
+		  <property name="use_underline">True</property>
+		  <property name="stock_pixmap">gtk-missing-image</property>
+		  <signal name="clicked" handler="on_full_clicked" last_modification_time="Sun, 12 Jan 2003 14:28:50 GMT"/>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="GtkVSeparator" id="vseparator3">
+		  <property name="visible">True</property>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="button" id="button7">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Collapse the whole tree in the right frame</property>
+		  <property name="label" translatable="yes">Collapse</property>
+		  <property name="use_underline">True</property>
+		  <signal name="pressed" handler="on_collapse_pressed"/>
+		</widget>
+	      </child>
+
+	      <child>
+		<widget class="button" id="button8">
+		  <property name="visible">True</property>
+		  <property name="tooltip" translatable="yes">Expand the whole tree in the right frame</property>
+		  <property name="label" translatable="yes">Expand</property>
+		  <property name="use_underline">True</property>
+		  <signal name="pressed" handler="on_expand_pressed"/>
+		</widget>
+	      </child>
+	    </widget>
+	  </child>
+	</widget>
+	<packing>
+	  <property name="padding">0</property>
+	  <property name="expand">False</property>
+	  <property name="fill">False</property>
+	</packing>
+      </child>
+
+      <child>
+	<widget class="GtkHPaned" id="hpaned1">
+	  <property name="width_request">1</property>
+	  <property name="visible">True</property>
+	  <property name="can_focus">True</property>
+	  <property name="position">0</property>
+
+	  <child>
+	    <widget class="GtkScrolledWindow" id="scrolledwindow1">
+	      <property name="visible">True</property>
+	      <property name="hscrollbar_policy">GTK_POLICY_ALWAYS</property>
+	      <property name="vscrollbar_policy">GTK_POLICY_ALWAYS</property>
+	      <property name="shadow_type">GTK_SHADOW_IN</property>
+	      <property name="window_placement">GTK_CORNER_TOP_LEFT</property>
+
+	      <child>
+		<widget class="GtkTreeView" id="treeview1">
+		  <property name="visible">True</property>
+		  <property name="can_focus">True</property>
+		  <property name="headers_visible">True</property>
+		  <property name="rules_hint">False</property>
+		  <property name="reorderable">False</property>
+		  <property name="enable_search">True</property>
+		  <signal name="cursor_changed" handler="on_treeview2_cursor_changed" last_modification_time="Sun, 12 Jan 2003 15:58:22 GMT"/>
+		  <signal name="button_press_event" handler="on_treeview1_button_press_event" last_modification_time="Sun, 12 Jan 2003 16:03:52 GMT"/>
+		  <signal name="key_press_event" handler="on_treeview2_key_press_event" last_modification_time="Sun, 12 Jan 2003 16:11:44 GMT"/>
+		</widget>
+	      </child>
+	    </widget>
+	    <packing>
+	      <property name="shrink">True</property>
+	      <property name="resize">False</property>
+	    </packing>
+	  </child>
+
+	  <child>
+	    <widget class="GtkVPaned" id="vpaned1">
+	      <property name="visible">True</property>
+	      <property name="can_focus">True</property>
+	      <property name="position">0</property>
+
+	      <child>
+		<widget class="GtkScrolledWindow" id="scrolledwindow2">
+		  <property name="visible">True</property>
+		  <property name="hscrollbar_policy">GTK_POLICY_ALWAYS</property>
+		  <property name="vscrollbar_policy">GTK_POLICY_ALWAYS</property>
+		  <property name="shadow_type">GTK_SHADOW_IN</property>
+		  <property name="window_placement">GTK_CORNER_TOP_LEFT</property>
+
+		  <child>
+		    <widget class="GtkTreeView" id="treeview2">
+		      <property name="visible">True</property>
+		      <property name="can_focus">True</property>
+		      <property name="has_focus">True</property>
+		      <property name="headers_visible">True</property>
+		      <property name="rules_hint">False</property>
+		      <property name="reorderable">False</property>
+		      <property name="enable_search">True</property>
+		      <signal name="cursor_changed" handler="on_treeview2_cursor_changed" last_modification_time="Sun, 12 Jan 2003 15:57:55 GMT"/>
+		      <signal name="button_press_event" handler="on_treeview2_button_press_event" last_modification_time="Sun, 12 Jan 2003 15:57:58 GMT"/>
+		      <signal name="key_press_event" handler="on_treeview2_key_press_event" last_modification_time="Sun, 12 Jan 2003 15:58:01 GMT"/>
+		    </widget>
+		  </child>
+		</widget>
+		<packing>
+		  <property name="shrink">True</property>
+		  <property name="resize">False</property>
+		</packing>
+	      </child>
+
+	      <child>
+		<widget class="GtkScrolledWindow" id="scrolledwindow3">
+		  <property name="visible">True</property>
+		  <property name="hscrollbar_policy">GTK_POLICY_NEVER</property>
+		  <property name="vscrollbar_policy">GTK_POLICY_ALWAYS</property>
+		  <property name="shadow_type">GTK_SHADOW_IN</property>
+		  <property name="window_placement">GTK_CORNER_TOP_LEFT</property>
+
+		  <child>
+		    <widget class="GtkTextView" id="textview3">
+		      <property name="visible">True</property>
+		      <property name="can_focus">True</property>
+		      <property name="editable">False</property>
+		      <property name="justification">GTK_JUSTIFY_LEFT</property>
+		      <property name="wrap_mode">GTK_WRAP_WORD</property>
+		      <property name="cursor_visible">True</property>
+		      <property name="pixels_above_lines">0</property>
+		      <property name="pixels_below_lines">0</property>
+		      <property name="pixels_inside_wrap">0</property>
+		      <property name="left_margin">0</property>
+		      <property name="right_margin">0</property>
+		      <property name="indent">0</property>
+		      <property name="text" translatable="yes">Sorry, no help available for this option yet.</property>
+		    </widget>
+		  </child>
+		</widget>
+		<packing>
+		  <property name="shrink">True</property>
+		  <property name="resize">True</property>
+		</packing>
+	      </child>
+	    </widget>
+	    <packing>
+	      <property name="shrink">True</property>
+	      <property name="resize">True</property>
+	    </packing>
+	  </child>
+	</widget>
+	<packing>
+	  <property name="padding">0</property>
+	  <property name="expand">True</property>
+	  <property name="fill">True</property>
+	</packing>
+      </child>
+    </widget>
+  </child>
+</widget>
+
+</glade-interface>
diff --git a/scripts/kconfig/images.c b/scripts/kconfig/images.c
index 65a5d67..d4f84bd 100644
--- a/scripts/kconfig/images.c
+++ b/scripts/kconfig/images.c
@@ -1,292 +1,326 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 static const char *xpm_load[] = {
 "22 22 5 1",
 ". c None",
 "# c #000000",
 "c c #838100",
 "a c #ffff00",
 "b c #ffffff",
 "......................",
 "......................",
 "......................",
 "............####....#.",
 "...........#....##.##.",
 "..................###.",
 ".................####.",
 ".####...........#####.",
 "#abab##########.......",
 "#babababababab#.......",
 "#ababababababa#.......",
 "#babababababab#.......",
 "#ababab###############",
 "#babab##cccccccccccc##",
 "#abab##cccccccccccc##.",
 "#bab##cccccccccccc##..",
 "#ab##cccccccccccc##...",
 "#b##cccccccccccc##....",
 "###cccccccccccc##.....",
 "##cccccccccccc##......",
 "###############.......",
 "......................"};
 
 static const char *xpm_save[] = {
 "22 22 5 1",
 ". c None",
 "# c #000000",
 "a c #838100",
 "b c #c5c2c5",
 "c c #cdb6d5",
 "......................",
 ".####################.",
 ".#aa#bbbbbbbbbbbb#bb#.",
 ".#aa#bbbbbbbbbbbb#bb#.",
 ".#aa#bbbbbbbbbcbb####.",
 ".#aa#bbbccbbbbbbb#aa#.",
 ".#aa#bbbccbbbbbbb#aa#.",
 ".#aa#bbbbbbbbbbbb#aa#.",
 ".#aa#bbbbbbbbbbbb#aa#.",
 ".#aa#bbbbbbbbbbbb#aa#.",
 ".#aa#bbbbbbbbbbbb#aa#.",
 ".#aaa############aaa#.",
 ".#aaaaaaaaaaaaaaaaaa#.",
 ".#aaaaaaaaaaaaaaaaaa#.",
 ".#aaa#############aa#.",
 ".#aaa#########bbb#aa#.",
 ".#aaa#########bbb#aa#.",
 ".#aaa#########bbb#aa#.",
 ".#aaa#########bbb#aa#.",
 ".#aaa#########bbb#aa#.",
 "..##################..",
 "......................"};
 
 static const char *xpm_back[] = {
 "22 22 3 1",
 ". c None",
 "# c #000083",
 "a c #838183",
 "......................",
 "......................",
 "......................",
 "......................",
 "......................",
 "...........######a....",
 "..#......##########...",
 "..##...####......##a..",
 "..###.###.........##..",
 "..######..........##..",
 "..#####...........##..",
 "..######..........##..",
 "..#######.........##..",
 "..########.......##a..",
 "...............a###...",
 "...............###....",
 "......................",
 "......................",
 "......................",
 "......................",
 "......................",
 "......................"};
 
 static const char *xpm_tree_view[] = {
 "22 22 2 1",
 ". c None",
 "# c #000000",
 "......................",
 "......................",
 "......#...............",
 "......#...............",
 "......#...............",
 "......#...............",
 "......#...............",
 "......########........",
 "......#...............",
 "......#...............",
 "......#...............",
 "......#...............",
 "......#...............",
 "......########........",
 "......#...............",
 "......#...............",
 "......#...............",
 "......#...............",
 "......#...............",
 "......########........",
 "......................",
 "......................"};
 
 static const char *xpm_single_view[] = {
 "22 22 2 1",
 ". c None",
 "# c #000000",
 "......................",
 "......................",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "..........#...........",
 "......................",
 "......................"};
 
 static const char *xpm_split_view[] = {
 "22 22 2 1",
 ". c None",
 "# c #000000",
 "......................",
 "......................",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......#......#........",
 "......................",
 "......................"};
 
 static const char *xpm_symbol_no[] = {
 "12 12 2 1",
 "  c white",
 ". c black",
 "            ",
 " .......... ",
 " .        . ",
 " .        . ",
 " .        . ",
 " .        . ",
 " .        . ",
 " .        . ",
 " .        . ",
 " .        . ",
 " .......... ",
 "            "};
 
 static const char *xpm_symbol_mod[] = {
 "12 12 2 1",
 "  c white",
 ". c black",
 "            ",
 " .......... ",
 " .        . ",
 " .        . ",
 " .   ..   . ",
 " .  ....  . ",
 " .  ....  . ",
 " .   ..   . ",
 " .        . ",
 " .        . ",
 " .......... ",
 "            "};
 
 static const char *xpm_symbol_yes[] = {
 "12 12 2 1",
 "  c white",
 ". c black",
 "            ",
 " .......... ",
 " .        . ",
 " .        . ",
 " .      . . ",
 " .     .. . ",
 " . .  ..  . ",
 " . ....   . ",
 " .  ..    . ",
 " .        . ",
 " .......... ",
 "            "};
 
 static const char *xpm_choice_no[] = {
 "12 12 2 1",
 "  c white",
 ". c black",
 "            ",
 "    ....    ",
 "  ..    ..  ",
 "  .      .  ",
 " .        . ",
 " .        . ",
 " .        . ",
 " .        . ",
 "  .      .  ",
 "  ..    ..  ",
 "    ....    ",
 "            "};
 
 static const char *xpm_choice_yes[] = {
 "12 12 2 1",
 "  c white",
 ". c black",
 "            ",
 "    ....    ",
 "  ..    ..  ",
 "  .      .  ",
 " .   ..   . ",
 " .  ....  . ",
 " .  ....  . ",
 " .   ..   . ",
 "  .      .  ",
 "  ..    ..  ",
 "    ....    ",
 "            "};
 
 static const char *xpm_menu[] = {
 "12 12 2 1",
 "  c white",
 ". c black",
 "            ",
 " .......... ",
 " .        . ",
 " . ..     . ",
 " . ....   . ",
 " . ...... . ",
 " . ...... . ",
 " . ....   . ",
 " . ..     . ",
 " .        . ",
 " .......... ",
 "            "};
 
 static const char *xpm_menu_inv[] = {
 "12 12 2 1",
 "  c white",
 ". c black",
 "            ",
 " .......... ",
 " .......... ",
 " ..  ...... ",
 " ..    .... ",
 " ..      .. ",
 " ..      .. ",
 " ..    .... ",
 " ..  ...... ",
 " .......... ",
 " .......... ",
 "            "};
+
+static const char *xpm_menuback[] = {
+"12 12 2 1",
+"  c white",
+". c black",
+"            ",
+" .......... ",
+" .        . ",
+" .     .. . ",
+" .   .... . ",
+" . ...... . ",
+" . ...... . ",
+" .   .... . ",
+" .     .. . ",
+" .        . ",
+" .......... ",
+"            "};
+
+static const char *xpm_void[] = {
+"12 12 2 1",
+"  c white",
+". c black",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            ",
+"            "};
diff --git a/scripts/kconfig/lkc-language.txt b/scripts/kconfig/lkc-language.txt
index a3037ff..40f8583 100644
--- a/scripts/kconfig/lkc-language.txt
+++ b/scripts/kconfig/lkc-language.txt
@@ -1,255 +1,279 @@
 Introduction
 ------------
 
 The configuration database is collection of configuration options
 organized in a tree structure:
 
 	+- Code maturity level options
 	|  +- Prompt for development and/or incomplete code/drivers
 	+- General setup
 	|  +- Networking support
 	|  +- System V IPC
 	|  +- BSD Process Accounting
 	|  +- Sysctl support
 	+- Loadable module support
 	|  +- Enable loadable module support
 	|     +- Set version information on all module symbols
 	|     +- Kernel module loader
 	+- ...
 
 Every entry has its own dependencies. These dependencies are used
-to determine the visible of an entry. Any child entry is only
+to determine the visibility of an entry. Any child entry is only
 visible if its parent entry is also visible.
 
 Menu entries
 ------------
 
 Most entries define a config option, all other entries help to organize
 them. A single configuration option is defined like this:
 
 config MODVERSIONS
 	bool "Set version information on all module symbols"
 	depends MODULES
 	help
 	  Usually, modules have to be recompiled whenever you switch to a new
 	  kernel.  ...
 
 Every line starts with a key word and can be followed by multiple
 arguments.  "config" starts a new config entry. The following lines
 define attributes for this config option. Attributes can be the type of
 the config option, input prompt, dependencies, help text and default
 values. A config option can be defined multiple times with the same
 name, but every definition can have only a single input prompt and the
 type must not conflict.
 
 Menu attributes
 ---------------
 
 A menu entry can have a number of attributes. Not all of them are
 applicable everywhere (see syntax).
 
 - type definition: "bool"/"tristate"/"string"/"hex"/"integer"
   Every config option must have a type. There are only two basic types:
-  tristate and string, the other types base on these two. The type
+  tristate and string, the other types are based on these two. The type
   definition optionally accepts an input prompt, so these two examples
   are equivalent:
 
 	bool "Networking support"
   and
 	bool
 	prompt "Networking support"
 
 - input prompt: "prompt" <prompt> ["if" <expr>]
   Every menu entry can have at most one prompt, which is used to display
   to the user. Optionally dependencies only for this prompt can be added
   with "if".
 
-- default value: "default" <symbol> ["if" <expr>]
+- default value: "default" <expr> ["if" <expr>]
   A config option can have any number of default values. If multiple
   default values are visible, only the first defined one is active.
   Default values are not limited to the menu entry, where they are
   defined, this means the default can be defined somewhere else or be
-  overriden by an earlier definition.
+  overridden by an earlier definition.
   The default value is only assigned to the config symbol if no other
   value was set by the user (via the input prompt above). If an input
   prompt is visible the default value is presented to the user and can
   be overridden by him.
   Optionally dependencies only for this default value can be added with
   "if".
 
 - dependencies: "depends on"/"requires" <expr>
   This defines a dependency for this menu entry. If multiple
   dependencies are defined they are connected with '&&'. Dependencies
   are applied to all other options within this menu entry (which also
-  accept "if" expression), so these two examples are equivalent:
+  accept an "if" expression), so these two examples are equivalent:
 
 	bool "foo" if BAR
 	default y if BAR
   and
 	depends on BAR
 	bool "foo"
 	default y
 
+- reverse dependencies: "select" <symbol> ["if" <expr>]
+  While normal dependencies reduce the upper limit of a symbol (see
+  below), reverse dependencies can be used to force a lower limit of
+  another symbol. The value of the current menu symbol is used as the
+  minimal value <symbol> can be set to. If <symbol> is selected multiple
+  times, the limit is set to the largest selection.
+  Reverse dependencies can only be used with boolean or tristate
+  symbols.
+
+- numerical ranges: "range" <symbol> <symbol> ["if" <expr>]
+  This allows to limit the range of possible input values for integer
+  and hex symbols. The user can only input a value which is larger than
+  or equal to the first symbol and smaller than or equal to the second
+  symbol.
+
 - help text: "help"
   This defines a help text. The end of the help text is determined by
-  the level indentation, this means it ends at the first line which has
+  the indentation level, this means it ends at the first line which has
   a smaller indentation than the first line of the help text.
 
 
 Menu dependencies
 -----------------
 
 Dependencies define the visibility of a menu entry and can also reduce
 the input range of tristate symbols. The tristate logic used in the
 expressions uses one more state than normal boolean logic to express the
 module state. Dependency expressions have the following syntax:
 
 <expr> ::= <symbol>                             (1)
            <symbol> '=' <symbol>                (2)
            <symbol> '!=' <symbol>               (3)
            '(' <expr> ')'                       (4)
            '!' <expr>                           (5)
            <expr> '||' <expr>                   (6)
            <expr> '&&' <expr>                   (7)
 
 Expressions are listed in decreasing order of precedence. 
 
 (1) Convert the symbol into an expression. Boolean and tristate symbols
     are simply converted into the respective expression values. All
     other symbol types result in 'n'.
 (2) If the values of both symbols are equal, it returns 'y',
     otherwise 'n'.
 (3) If the values of both symbols are equal, it returns 'n',
     otherwise 'y'.
 (4) Returns the value of the expression. Used to override precedence.
 (5) Returns the result of (2-/expr/).
-(6) Returns the result of min(/expr/, /expr/).
-(7) Returns the result of max(/expr/, /expr/).
+(6) Returns the result of max(/expr/, /expr/).
+(7) Returns the result of min(/expr/, /expr/).
 
 An expression can have a value of 'n', 'm' or 'y' (or 0, 1, 2
 respectively for calculations). A menu entry becomes visible when it's
 expression evaluates to 'm' or 'y'.
 
-There are two type of symbols: constant and nonconstant symbols.
+There are two types of symbols: constant and nonconstant symbols.
 Nonconstant symbols are the most common ones and are defined with the
 'config' statement. Nonconstant symbols consist entirely of alphanumeric
 characters or underscores.
 Constant symbols are only part of expressions. Constant symbols are
 always surrounded by single or double quotes. Within the quote any
 other character is allowed and the quotes can be escaped using '\'.
 
 Menu structure
 --------------
 
 The position of a menu entry in the tree is determined in two ways. First
-it can be specified explicitely:
+it can be specified explicitly:
 
 menu "Network device support"
 	depends NET
 
 config NETDEVICES
 	...
 
 endmenu
 
 All entries within the "menu" ... "endmenu" block become a submenu of
 "Network device support". All subentries inherit the dependencies from
 the menu entry, e.g. this means the dependency "NET" is added to the
 dependency list of the config option NETDEVICES.
 
 The other way to generate the menu structure is done by analyzing the
 dependencies. If a menu entry somehow depends on the previous entry, it
-can be made a submenu of it. First the the previous (parent) symbol must
-be part of the dependency list and then one of these two condititions
+can be made a submenu of it. First, the previous (parent) symbol must
+be part of the dependency list and then one of these two conditions
 must be true:
 - the child entry must become invisible, if the parent is set to 'n'
 - the child entry must only be visible, if the parent is visible
 
 config MODULES
 	bool "Enable loadable module support"
 
 config MODVERSIONS
 	bool "Set version information on all module symbols"
 	depends MODULES
 
 comment "module support disabled"
 	depends !MODULES
 
 MODVERSIONS directly depends on MODULES, this means it's only visible if
 MODULES is different from 'n'. The comment on the other hand is always
-visible when MODULES it's visible (the (empty) dependency of MODULES is
+visible when MODULES is visible (the (empty) dependency of MODULES is
 also part of the comment dependencies).
 
 
 Kconfig syntax
 --------------
 
 The configuration file describes a series of menu entries, where every
 line starts with a keyword (except help texts). The following keywords
 end a menu entry:
 - config
+- menuconfig
 - choice/endchoice
 - comment
 - menu/endmenu
 - if/endif
 - source
-The first four also start the definition of a menu entry.
+The first five also start the definition of a menu entry.
 
 config:
 
 	"config" <symbol>
 	<config options>
 
 This defines a config symbol <symbol> and accepts any of above
 attributes as options.
 
+menuconfig:
+	"menuconfig" <symbol>
+	<config options>
+
+This is similiar to the simple config entry above, but it also gives a
+hint to front ends, that all suboptions should be displayed as a
+separate list of options.
+
 choices:
 
 	"choice"
 	<choice options>
 	<choice block>
 	"endchoice"
 
 This defines a choice group and accepts any of above attributes as
 options. A choice can only be of type bool or tristate, while a boolean
 choice only allows a single config entry to be selected, a tristate
 choice also allows any number of config entries to be set to 'm'. This
 can be used if multiple drivers for a single hardware exists and only a
 single driver can be compiled/loaded into the kernel, but all drivers
 can be compiled as modules.
 A choice accepts another option "optional", which allows to set the
 choice to 'n' and no entry needs to be selected.
 
 comment:
 
 	"comment" <prompt>
 	<comment options>
 
 This defines a comment which is displayed to the user during the
 configuration process and is also echoed to the output files. The only
 possible options are dependencies.
 
 menu:
 
 	"menu" <prompt>
 	<menu options>
 	<menu block>
 	"endmenu"
 
 This defines a menu block, see "Menu structure" above for more
 information. The only possible options are dependencies.
 
 if:
 
 	"if" <expr>
 	<if block>
 	"endif"
 
 This defines an if block. The dependency expression <expr> is appended
 to all enclosed menu entries.
 
 source:
 
 	"source" <prompt>
 
 This reads the specified configuration file. This file is always parsed.
diff --git a/scripts/kconfig/lkc.h b/scripts/kconfig/lkc.h
index cdd04a9..dd040f7 100644
--- a/scripts/kconfig/lkc.h
+++ b/scripts/kconfig/lkc.h
@@ -1,109 +1,113 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #ifndef LKC_H
 #define LKC_H
 
 #include "expr.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #ifdef LKC_DIRECT_LINK
 #define P(name,type,arg)	extern type name arg
 #else
 #include "lkc_defs.h"
 #define P(name,type,arg)	extern type (*name ## _p) arg
 #endif
 #include "lkc_proto.h"
 #undef P
 
 #define SRCTREE "srctree"
 
 int zconfparse(void);
 void zconfdump(FILE *out);
 
 extern int zconfdebug;
 void zconf_starthelp(void);
 FILE *zconf_fopen(const char *name);
 void zconf_initscan(const char *name);
 void zconf_nextfile(const char *name);
 int zconf_lineno(void);
 char *zconf_curname(void);
 
 /* confdata.c */
 extern const char conf_def_filename[];
 extern char conf_filename[];
 
 char *conf_get_default_confname(void);
 
 /* kconfig_load.c */
 void kconfig_load(void);
 
 /* menu.c */
 void menu_init(void);
 void menu_add_menu(void);
 void menu_end_menu(void);
 void menu_add_entry(struct symbol *sym);
 void menu_end_entry(void);
-struct property *create_prop(enum prop_type type);
 void menu_add_dep(struct expr *dep);
-struct property *menu_add_prop(int token, char *prompt, struct symbol *def, struct expr *dep);
+struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep);
+void menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep);
+void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep);
+void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep);
 void menu_finalize(struct menu *parent);
 void menu_set_type(int type);
 struct file *file_lookup(const char *name);
 int file_write_dep(const char *name);
 
 extern struct menu *current_entry;
 extern struct menu *current_menu;
 
 /* symbol.c */
 void sym_init(void);
 void sym_clear_all_valid(void);
 void sym_set_changed(struct symbol *sym);
+struct symbol *sym_check_deps(struct symbol *sym);
+struct property *prop_alloc(enum prop_type type, struct symbol *sym);
+struct symbol *prop_get_symbol(struct property *prop);
 
 static inline tristate sym_get_tristate_value(struct symbol *sym)
 {
-	return S_TRI(sym->curr);
+	return sym->curr.tri;
 }
 
 
 static inline struct symbol *sym_get_choice_value(struct symbol *sym)
 {
-	return (struct symbol *)S_VAL(sym->curr);
+	return (struct symbol *)sym->curr.val;
 }
 
 static inline bool sym_set_choice_value(struct symbol *ch, struct symbol *chval)
 {
 	return sym_set_tristate_value(chval, yes);
 }
 
 static inline bool sym_is_choice(struct symbol *sym)
 {
 	return sym->flags & SYMBOL_CHOICE ? true : false;
 }
 
 static inline bool sym_is_choice_value(struct symbol *sym)
 {
 	return sym->flags & SYMBOL_CHOICEVAL ? true : false;
 }
 
 static inline bool sym_is_optional(struct symbol *sym)
 {
 	return sym->flags & SYMBOL_OPTIONAL ? true : false;
 }
 
 static inline bool sym_has_value(struct symbol *sym)
 {
-	//return S_VAL(sym->def) != NULL;
 	return sym->flags & SYMBOL_NEW ? false : true;
 }
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* LKC_H */
diff --git a/scripts/kconfig/lkc_proto.h b/scripts/kconfig/lkc_proto.h
index 116d759..97c7917 100644
--- a/scripts/kconfig/lkc_proto.h
+++ b/scripts/kconfig/lkc_proto.h
@@ -1,38 +1,39 @@
 
 /* confdata.c */
 P(conf_parse,void,(const char *name));
 P(conf_read,int,(const char *name));
 P(conf_write,int,(const char *name));
 
 /* menu.c */
 P(rootmenu,struct menu,);
 
 P(menu_is_visible,bool,(struct menu *menu));
 P(menu_get_prompt,const char *,(struct menu *menu));
 P(menu_get_root_menu,struct menu *,(struct menu *menu));
 P(menu_get_parent_menu,struct menu *,(struct menu *menu));
 
 /* symbol.c */
 P(symbol_hash,struct symbol *,[SYMBOL_HASHSIZE]);
 P(sym_change_count,int,);
 
 P(sym_lookup,struct symbol *,(const char *name, int isconst));
 P(sym_find,struct symbol *,(const char *name));
-P(sym_type_name,const char *,(int type));
+P(sym_type_name,const char *,(enum symbol_type type));
 P(sym_calc_value,void,(struct symbol *sym));
-P(sym_get_type,int,(struct symbol *sym));
+P(sym_get_type,enum symbol_type,(struct symbol *sym));
 P(sym_tristate_within_range,bool,(struct symbol *sym,tristate tri));
 P(sym_set_tristate_value,bool,(struct symbol *sym,tristate tri));
 P(sym_toggle_tristate_value,tristate,(struct symbol *sym));
 P(sym_string_valid,bool,(struct symbol *sym, const char *newval));
+P(sym_string_within_range,bool,(struct symbol *sym, const char *str));
 P(sym_set_string_value,bool,(struct symbol *sym, const char *newval));
 P(sym_is_changable,bool,(struct symbol *sym));
 P(sym_get_choice_prop,struct property *,(struct symbol *sym));
 P(sym_get_default_prop,struct property *,(struct symbol *sym));
 P(sym_get_string_value,const char *,(struct symbol *sym));
 
 P(prop_get_type_name,const char *,(enum prop_type type));
 
 /* expr.c */
 P(expr_compare_type,int,(enum expr_type t1, enum expr_type t2));
 P(expr_print,void,(struct expr *e, void (*fn)(void *, const char *), void *data, int prevtoken));
diff --git a/scripts/kconfig/mconf.c b/scripts/kconfig/mconf.c
index 6d82718..b9cf25f 100644
--- a/scripts/kconfig/mconf.c
+++ b/scripts/kconfig/mconf.c
@@ -1,780 +1,802 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  *
  * Introduced single menu mode (show all sub-menus in one large tree).
  * 2002-11-06 Petr Baudis <pasky@ucw.cz>
  */
 
 #include <sys/ioctl.h>
 #include <sys/wait.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 #include <termios.h>
 #include <unistd.h>
 
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 
 static char menu_backtitle[128];
 static const char menu_instructions[] =
 	"Arrow keys navigate the menu.  "
 	"<Enter> selects submenus --->.  "
 	"Highlighted letters are hotkeys.  "
 	"Pressing <Y> includes, <N> excludes, <M> modularizes features.  "
 	"Press <Esc><Esc> to exit, <?> for Help.  "
 	"Legend: [*] built-in  [ ] excluded  <M> module  < > module capable",
 radiolist_instructions[] =
 	"Use the arrow keys to navigate this window or "
 	"press the hotkey of the item you wish to select "
 	"followed by the <SPACE BAR>. "
 	"Press <?> for additional information about this option.",
 inputbox_instructions_int[] =
 	"Please enter a decimal value. "
 	"Fractions will not be accepted.  "
 	"Use the <TAB> key to move from the input field to the buttons below it.",
 inputbox_instructions_hex[] =
 	"Please enter a hexadecimal value. "
 	"Use the <TAB> key to move from the input field to the buttons below it.",
 inputbox_instructions_string[] =
 	"Please enter a string value. "
 	"Use the <TAB> key to move from the input field to the buttons below it.",
 setmod_text[] =
 	"This feature depends on another which has been configured as a module.\n"
 	"As a result, this feature will be built as a module.",
 nohelp_text[] =
-	"There is no help available for this kernel option.\n",
+	"There is no help available for this option.\n",
 load_config_text[] =
 	"Enter the name of the configuration file you wish to load.  "
 	"Accept the name shown to restore the configuration you "
 	"last retrieved.  Leave blank to abort.",
 load_config_help[] =
 	"\n"
-	"For various reasons, one may wish to keep several different kernel\n"
+	"For various reasons, one may wish to keep several different \n"
 	"configurations available on a single machine.\n"
 	"\n"
 	"If you have saved a previous configuration in a file other than the\n"
-	"kernel's default, entering the name of the file here will allow you\n"
+	"default, entering the name of the file here will allow you\n"
 	"to modify that configuration.\n"
 	"\n"
 	"If you are uncertain, then you have probably never used alternate\n"
 	"configuration files.  You should therefor leave this blank to abort.\n",
 save_config_text[] =
 	"Enter a filename to which this configuration should be saved "
 	"as an alternate.  Leave blank to abort.",
 save_config_help[] =
 	"\n"
-	"For various reasons, one may wish to keep different kernel\n"
+	"For various reasons, one may wish to keep different\n"
 	"configurations available on a single machine.\n"
 	"\n"
 	"Entering a file name here will allow you to later retrieve, modify\n"
 	"and use the current configuration as an alternate to whatever\n"
 	"configuration options you have selected at that time.\n"
 	"\n"
 	"If you are uncertain what all this means then you should probably\n"
 	"leave this blank.\n"
 ;
 
 static char buf[4096], *bufptr = buf;
 static char input_buf[4096];
 static char filename[PATH_MAX+1] = ".config";
 static char *args[1024], **argptr = args;
 static int indent = 0;
 static struct termios ios_org;
 static int rows, cols;
 static struct menu *current_menu;
 static int child_count;
 static int do_resize;
 static int single_menu_mode;
 
 static void conf(struct menu *menu);
 static void conf_choice(struct menu *menu);
 static void conf_string(struct menu *menu);
 static void conf_load(void);
 static void conf_save(void);
 static void show_textbox(const char *title, const char *text, int r, int c);
 static void show_helptext(const char *title, const char *text);
 static void show_help(struct menu *menu);
 static void show_readme(void);
 
 static void cprint_init(void);
 static int cprint1(const char *fmt, ...);
 static void cprint_done(void);
 static int cprint(const char *fmt, ...);
 
 static void init_wsize(void)
 {
 	struct winsize ws;
 	char *env;
 
 	if (ioctl(1, TIOCGWINSZ, &ws) == -1) {
 		rows = 24;
 		cols = 80;
 	} else {
 		rows = ws.ws_row;
 		cols = ws.ws_col;
 		if (!rows) {
 			env = getenv("LINES");
 			if (env)
 				rows = atoi(env);
 			if (!rows)
 				rows = 24;
 		}
 		if (!cols) {
 			env = getenv("COLUMNS");
 			if (env)
 				cols = atoi(env);
 			if (!cols)
 				cols = 80;
 		}
 	}
 
 	if (rows < 19 || cols < 80) {
 		fprintf(stderr, "Your display is too small to run Menuconfig!\n");
 		fprintf(stderr, "It must be at least 19 lines by 80 columns.\n");
 		exit(1);
 	}
 
 	rows -= 4;
 	cols -= 5;
 }
 
 static void cprint_init(void)
 {
+	char *env = getenv("LXDIALOG");
 	bufptr = buf;
 	argptr = args;
 	memset(args, 0, sizeof(args));
 	indent = 0;
 	child_count = 0;
-	cprint("./scripts/lxdialog/lxdialog");
+	if(env != NULL) {
+		cprint(env);
+	} else {
+		cprint("./scripts/lxdialog/lxdialog");
+	}
 	cprint("--backtitle");
 	cprint(menu_backtitle);
 }
 
 static int cprint1(const char *fmt, ...)
 {
 	va_list ap;
 	int res;
 
 	if (!*argptr)
 		*argptr = bufptr;
 	va_start(ap, fmt);
 	res = vsprintf(bufptr, fmt, ap);
 	va_end(ap);
 	bufptr += res;
 
 	return res;
 }
 
 static void cprint_done(void)
 {
 	*bufptr++ = 0;
 	argptr++;
 }
 
 static int cprint(const char *fmt, ...)
 {
 	va_list ap;
 	int res;
 
 	*argptr++ = bufptr;
 	va_start(ap, fmt);
 	res = vsprintf(bufptr, fmt, ap);
 	va_end(ap);
 	bufptr += res;
 	*bufptr++ = 0;
 
 	return res;
 }
 
 pid_t pid;
 
 static void winch_handler(int sig)
 {
 	if (!do_resize) {
 		kill(pid, SIGINT);
 		do_resize = 1;
 	}
 }
 
 static int exec_conf(void)
 {
 	int pipefd[2], stat, size;
 	struct sigaction sa;
 	sigset_t sset, osset;
 
 	sigemptyset(&sset);
 	sigaddset(&sset, SIGINT);
 	sigprocmask(SIG_BLOCK, &sset, &osset);
 
 	signal(SIGINT, SIG_DFL);
 
 	sa.sa_handler = winch_handler;
 	sigemptyset(&sa.sa_mask);
 	sa.sa_flags = SA_RESTART;
 	sigaction(SIGWINCH, &sa, NULL);
 
 	*argptr++ = NULL;
 
 	pipe(pipefd);
 	pid = fork();
 	if (pid == 0) {
 		sigprocmask(SIG_SETMASK, &osset, NULL);
 		dup2(pipefd[1], 2);
 		close(pipefd[0]);
 		close(pipefd[1]);
 		execv(args[0], args);
 		_exit(EXIT_FAILURE);
 	}
 
 	close(pipefd[1]);
 	bufptr = input_buf;
 	while (1) {
 		size = input_buf + sizeof(input_buf) - bufptr;
 		size = read(pipefd[0], bufptr, size);
 		if (size <= 0) {
 			if (size < 0) {
 				if (errno == EINTR || errno == EAGAIN)
 					continue;
 				perror("read");
 			}
 			break;
 		}
 		bufptr += size;
 	}
 	*bufptr++ = 0;
 	close(pipefd[0]);
 	waitpid(pid, &stat, 0);
 
 	if (do_resize) {
 		init_wsize();
 		do_resize = 0;
 		sigprocmask(SIG_SETMASK, &osset, NULL);
 		return -1;
 	}
 	if (WIFSIGNALED(stat)) {
 		printf("\finterrupted(%d)\n", WTERMSIG(stat));
 		exit(1);
 	}
 #if 0
 	printf("\fexit state: %d\nexit data: '%s'\n", WEXITSTATUS(stat), input_buf);
 	sleep(1);
 #endif
 	sigpending(&sset);
 	if (sigismember(&sset, SIGINT)) {
 		printf("\finterrupted\n");
 		exit(1);
 	}
 	sigprocmask(SIG_SETMASK, &osset, NULL);
 
 	return WEXITSTATUS(stat);
 }
 
 static void build_conf(struct menu *menu)
 {
 	struct symbol *sym;
 	struct property *prop;
 	struct menu *child;
 	int type, tmp, doint = 2;
 	tristate val;
 	char ch;
 
 	if (!menu_is_visible(menu))
 		return;
 
 	sym = menu->sym;
 	prop = menu->prompt;
 	if (!sym) {
 		if (prop && menu != current_menu) {
 			const char *prompt = menu_get_prompt(menu);
 			switch (prop->type) {
 			case P_MENU:
 				child_count++;
 				cprint("m%p", menu);
 
 				if (single_menu_mode) {
 					cprint1("%s%*c%s",
 						menu->data ? "-->" : "++>",
 						indent + 1, ' ', prompt);
-				} else {
-					if (menu->parent != &rootmenu)
-						cprint1("   %*c", indent + 1, ' ');
-					cprint1("%s  --->", prompt);
-				}
+				} else
+					cprint1("   %*c%s  --->", indent + 1, ' ', prompt);
 
 				cprint_done();
 				if (single_menu_mode && menu->data)
 					goto conf_childs;
 				return;
 			default:
 				if (prompt) {
 					child_count++;
 					cprint(":%p", menu);
 					cprint("---%*c%s", indent + 1, ' ', prompt);
 				}
 			}
 		} else
 			doint = 0;
 		goto conf_childs;
 	}
 
 	type = sym_get_type(sym);
 	if (sym_is_choice(sym)) {
 		struct symbol *def_sym = sym_get_choice_value(sym);
 		struct menu *def_menu = NULL;
 
 		child_count++;
 		for (child = menu->list; child; child = child->next) {
 			if (menu_is_visible(child) && child->sym == def_sym)
 				def_menu = child;
 		}
 
 		val = sym_get_tristate_value(sym);
 		if (sym_is_changable(sym)) {
 			cprint("t%p", menu);
 			switch (type) {
 			case S_BOOLEAN:
 				cprint1("[%c]", val == no ? ' ' : '*');
 				break;
 			case S_TRISTATE:
 				switch (val) {
 				case yes: ch = '*'; break;
 				case mod: ch = 'M'; break;
 				default:  ch = ' '; break;
 				}
 				cprint1("<%c>", ch);
 				break;
 			}
 		} else {
 			cprint("%c%p", def_menu ? 't' : ':', menu);
 			cprint1("   ");
 		}
 
 		cprint1("%*c%s", indent + 1, ' ', menu_get_prompt(menu));
 		if (val == yes) {
 			if (def_menu) {
 				cprint1(" (%s)", menu_get_prompt(def_menu));
 				cprint1("  --->");
 				cprint_done();
 				if (def_menu->list) {
 					indent += 2;
 					build_conf(def_menu);
 					indent -= 2;
 				}
 			} else
 				cprint_done();
 			return;
 		}
 		cprint_done();
 	} else {
+		if (menu == current_menu) {
+			cprint(":%p", menu);
+			cprint("---%*c%s", indent + 1, ' ', menu_get_prompt(menu));
+			goto conf_childs;
+		}
 		child_count++;
 		val = sym_get_tristate_value(sym);
 		if (sym_is_choice_value(sym) && val == yes) {
 			cprint(":%p", menu);
 			cprint1("   ");
 		} else {
 			switch (type) {
 			case S_BOOLEAN:
 				cprint("t%p", menu);
-				cprint1("[%c]", val == no ? ' ' : '*');
+				if (sym_is_changable(sym))
+					cprint1("[%c]", val == no ? ' ' : '*');
+				else
+					cprint1("---");
 				break;
 			case S_TRISTATE:
 				cprint("t%p", menu);
 				switch (val) {
 				case yes: ch = '*'; break;
 				case mod: ch = 'M'; break;
 				default:  ch = ' '; break;
 				}
-				cprint1("<%c>", ch);
+				if (sym_is_changable(sym))
+					cprint1("<%c>", ch);
+				else
+					cprint1("---");
 				break;
 			default:
 				cprint("s%p", menu);
 				tmp = cprint1("(%s)", sym_get_string_value(sym));
 				tmp = indent - tmp + 4;
 				if (tmp < 0)
 					tmp = 0;
 				cprint1("%*c%s%s", tmp, ' ', menu_get_prompt(menu),
-					sym_has_value(sym) ? "" : " (NEW)");
+					(sym_has_value(sym) || !sym_is_changable(sym)) ?
+					"" : " (NEW)");
 				cprint_done();
 				goto conf_childs;
 			}
 		}
 		cprint1("%*c%s%s", indent + 1, ' ', menu_get_prompt(menu),
-			sym_has_value(sym) ? "" : " (NEW)");
+			(sym_has_value(sym) || !sym_is_changable(sym)) ?
+			"" : " (NEW)");
+		if (menu->prompt->type == P_MENU) {
+			cprint1("  --->");
+			cprint_done();
+			return;
+		}
 		cprint_done();
 	}
 
 conf_childs:
 	indent += doint;
 	for (child = menu->list; child; child = child->next)
 		build_conf(child);
 	indent -= doint;
 }
 
 static void conf(struct menu *menu)
 {
 	struct menu *submenu;
 	const char *prompt = menu_get_prompt(menu);
 	struct symbol *sym;
 	char active_entry[40];
 	int stat, type, i;
 
 	unlink("lxdialog.scrltmp");
 	active_entry[0] = 0;
 	while (1) {
 		cprint_init();
 		cprint("--title");
 		cprint("%s", prompt ? prompt : "Main Menu");
 		cprint("--menu");
 		cprint(menu_instructions);
 		cprint("%d", rows);
 		cprint("%d", cols);
 		cprint("%d", rows - 10);
 		cprint("%s", active_entry);
 		current_menu = menu;
 		build_conf(menu);
 		if (!child_count)
 			break;
 		if (menu == &rootmenu) {
 			cprint(":");
 			cprint("--- ");
 			cprint("L");
-			cprint("Load an Alternate Configuration File");
+			cprint("    Load an Alternate Configuration File");
 			cprint("S");
-			cprint("Save Configuration to an Alternate File");
+			cprint("    Save Configuration to an Alternate File");
 		}
 		stat = exec_conf();
 		if (stat < 0)
 			continue;
 
 		if (stat == 1 || stat == 255)
 			break;
 
 		type = input_buf[0];
 		if (!type)
 			continue;
 
 		for (i = 0; input_buf[i] && !isspace(input_buf[i]); i++)
 			;
 		if (i >= sizeof(active_entry))
 			i = sizeof(active_entry) - 1;
 		input_buf[i] = 0;
 		strcpy(active_entry, input_buf);
 
 		sym = NULL;
 		submenu = NULL;
 		if (sscanf(input_buf + 1, "%p", &submenu) == 1)
 			sym = submenu->sym;
 
 		switch (stat) {
 		case 0:
 			switch (type) {
 			case 'm':
 				if (single_menu_mode)
 					submenu->data = (void *) !submenu->data;
 				else
 					conf(submenu);
 				break;
 			case 't':
 				if (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)
 					conf_choice(submenu);
+				else if (submenu->prompt->type == P_MENU)
+					conf(submenu);
 				break;
 			case 's':
 				conf_string(submenu);
 				break;
 			case 'L':
 				conf_load();
 				break;
 			case 'S':
 				conf_save();
 				break;
 			}
 			break;
 		case 2:
 			if (sym)
 				show_help(submenu);
 			else
 				show_readme();
 			break;
 		case 3:
 			if (type == 't') {
 				if (sym_set_tristate_value(sym, yes))
 					break;
 				if (sym_set_tristate_value(sym, mod))
 					show_textbox(NULL, setmod_text, 6, 74);
 			}
 			break;
 		case 4:
 			if (type == 't')
 				sym_set_tristate_value(sym, no);
 			break;
 		case 5:
 			if (type == 't')
 				sym_set_tristate_value(sym, mod);
 			break;
 		case 6:
 			if (type == 't')
 				sym_toggle_tristate_value(sym);
 			else if (type == 'm')
 				conf(submenu);
 			break;
 		}
 	}
 }
 
 static void show_textbox(const char *title, const char *text, int r, int c)
 {
 	int fd;
 
 	fd = creat(".help.tmp", 0777);
 	write(fd, text, strlen(text));
 	close(fd);
 	do {
 		cprint_init();
 		if (title) {
 			cprint("--title");
 			cprint("%s", title);
 		}
 		cprint("--textbox");
 		cprint(".help.tmp");
 		cprint("%d", r);
 		cprint("%d", c);
 	} while (exec_conf() < 0);
 	unlink(".help.tmp");
 }
 
 static void show_helptext(const char *title, const char *text)
 {
 	show_textbox(title, text, rows, cols);
 }
 
 static void show_help(struct menu *menu)
 {
 	const char *help;
 	char *helptext;
 	struct symbol *sym = menu->sym;
 
 	help = sym->help;
 	if (!help)
 		help = nohelp_text;
 	if (sym->name) {
 		helptext = malloc(strlen(sym->name) + strlen(help) + 16);
 		sprintf(helptext, "CONFIG_%s:\n\n%s", sym->name, help);
 		show_helptext(menu_get_prompt(menu), helptext);
 		free(helptext);
 	} else
 		show_helptext(menu_get_prompt(menu), help);
 }
 
 static void show_readme(void)
 {
 	do {
 		cprint_init();
 		cprint("--textbox");
 		cprint("scripts/README.Menuconfig");
 		cprint("%d", rows);
 		cprint("%d", cols);
 	} while (exec_conf() == -1);
 }
 
 static void conf_choice(struct menu *menu)
 {
 	const char *prompt = menu_get_prompt(menu);
 	struct menu *child;
 	struct symbol *active;
 	int stat;
 
 	while (1) {
 		cprint_init();
 		cprint("--title");
 		cprint("%s", prompt ? prompt : "Main Menu");
 		cprint("--radiolist");
 		cprint(radiolist_instructions);
 		cprint("15");
 		cprint("70");
 		cprint("6");
 
 		current_menu = menu;
 		active = sym_get_choice_value(menu->sym);
 		for (child = menu->list; child; child = child->next) {
 			if (!menu_is_visible(child))
 				continue;
 			cprint("%p", child);
 			cprint("%s", menu_get_prompt(child));
 			cprint(child->sym == active ? "ON" : "OFF");
 		}
 
 		stat = exec_conf();
 		switch (stat) {
 		case 0:
 			if (sscanf(input_buf, "%p", &menu) != 1)
 				break;
 			sym_set_tristate_value(menu->sym, yes);
 			return;
 		case 1:
 			show_help(menu);
 			break;
 		case 255:
 			return;
 		}
 	}
 }
 
 static void conf_string(struct menu *menu)
 {
 	const char *prompt = menu_get_prompt(menu);
 	int stat;
 
 	while (1) {
 		cprint_init();
 		cprint("--title");
 		cprint("%s", prompt ? prompt : "Main Menu");
 		cprint("--inputbox");
 		switch (sym_get_type(menu->sym)) {
 		case S_INT:
 			cprint(inputbox_instructions_int);
 			break;
 		case S_HEX:
 			cprint(inputbox_instructions_hex);
 			break;
 		case S_STRING:
 			cprint(inputbox_instructions_string);
 			break;
 		default:
 			/* panic? */;
 		}
 		cprint("10");
 		cprint("75");
 		cprint("%s", sym_get_string_value(menu->sym));
 		stat = exec_conf();
 		switch (stat) {
 		case 0:
 			if (sym_set_string_value(menu->sym, input_buf))
 				return;
 			show_textbox(NULL, "You have made an invalid entry.", 5, 43);
 			break;
 		case 1:
 			show_help(menu);
 			break;
 		case 255:
 			return;
 		}
 	}
 }
 
 static void conf_load(void)
 {
 	int stat;
 
 	while (1) {
 		cprint_init();
 		cprint("--inputbox");
 		cprint(load_config_text);
 		cprint("11");
 		cprint("55");
 		cprint("%s", filename);
 		stat = exec_conf();
 		switch(stat) {
 		case 0:
 			if (!input_buf[0])
 				return;
 			if (!conf_read(input_buf))
 				return;
 			show_textbox(NULL, "File does not exist!", 5, 38);
 			break;
 		case 1:
 			show_helptext("Load Alternate Configuration", load_config_help);
 			break;
 		case 255:
 			return;
 		}
 	}
 }
 
 static void conf_save(void)
 {
 	int stat;
 
 	while (1) {
 		cprint_init();
 		cprint("--inputbox");
 		cprint(save_config_text);
 		cprint("11");
 		cprint("55");
 		cprint("%s", filename);
 		stat = exec_conf();
 		switch(stat) {
 		case 0:
 			if (!input_buf[0])
 				return;
 			if (!conf_write(input_buf))
 				return;
 			show_textbox(NULL, "Can't create file!  Probably a nonexistent directory.", 5, 60);
 			break;
 		case 1:
 			show_helptext("Save Alternate Configuration", save_config_help);
 			break;
 		case 255:
 			return;
 		}
 	}
 }
 
 static void conf_cleanup(void)
 {
 	tcsetattr(1, TCSAFLUSH, &ios_org);
 	unlink(".help.tmp");
 	unlink("lxdialog.scrltmp");
 }
 
 int main(int ac, char **av)
 {
 	struct symbol *sym;
 	char *mode;
 	int stat;
 
 	conf_parse(av[1]);
 	conf_read(NULL);
 
 	sym = sym_lookup("KERNELRELEASE", 0);
 	sym_calc_value(sym);
-	sprintf(menu_backtitle, "Opie %s Configuration",
-		sym_get_string_value(sym));
+	sprintf(menu_backtitle, "Build Configuration");
 
 	mode = getenv("MENUCONFIG_MODE");
 	if (mode) {
 		if (!strcasecmp(mode, "single_menu"))
 			single_menu_mode = 1;
 	}
 
 	tcgetattr(1, &ios_org);
 	atexit(conf_cleanup);
 	init_wsize();
 	conf(&rootmenu);
 
 	do {
 		cprint_init();
 		cprint("--yesno");
 		cprint("Do you wish to save your new configuration?");
 		cprint("5");
 		cprint("60");
 		stat = exec_conf();
 	} while (stat < 0);
 
 	if (stat == 0) {
 		conf_write(NULL);
 		printf("\n\n"
-			"*** End of Opie configuration.\n"
-			"*** Check the top-level Makefile for additional configuration.\n"
-			"*** Next, you may run 'make'.\n\n");
+			"*** End of configuration.\n"
+			"\n\n");
 	} else
-		printf("\n\nYour Opie  configuration changes were NOT saved.\n\n");
+		printf("\n\n"
+			"Your configuration changes were NOT saved."
+			"\n\n");
 
 	return 0;
 }
diff --git a/scripts/kconfig/menu.c b/scripts/kconfig/menu.c
index 24be0ec..1631767 100644
--- a/scripts/kconfig/menu.c
+++ b/scripts/kconfig/menu.c
@@ -1,309 +1,397 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <stdlib.h>
 #include <string.h>
 
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 
 struct menu rootmenu;
 struct menu *current_menu, *current_entry;
 static struct menu **last_entry_ptr;
 
 struct file *file_list;
 struct file *current_file;
 
 void menu_init(void)
 {
 	current_entry = current_menu = &rootmenu;
 	last_entry_ptr = &rootmenu.list;
 }
 
 void menu_add_entry(struct symbol *sym)
 {
 	struct menu *menu;
 
 	menu = malloc(sizeof(*menu));
 	memset(menu, 0, sizeof(*menu));
 	menu->sym = sym;
 	menu->parent = current_menu;
 	menu->file = current_file;
 	menu->lineno = zconf_lineno();
 
 	*last_entry_ptr = menu;
 	last_entry_ptr = &menu->next;
 	current_entry = menu;
 }
 
 void menu_end_entry(void)
 {
 }
 
 void menu_add_menu(void)
 {
 	current_menu = current_entry;
 	last_entry_ptr = &current_entry->list;
 }
 
 void menu_end_menu(void)
 {
 	last_entry_ptr = &current_menu->next;
 	current_menu = current_menu->parent;
 }
 
+struct expr *menu_check_dep(struct expr *e)
+{
+	if (!e)
+		return e;
+
+	switch (e->type) {
+	case E_NOT:
+		e->left.expr = menu_check_dep(e->left.expr);
+		break;
+	case E_OR:
+	case E_AND:
+		e->left.expr = menu_check_dep(e->left.expr);
+		e->right.expr = menu_check_dep(e->right.expr);
+		break;
+	case E_SYMBOL:
+		/* change 'm' into 'm' && MODULES */
+		if (e->left.sym == &symbol_mod)
+			return expr_alloc_and(e, expr_alloc_symbol(modules_sym));
+		break;
+	default:
+		break;
+	}
+	return e;
+}
+
 void menu_add_dep(struct expr *dep)
 {
-	current_entry->dep = expr_alloc_and(current_entry->dep, dep);
+	current_entry->dep = expr_alloc_and(current_entry->dep, menu_check_dep(dep));
 }
 
 void menu_set_type(int type)
 {
 	struct symbol *sym = current_entry->sym;
 
 	if (sym->type == type)
 		return;
 	if (sym->type == S_UNKNOWN) {
 		sym->type = type;
 		return;
 	}
-	fprintf(stderr, "%s:%d: type of '%s' redefined from '%s' to '%s'\n",
+	fprintf(stderr, "%s:%d:warning: type of '%s' redefined from '%s' to '%s'\n",
 		current_entry->file->name, current_entry->lineno,
 		sym->name ? sym->name : "<choice>", sym_type_name(sym->type), sym_type_name(type));
 }
 
-struct property *create_prop(enum prop_type type)
-{
-	struct property *prop;
-
-	prop = malloc(sizeof(*prop));
-	memset(prop, 0, sizeof(*prop));
-	prop->type = type;
-	prop->file = current_file;
-	prop->lineno = zconf_lineno();
-
-	return prop;
-}
-
-struct property *menu_add_prop(int token, char *prompt, struct symbol *def, struct expr *dep)
+struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep)
 {
-	struct property *prop = create_prop(token);
-	struct property **propp;
+	struct property *prop = prop_alloc(type, current_entry->sym);
 
-	prop->sym = current_entry->sym;
 	prop->menu = current_entry;
 	prop->text = prompt;
-	prop->def = def;
-	E_EXPR(prop->visible) = dep;
+	prop->expr = expr;
+	prop->visible.expr = menu_check_dep(dep);
 
-	if (prompt)
+	if (prompt) {
+		if (current_entry->prompt)
+			fprintf(stderr, "%s:%d: prompt redefined\n",
+				current_entry->file->name, current_entry->lineno);
 		current_entry->prompt = prop;
-
-	/* append property to the prop list of symbol */
-	if (prop->sym) {
-		for (propp = &prop->sym->prop; *propp; propp = &(*propp)->next)
-			;
-		*propp = prop;
 	}
 
 	return prop;
 }
 
-void menu_add_prompt(int token, char *prompt, struct expr *dep)
+void menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep)
 {
-	current_entry->prompt = menu_add_prop(token, prompt, NULL, dep);
+	menu_add_prop(type, prompt, NULL, dep);
 }
 
-void menu_add_default(int token, struct symbol *def, struct expr *dep)
+void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep)
 {
-	current_entry->prompt = menu_add_prop(token, NULL, def, dep);
+	menu_add_prop(type, NULL, expr, dep);
+}
+
+void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep)
+{
+	menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep);
 }
 
 void menu_finalize(struct menu *parent)
 {
 	struct menu *menu, *last_menu;
 	struct symbol *sym;
 	struct property *prop;
-	struct expr *parentdep, *basedep, *dep, *dep2;
+	struct expr *parentdep, *basedep, *dep, *dep2, **ep;
 
 	sym = parent->sym;
 	if (parent->list) {
 		if (sym && sym_is_choice(sym)) {
 			/* find the first choice value and find out choice type */
 			for (menu = parent->list; menu; menu = menu->next) {
 				if (menu->sym) {
 					current_entry = parent;
 					menu_set_type(menu->sym->type);
 					current_entry = menu;
 					menu_set_type(sym->type);
 					break;
 				}
 			}
 			parentdep = expr_alloc_symbol(sym);
 		} else if (parent->prompt)
-			parentdep = E_EXPR(parent->prompt->visible);
+			parentdep = parent->prompt->visible.expr;
 		else
 			parentdep = parent->dep;
 
 		for (menu = parent->list; menu; menu = menu->next) {
 			basedep = expr_transform(menu->dep);
 			basedep = expr_alloc_and(expr_copy(parentdep), basedep);
 			basedep = expr_eliminate_dups(basedep);
 			menu->dep = basedep;
 			if (menu->sym)
 				prop = menu->sym->prop;
 			else
 				prop = menu->prompt;
 			for (; prop; prop = prop->next) {
 				if (prop->menu != menu)
 					continue;
-				dep = expr_transform(E_EXPR(prop->visible));
+				dep = expr_transform(prop->visible.expr);
 				dep = expr_alloc_and(expr_copy(basedep), dep);
 				dep = expr_eliminate_dups(dep);
 				if (menu->sym && menu->sym->type != S_TRISTATE)
 					dep = expr_trans_bool(dep);
-				E_EXPR(prop->visible) = dep;
+				prop->visible.expr = dep;
+				if (prop->type == P_SELECT) {
+					struct symbol *es = prop_get_symbol(prop);
+					es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr,
+							expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep)));
+				}
 			}
 		}
 		for (menu = parent->list; menu; menu = menu->next)
 			menu_finalize(menu);
-	} else if (sym && parent->prompt) {
-		basedep = E_EXPR(parent->prompt->visible);
+	} else if (sym) {
+		basedep = parent->prompt ? parent->prompt->visible.expr : NULL;
 		basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no);
 		basedep = expr_eliminate_dups(expr_transform(basedep));
 		last_menu = NULL;
 		for (menu = parent->next; menu; menu = menu->next) {
-			dep = menu->prompt ? E_EXPR(menu->prompt->visible) : menu->dep;
+			dep = menu->prompt ? menu->prompt->visible.expr : menu->dep;
 			if (!expr_contains_symbol(dep, sym))
 				break;
 			if (expr_depends_symbol(dep, sym))
 				goto next;
 			dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no);
 			dep = expr_eliminate_dups(expr_transform(dep));
 			dep2 = expr_copy(basedep);
 			expr_eliminate_eq(&dep, &dep2);
 			expr_free(dep);
 			if (!expr_is_yes(dep2)) {
 				expr_free(dep2);
 				break;
 			}
 			expr_free(dep2);
 		next:
 			menu_finalize(menu);
 			menu->parent = parent;
 			last_menu = menu;
 		}
 		if (last_menu) {
 			parent->list = parent->next;
 			parent->next = last_menu->next;
 			last_menu->next = NULL;
 		}
 	}
 	for (menu = parent->list; menu; menu = menu->next) {
 		if (sym && sym_is_choice(sym) && menu->sym) {
 			menu->sym->flags |= SYMBOL_CHOICEVAL;
+			if (!menu->prompt)
+				fprintf(stderr, "%s:%d:warning: choice value must have a prompt\n",
+					menu->file->name, menu->lineno);
+			for (prop = menu->sym->prop; prop; prop = prop->next) {
+				if (prop->type == P_PROMPT && prop->menu != menu) {
+					fprintf(stderr, "%s:%d:warning: choice values currently only support a single prompt\n",
+						prop->file->name, prop->lineno);
+					
+				}
+				if (prop->type == P_DEFAULT)
+					fprintf(stderr, "%s:%d:warning: defaults for choice values not supported\n",
+						prop->file->name, prop->lineno);
+			}
 			current_entry = menu;
 			menu_set_type(sym->type);
-			menu_add_prop(P_CHOICE, NULL, parent->sym, NULL);
-			prop = sym_get_choice_prop(parent->sym);
-			//dep = expr_alloc_one(E_CHOICE, dep);
-			//dep->right.sym = menu->sym;
-			prop->dep = expr_alloc_one(E_CHOICE, prop->dep);
-			prop->dep->right.sym = menu->sym;
+			menu_add_symbol(P_CHOICE, sym, NULL);
+			prop = sym_get_choice_prop(sym);
+			for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr)
+				;
+			*ep = expr_alloc_one(E_CHOICE, NULL);
+			(*ep)->right.sym = menu->sym;
 		}
 		if (menu->list && (!menu->prompt || !menu->prompt->text)) {
 			for (last_menu = menu->list; ; last_menu = last_menu->next) {
 				last_menu->parent = parent;
 				if (!last_menu->next)
 					break;
 			}
 			last_menu->next = menu->next;
 			menu->next = menu->list;
 			menu->list = NULL;
 		}
 	}
+
+	if (sym && !(sym->flags & SYMBOL_WARNED)) {
+		struct symbol *sym2;
+		if (sym->type == S_UNKNOWN)
+			fprintf(stderr, "%s:%d:warning: config symbol defined without type\n",
+				parent->file->name, parent->lineno);
+
+		if (sym_is_choice(sym) && !parent->prompt)
+			fprintf(stderr, "%s:%d:warning: choice must have a prompt\n",
+				parent->file->name, parent->lineno);
+
+		for (prop = sym->prop; prop; prop = prop->next) {
+			switch (prop->type) {
+			case P_DEFAULT:
+				if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) &&
+				    prop->expr->type != E_SYMBOL)
+					fprintf(stderr, "%s:%d:warning: default must be a single symbol\n",
+						prop->file->name, prop->lineno);
+				break;
+			case P_SELECT:
+				sym2 = prop_get_symbol(prop);
+				if ((sym->type != S_BOOLEAN && sym->type != S_TRISTATE) ||
+				    (sym2->type != S_BOOLEAN && sym2->type != S_TRISTATE))
+					fprintf(stderr, "%s:%d:warning: enable is only allowed with boolean and tristate symbols\n",
+						prop->file->name, prop->lineno);
+				break;
+			case P_RANGE:
+				if (sym->type != S_INT && sym->type != S_HEX)
+					fprintf(stderr, "%s:%d:warning: range is only allowed for int or hex symbols\n",
+						prop->file->name, prop->lineno);
+				if (!sym_string_valid(sym, prop->expr->left.sym->name) ||
+				    !sym_string_valid(sym, prop->expr->right.sym->name))
+					fprintf(stderr, "%s:%d:warning: range is invalid\n",
+						prop->file->name, prop->lineno);
+				break;
+			default:
+				;
+			}
+		}
+		sym->flags |= SYMBOL_WARNED;
+	}
+
+	if (sym && !sym_is_optional(sym) && parent->prompt) {
+		sym->rev_dep.expr = expr_alloc_or(sym->rev_dep.expr,
+				expr_alloc_and(parent->prompt->visible.expr,
+					expr_alloc_symbol(&symbol_mod)));
+	}
 }
 
 bool menu_is_visible(struct menu *menu)
 {
+	struct menu *child;
+	struct symbol *sym;
 	tristate visible;
 
 	if (!menu->prompt)
 		return false;
-	if (menu->sym) {
-		sym_calc_value(menu->sym);
-		visible = E_TRI(menu->prompt->visible);
+	sym = menu->sym;
+	if (sym) {
+		sym_calc_value(sym);
+		visible = menu->prompt->visible.tri;
 	} else
-		visible = E_CALC(menu->prompt->visible);
-	return visible != no;
+		visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr);
+
+	if (visible != no)
+		return true;
+	if (!sym || sym_get_tristate_value(menu->sym) == no)
+		return false;
+
+	for (child = menu->list; child; child = child->next)
+		if (menu_is_visible(child))
+			return true;
+	return false;
 }
 
 const char *menu_get_prompt(struct menu *menu)
 {
 	if (menu->prompt)
 		return menu->prompt->text;
 	else if (menu->sym)
 		return menu->sym->name;
 	return NULL;
 }
 
 struct menu *menu_get_root_menu(struct menu *menu)
 {
 	return &rootmenu;
 }
 
 struct menu *menu_get_parent_menu(struct menu *menu)
 {
 	enum prop_type type;
 
-	while (menu != &rootmenu) {
-		menu = menu->parent;
+	for (; menu != &rootmenu; menu = menu->parent) {
 		type = menu->prompt ? menu->prompt->type : 0;
-		if (type == P_MENU || type == P_ROOTMENU)
+		if (type == P_MENU)
 			break;
 	}
 	return menu;
 }
 
 struct file *file_lookup(const char *name)
 {
 	struct file *file;
 
 	for (file = file_list; file; file = file->next) {
 		if (!strcmp(name, file->name))
 			return file;
 	}
 
 	file = malloc(sizeof(*file));
 	memset(file, 0, sizeof(*file));
 	file->name = strdup(name);
 	file->next = file_list;
 	file_list = file;
 	return file;
 }
 
 int file_write_dep(const char *name)
 {
 	struct file *file;
 	FILE *out;
 
 	if (!name)
 		name = ".config.cmd";
 	out = fopen("..config.tmp", "w");
 	if (!out)
 		return 1;
 	fprintf(out, "deps_config := \\\n");
 	for (file = file_list; file; file = file->next) {
 		if (file->next)
 			fprintf(out, "\t%s \\\n", file->name);
 		else
 			fprintf(out, "\t%s\n", file->name);
 	}
 	fprintf(out, "\n.config include/linux/autoconf.h: $(deps_config)\n\n$(deps_config):\n");
 	fclose(out);
 	rename("..config.tmp", name);
 	return 0;
 }
 
diff --git a/scripts/kconfig/qconf.cc b/scripts/kconfig/qconf.cc
index bed541d..52419ad 100644
--- a/scripts/kconfig/qconf.cc
+++ b/scripts/kconfig/qconf.cc
@@ -1,1203 +1,1304 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <qapplication.h>
 #include <qmainwindow.h>
 #include <qtoolbar.h>
 #include <qvbox.h>
 #include <qsplitter.h>
 #include <qlistview.h>
 #include <qtextview.h>
 #include <qlineedit.h>
 #include <qmenubar.h>
 #include <qmessagebox.h>
 #include <qaction.h>
 #include <qheader.h>
 #include <qfiledialog.h>
 #include <qregexp.h>
 #if QT_VERSION >= 300
 #include <qsettings.h>
 #endif
 
 #include <stdlib.h>
 
 #include "lkc.h"
 #include "qconf.h"
 
 #include "qconf.moc"
 #include "images.c"
 
 static QApplication *configApp;
 #if QT_VERSION >= 300
 static QSettings *configSettings;
 #endif
 
 /*
  * update all the children of a menu entry
  *   removes/adds the entries from the parent widget as necessary
  *
  * parent: either the menu list widget or a menu entry widget
  * menu: entry to be updated
  */
 template <class P>
-static void updateMenuList(P* parent, struct menu* menu)
+void ConfigList::updateMenuList(P* parent, struct menu* menu)
 {
 	struct menu* child;
-	ConfigList* list = parent->listView();
 	ConfigItem* item;
 	ConfigItem* last;
 	bool visible;
-	bool showAll = list->showAll;
-	enum listMode mode = list->mode;
 	enum prop_type type;
 
 	if (!menu) {
 		while ((item = parent->firstChild()))
 			delete item;
 		return;
 	}
 
-	last = 0;
+	last = parent->firstChild();
+	if (last && !last->goParent)
+		last = 0;
 	for (child = menu->list; child; child = child->next) {
 		item = last ? last->nextSibling() : parent->firstChild();
 		type = child->prompt ? child->prompt->type : P_UNKNOWN;
 
 		switch (mode) {
 		case menuMode:
-			if (type != P_ROOTMENU)
+			if (!(child->flags & MENU_ROOT))
 				goto hide;
 			break;
 		case symbolMode:
-			if (type == P_ROOTMENU)
+			if (child->flags & MENU_ROOT)
 				goto hide;
 			break;
 		default:
 			break;
 		}
 
 		visible = menu_is_visible(child);
 		if (showAll || visible) {
 			if (!item || item->menu != child)
 				item = new ConfigItem(parent, last, child, visible);
-			else {
-				item->visible = visible;
-				if (item->updateNeeded()) {
-					ConfigItem* i = (ConfigItem*)child->data;
-					for (; i; i = i->nextItem) {
-						i->updateMenu();
-					}
-				} else if (list->updateAll)
-					item->updateMenu();
-			}
+			else
+				item->testUpdateMenu(visible);
 
-			if (mode == fullMode || mode == menuMode ||
-			    (type != P_MENU && type != P_ROOTMENU))
+			if (mode == fullMode || mode == menuMode || type != P_MENU)
 				updateMenuList(item, child);
 			else
 				updateMenuList(item, 0);
 			last = item;
 			continue;
 		}
-	hide:	
+	hide:
 		if (item && item->menu == child) {
 			last = parent->firstChild();
 			if (last == item)
 				last = 0;
 			else while (last->nextSibling() != item)
 				last = last->nextSibling();
 			delete item;
 		}
 	}
 }
 
 #if QT_VERSION >= 300
 /*
  * set the new data
  * TODO check the value
  */
 void ConfigItem::okRename(int col)
 {
 	Parent::okRename(col);
 	sym_set_string_value(menu->sym, text(dataColIdx).latin1());
 }
 #endif
 
 /*
  * update the displayed of a menu entry
  */
 void ConfigItem::updateMenu(void)
 {
 	ConfigList* list;
 	struct symbol* sym;
+	struct property *prop;
 	QString prompt;
 	int type;
-	enum prop_type ptype;
 	tristate expr;
 
 	list = listView();
+	if (goParent) {
+		setPixmap(promptColIdx, list->menuBackPix);
+		prompt = "..";
+		goto set_prompt;
+	}
 
 	sym = menu->sym;
-	if (!sym) {
-		setText(promptColIdx, menu_get_prompt(menu));
-		ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-		if ((ptype == P_ROOTMENU || ptype == P_MENU) &&
-		    (list->mode == singleMode || list->mode == symbolMode))
+	prop = menu->prompt;
+	prompt = menu_get_prompt(menu);
+
+	if (prop) switch (prop->type) {
+	case P_MENU:
+		if (list->mode == singleMode || list->mode == symbolMode) {
+			/* a menuconfig entry is displayed differently
+			 * depending whether it's at the view root or a child.
+			 */
+			if (sym && list->rootEntry == menu)
+				break;
 			setPixmap(promptColIdx, list->menuPix);
-		else
+		} else {
+			if (sym)
+				break;
 			setPixmap(promptColIdx, 0);
-		return;
+		}
+		goto set_prompt;
+	case P_COMMENT:
+		setPixmap(promptColIdx, 0);
+		goto set_prompt;
+	default:
+		;
 	}
+	if (!sym)
+		goto set_prompt;
 
 	setText(nameColIdx, sym->name);
 
 	type = sym_get_type(sym);
 	switch (type) {
 	case S_BOOLEAN:
 	case S_TRISTATE:
 		char ch;
 
-		prompt = menu_get_prompt(menu);
 		if (!sym_is_changable(sym) && !list->showAll) {
+			setPixmap(promptColIdx, 0);
 			setText(noColIdx, 0);
 			setText(modColIdx, 0);
 			setText(yesColIdx, 0);
 			break;
 		}
 		expr = sym_get_tristate_value(sym);
 		switch (expr) {
 		case yes:
 			if (sym_is_choice_value(sym) && type == S_BOOLEAN)
 				setPixmap(promptColIdx, list->choiceYesPix);
 			else
 				setPixmap(promptColIdx, list->symbolYesPix);
 			setText(yesColIdx, "Y");
 			ch = 'Y';
 			break;
 		case mod:
 			setPixmap(promptColIdx, list->symbolModPix);
 			setText(modColIdx, "M");
 			ch = 'M';
 			break;
 		default:
 			if (sym_is_choice_value(sym) && type == S_BOOLEAN)
 				setPixmap(promptColIdx, list->choiceNoPix);
 			else
 				setPixmap(promptColIdx, list->symbolNoPix);
 			setText(noColIdx, "N");
 			ch = 'N';
 			break;
 		}
 		if (expr != no)
 			setText(noColIdx, sym_tristate_within_range(sym, no) ? "_" : 0);
 		if (expr != mod)
 			setText(modColIdx, sym_tristate_within_range(sym, mod) ? "_" : 0);
 		if (expr != yes)
 			setText(yesColIdx, sym_tristate_within_range(sym, yes) ? "_" : 0);
 
 		setText(dataColIdx, QChar(ch));
 		break;
 	case S_INT:
 	case S_HEX:
 	case S_STRING:
 		const char* data;
 
 		data = sym_get_string_value(sym);
 #if QT_VERSION >= 300
 		int i = list->mapIdx(dataColIdx);
 		if (i >= 0)
 			setRenameEnabled(i, TRUE);
 #endif
 		setText(dataColIdx, data);
 		if (type == S_STRING)
-			prompt.sprintf("%s: %s", menu_get_prompt(menu), data);
+			prompt.sprintf("%s: %s", prompt.latin1(), data);
 		else
-			prompt.sprintf("(%s) %s", data, menu_get_prompt(menu));
+			prompt.sprintf("(%s) %s", data, prompt.latin1());
 		break;
 	}
 	if (!sym_has_value(sym) && visible)
 		prompt += " (NEW)";
+set_prompt:
 	setText(promptColIdx, prompt);
 }
 
-bool ConfigItem::updateNeeded(void)
+void ConfigItem::testUpdateMenu(bool v)
 {
-	struct symbol* sym = menu->sym;
-	if (sym)
-		sym_calc_value(sym);
+	ConfigItem* i;
+
+	visible = v;
+	if (!menu)
+		return;
+
+	sym_calc_value(menu->sym);
 	if (menu->flags & MENU_CHANGED) {
+		/* the menu entry changed, so update all list items */
 		menu->flags &= ~MENU_CHANGED;
-		return true;
-	}
-	return false;
+		for (i = (ConfigItem*)menu->data; i; i = i->nextItem)
+			i->updateMenu();
+	} else if (listView()->updateAll)
+		updateMenu();
 }
 
 void ConfigItem::paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align)
 {
 	ConfigList* list = listView();
 
 	if (visible) {
 		if (isSelected() && !list->hasFocus() && list->mode == menuMode)
 			Parent::paintCell(p, list->inactivedColorGroup, column, width, align);
 		else
 			Parent::paintCell(p, cg, column, width, align);
 	} else
 		Parent::paintCell(p, list->disabledColorGroup, column, width, align);
 }
 
 /*
  * construct a menu entry
  */
 void ConfigItem::init(void)
 {
-	ConfigList* list = listView();
-	nextItem = (ConfigItem*)menu->data;
-	menu->data = this;
+	if (menu) {
+		ConfigList* list = listView();
+		nextItem = (ConfigItem*)menu->data;
+		menu->data = this;
 
-	if (list->mode != fullMode)
-		setOpen(TRUE);
-	if (menu->sym)
+		if (list->mode != fullMode)
+			setOpen(TRUE);
 		sym_calc_value(menu->sym);
+	}
 	updateMenu();
 }
 
 /*
  * destruct a menu entry
  */
 ConfigItem::~ConfigItem(void)
 {
-	ConfigItem** ip = &(ConfigItem*)menu->data;
-	for (; *ip; ip = &(*ip)->nextItem) {
-		if (*ip == this) {
-			*ip = nextItem;
-			break;
+	if (menu) {
+		ConfigItem** ip = (ConfigItem**)&menu->data;
+		for (; *ip; ip = &(*ip)->nextItem) {
+			if (*ip == this) {
+				*ip = nextItem;
+				break;
+			}
 		}
 	}
 }
 
 void ConfigLineEdit::show(ConfigItem* i)
 {
 	item = i;
 	if (sym_get_string_value(item->menu->sym))
 		setText(sym_get_string_value(item->menu->sym));
 	else
 		setText(0);
 	Parent::show();
 	setFocus();
 }
 
 void ConfigLineEdit::keyPressEvent(QKeyEvent* e)
 {
 	switch (e->key()) {
 	case Key_Escape:
 		break;
 	case Key_Return:
 	case Key_Enter:
 		sym_set_string_value(item->menu->sym, text().latin1());
 		parent()->updateList(item);
 		break;
 	default:
 		Parent::keyPressEvent(e);
 		return;
 	}
 	e->accept();
 	parent()->list->setFocus();
 	hide();
 }
 
 ConfigList::ConfigList(ConfigView* p, ConfigMainWindow* cv)
 	: Parent(p), cview(cv),
 	  updateAll(false),
 	  symbolYesPix(xpm_symbol_yes), symbolModPix(xpm_symbol_mod), symbolNoPix(xpm_symbol_no),
-	  choiceYesPix(xpm_choice_yes), choiceNoPix(xpm_choice_no), menuPix(xpm_menu), menuInvPix(xpm_menu_inv),
+	  choiceYesPix(xpm_choice_yes), choiceNoPix(xpm_choice_no),
+	  menuPix(xpm_menu), menuInvPix(xpm_menu_inv), menuBackPix(xpm_menuback), voidPix(xpm_void),
 	  showAll(false), showName(false), showRange(false), showData(false),
 	  rootEntry(0)
 {
 	int i;
 
 	setSorting(-1);
 	setRootIsDecorated(TRUE);
 	disabledColorGroup = palette().active();
 	disabledColorGroup.setColor(QColorGroup::Text, palette().disabled().text());
 	inactivedColorGroup = palette().active();
 	inactivedColorGroup.setColor(QColorGroup::Highlight, palette().disabled().highlight());
 
 	connect(this, SIGNAL(selectionChanged(void)),
 		SLOT(updateSelection(void)));
 
 	for (i = 0; i < colNr; i++)
 		colMap[i] = colRevMap[i] = -1;
 	addColumn(promptColIdx, "Option");
 
 	reinit();
 }
 
 void ConfigList::reinit(void)
 {
 	removeColumn(dataColIdx);
 	removeColumn(yesColIdx);
 	removeColumn(modColIdx);
 	removeColumn(noColIdx);
 	removeColumn(nameColIdx);
 
 	if (showName)
 		addColumn(nameColIdx, "Name");
 	if (showRange) {
 		addColumn(noColIdx, "N");
 		addColumn(modColIdx, "M");
 		addColumn(yesColIdx, "Y");
 	}
 	if (showData)
 		addColumn(dataColIdx, "Value");
 
 	updateListAll();
 }
 
 void ConfigList::updateSelection(void)
 {
 	struct menu *menu;
 	enum prop_type type;
 
 	ConfigItem* item = (ConfigItem*)selectedItem();
 	if (!item)
 		return;
 
 	cview->setHelp(item);
 
 	menu = item->menu;
+	if (!menu)
+		return;
 	type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-	if (mode == menuMode && (type == P_MENU || type == P_ROOTMENU))
+	if (mode == menuMode && type == P_MENU)
 		emit menuSelected(menu);
 }
 
 void ConfigList::updateList(ConfigItem* item)
 {
-	(void)item;	// unused so far
+	ConfigItem* last = 0;
+
+	if (!rootEntry)
+		goto update;
+
+	if (rootEntry != &rootmenu && (mode == singleMode ||
+	    (mode == symbolMode && rootEntry->parent != &rootmenu))) {
+		item = firstChild();
+		if (!item)
+			item = new ConfigItem(this, 0, true);
+		last = item;
+	}
+	if (mode == singleMode && rootEntry->sym && rootEntry->prompt) {
+		item = last ? last->nextSibling() : firstChild();
+		if (!item)
+			item = new ConfigItem(this, last, rootEntry, true);
+
+		updateMenuList(item, rootEntry);
+		triggerUpdate();
+		return;
+	}
+update:
 	updateMenuList(this, rootEntry);
 	triggerUpdate();
 }
 
 void ConfigList::setAllOpen(bool open)
 {
 	QListViewItemIterator it(this);
 
 	for (; it.current(); it++)
 		it.current()->setOpen(open);
 }
 
 void ConfigList::setValue(ConfigItem* item, tristate val)
 {
 	struct symbol* sym;
 	int type;
 	tristate oldval;
 
-	sym = item->menu->sym;
+	sym = item->menu ? item->menu->sym : 0;
 	if (!sym)
 		return;
 
 	type = sym_get_type(sym);
 	switch (type) {
 	case S_BOOLEAN:
 	case S_TRISTATE:
 		oldval = sym_get_tristate_value(sym);
 
 		if (!sym_set_tristate_value(sym, val))
 			return;
 		if (oldval == no && item->menu->list)
 			item->setOpen(TRUE);
 		parent()->updateList(item);
 		break;
 	}
 }
 
 void ConfigList::changeValue(ConfigItem* item)
 {
 	struct symbol* sym;
 	struct menu* menu;
 	int type, oldexpr, newexpr;
 
 	menu = item->menu;
+	if (!menu)
+		return;
 	sym = menu->sym;
 	if (!sym) {
 		if (item->menu->list)
 			item->setOpen(!item->isOpen());
 		return;
 	}
 
 	type = sym_get_type(sym);
 	switch (type) {
 	case S_BOOLEAN:
 	case S_TRISTATE:
 		oldexpr = sym_get_tristate_value(sym);
 		newexpr = sym_toggle_tristate_value(sym);
 		if (item->menu->list) {
 			if (oldexpr == newexpr)
 				item->setOpen(!item->isOpen());
 			else if (oldexpr == no)
 				item->setOpen(TRUE);
 		}
 		if (oldexpr != newexpr)
 			parent()->updateList(item);
 		break;
 	case S_INT:
 	case S_HEX:
 	case S_STRING:
 #if QT_VERSION >= 300
 		if (colMap[dataColIdx] >= 0)
 			item->startRename(colMap[dataColIdx]);
 		else
 #endif
 			parent()->lineEdit->show(item);
 		break;
 	}
 }
 
 void ConfigList::setRootMenu(struct menu *menu)
 {
 	enum prop_type type;
 
 	if (rootEntry == menu)
 		return;
 	type = menu && menu->prompt ? menu->prompt->type : P_UNKNOWN;
-	if (type != P_MENU && type != P_ROOTMENU)
+	if (type != P_MENU)
 		return;
 	updateMenuList(this, 0);
 	rootEntry = menu;
 	updateListAll();
 	setSelected(currentItem(), hasFocus());
 }
 
 void ConfigList::setParentMenu(void)
 {
 	ConfigItem* item;
-	struct menu *oldroot, *newroot;
+	struct menu *oldroot;
 
 	oldroot = rootEntry;
-	newroot = menu_get_parent_menu(oldroot);
-	if (newroot == oldroot)
+	if (rootEntry == &rootmenu)
 		return;
-	setRootMenu(newroot);
+	setRootMenu(menu_get_parent_menu(rootEntry->parent));
 
 	QListViewItemIterator it(this);
 	for (; (item = (ConfigItem*)it.current()); it++) {
 		if (item->menu == oldroot) {
 			setCurrentItem(item);
 			ensureItemVisible(item);
 			break;
 		}
 	}
 }
 
 void ConfigList::keyPressEvent(QKeyEvent* ev)
 {
 	QListViewItem* i = currentItem();
 	ConfigItem* item;
 	struct menu *menu;
 	enum prop_type type;
 
 	if (ev->key() == Key_Escape && mode != fullMode) {
 		emit parentSelected();
 		ev->accept();
 		return;
 	}
 
 	if (!i) {
 		Parent::keyPressEvent(ev);
 		return;
 	}
 	item = (ConfigItem*)i;
 
 	switch (ev->key()) {
 	case Key_Return:
 	case Key_Enter:
+		if (item->goParent) {
+			emit parentSelected();
+			break;
+		}
 		menu = item->menu;
+		if (!menu)
+			break;
 		type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-		if ((type == P_MENU || type == P_ROOTMENU) && mode != fullMode) {
+		if (type == P_MENU && rootEntry != menu &&
+		    mode != fullMode && mode != menuMode) {
 			emit menuSelected(menu);
 			break;
 		}
 	case Key_Space:
 		changeValue(item);
 		break;
 	case Key_N:
 		setValue(item, no);
 		break;
 	case Key_M:
 		setValue(item, mod);
 		break;
 	case Key_Y:
 		setValue(item, yes);
 		break;
 	default:
 		Parent::keyPressEvent(ev);
 		return;
 	}
 	ev->accept();
 }
 
 void ConfigList::contentsMousePressEvent(QMouseEvent* e)
 {
 	//QPoint p(contentsToViewport(e->pos()));
 	//printf("contentsMousePressEvent: %d,%d\n", p.x(), p.y());
 	Parent::contentsMousePressEvent(e);
 }
 
 void ConfigList::contentsMouseReleaseEvent(QMouseEvent* e)
 {
 	QPoint p(contentsToViewport(e->pos()));
 	ConfigItem* item = (ConfigItem*)itemAt(p);
 	struct menu *menu;
+	enum prop_type ptype;
 	const QPixmap* pm;
 	int idx, x;
 
 	if (!item)
 		goto skip;
 
 	menu = item->menu;
 	x = header()->offset() + p.x();
 	idx = colRevMap[header()->sectionAt(x)];
 	switch (idx) {
 	case promptColIdx:
 		pm = item->pixmap(promptColIdx);
 		if (pm) {
 			int off = header()->sectionPos(0) + itemMargin() +
 				treeStepSize() * (item->depth() + (rootIsDecorated() ? 1 : 0));
 			if (x >= off && x < off + pm->width()) {
-				if (menu->sym)
-					changeValue(item);
-				else
+				if (item->goParent) {
+					emit parentSelected();
+					break;
+				} else if (!menu)
+					break;
+				ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
+				if (ptype == P_MENU && rootEntry != menu &&
+				    mode != fullMode && mode != menuMode)
 					emit menuSelected(menu);
+				else
+					changeValue(item);
 			}
 		}
 		break;
 	case noColIdx:
 		setValue(item, no);
 		break;
 	case modColIdx:
 		setValue(item, mod);
 		break;
 	case yesColIdx:
 		setValue(item, yes);
 		break;
 	case dataColIdx:
 		changeValue(item);
 		break;
 	}
 
 skip:
 	//printf("contentsMouseReleaseEvent: %d,%d\n", p.x(), p.y());
 	Parent::contentsMouseReleaseEvent(e);
 }
 
 void ConfigList::contentsMouseMoveEvent(QMouseEvent* e)
 {
 	//QPoint p(contentsToViewport(e->pos()));
 	//printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
 	Parent::contentsMouseMoveEvent(e);
 }
 
 void ConfigList::contentsMouseDoubleClickEvent(QMouseEvent* e)
 {
 	QPoint p(contentsToViewport(e->pos()));
 	ConfigItem* item = (ConfigItem*)itemAt(p);
 	struct menu *menu;
 	enum prop_type ptype;
 
 	if (!item)
 		goto skip;
+	if (item->goParent) {
+		emit parentSelected();
+		goto skip;
+	}
 	menu = item->menu;
+	if (!menu)
+		goto skip;
 	ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
-	if ((ptype == P_ROOTMENU || ptype == P_MENU) &&
-	    (mode == singleMode || mode == symbolMode))
+	if (ptype == P_MENU && (mode == singleMode || mode == symbolMode))
 		emit menuSelected(menu);
 	else if (menu->sym)
 		changeValue(item);
 
 skip:
 	//printf("contentsMouseDoubleClickEvent: %d,%d\n", p.x(), p.y());
 	Parent::contentsMouseDoubleClickEvent(e);
 }
 
 void ConfigList::focusInEvent(QFocusEvent *e)
 {
 	Parent::focusInEvent(e);
 
 	QListViewItem* item = currentItem();
 	if (!item)
 		return;
 
 	setSelected(item, TRUE);
 	emit gotFocus();
 }
 
 ConfigView* ConfigView::viewList;
 
 ConfigView::ConfigView(QWidget* parent, ConfigMainWindow* cview)
 	: Parent(parent)
 {
 	list = new ConfigList(this, cview);
 	lineEdit = new ConfigLineEdit(this);
 	lineEdit->hide();
 
 	this->nextView = viewList;
 	viewList = this;
 }
 
 ConfigView::~ConfigView(void)
 {
 	ConfigView** vp;
 
 	for (vp = &viewList; *vp; vp = &(*vp)->nextView) {
 		if (*vp == this) {
 			*vp = nextView;
 			break;
 		}
 	}
 }
 
 void ConfigView::updateList(ConfigItem* item)
 {
 	ConfigView* v;
 
 	for (v = viewList; v; v = v->nextView)
 		v->list->updateList(item);
 }
 
 void ConfigView::updateListAll(void)
 {
 	ConfigView* v;
 
 	for (v = viewList; v; v = v->nextView)
 		v->list->updateListAll();
 }
 
 /*
  * Construct the complete config widget
  */
 ConfigMainWindow::ConfigMainWindow(void)
 {
-	ConfigView* view;
 	QMenuBar* menu;
 	QSplitter* split1;
 	QSplitter* split2;
 	bool ok;
 	int x, y, width, height;
 
 	QWidget *d = configApp->desktop();
 
 #if QT_VERSION >= 300
 	width = configSettings->readNumEntry("/kconfig/qconf/window width", d->width() - 64);
 	height = configSettings->readNumEntry("/kconfig/qconf/window height", d->height() - 64);
 	resize(width, height);
 	x = configSettings->readNumEntry("/kconfig/qconf/window x", 0, &ok);
 	if (ok)
 		y = configSettings->readNumEntry("/kconfig/qconf/window y", 0, &ok);
 	if (ok)
 		move(x, y);
 #else
 	width = d->width() - 64;
 	height = d->height() - 64;
 	resize(width, height);
 #endif
 
 	showDebug = false;
 
 	split1 = new QSplitter(this);
 	split1->setOrientation(QSplitter::Horizontal);
 	setCentralWidget(split1);
 
-	view = new ConfigView(split1, this);
-	menuList = view->list;
+	menuView = new ConfigView(split1, this);
+	menuList = menuView->list;
 
 	split2 = new QSplitter(split1);
 	split2->setOrientation(QSplitter::Vertical);
 
 	// create config tree
-	view = new ConfigView(split2, this);
-	configList = view->list;
+	configView = new ConfigView(split2, this);
+	configList = configView->list;
 
 	helpText = new QTextView(split2);
 	helpText->setTextFormat(Qt::RichText);
 
 	setTabOrder(configList, helpText);
 	configList->setFocus();
 
 	menu = menuBar();
 	toolBar = new QToolBar("Tools", this);
 
 	backAction = new QAction("Back", QPixmap(xpm_back), "Back", 0, this);
 	  connect(backAction, SIGNAL(activated()), SLOT(goBack()));
 	  backAction->setEnabled(FALSE);
 	QAction *quitAction = new QAction("Quit", "&Quit", CTRL+Key_Q, this);
 	  connect(quitAction, SIGNAL(activated()), SLOT(close()));
 	QAction *loadAction = new QAction("Load", QPixmap(xpm_load), "&Load", CTRL+Key_L, this);
 	  connect(loadAction, SIGNAL(activated()), SLOT(loadConfig()));
 	QAction *saveAction = new QAction("Save", QPixmap(xpm_save), "&Save", CTRL+Key_S, this);
 	  connect(saveAction, SIGNAL(activated()), SLOT(saveConfig()));
 	QAction *saveAsAction = new QAction("Save As...", "Save &As...", 0, this);
 	  connect(saveAsAction, SIGNAL(activated()), SLOT(saveConfigAs()));
 	QAction *singleViewAction = new QAction("Single View", QPixmap(xpm_single_view), "Split View", 0, this);
 	  connect(singleViewAction, SIGNAL(activated()), SLOT(showSingleView()));
 	QAction *splitViewAction = new QAction("Split View", QPixmap(xpm_split_view), "Split View", 0, this);
 	  connect(splitViewAction, SIGNAL(activated()), SLOT(showSplitView()));
 	QAction *fullViewAction = new QAction("Full View", QPixmap(xpm_tree_view), "Full View", 0, this);
 	  connect(fullViewAction, SIGNAL(activated()), SLOT(showFullView()));
 
 	QAction *showNameAction = new QAction(NULL, "Show Name", 0, this);
 	  showNameAction->setToggleAction(TRUE);
 	  showNameAction->setOn(configList->showName);
 	  connect(showNameAction, SIGNAL(toggled(bool)), SLOT(setShowName(bool)));
 	QAction *showRangeAction = new QAction(NULL, "Show Range", 0, this);
 	  showRangeAction->setToggleAction(TRUE);
 	  showRangeAction->setOn(configList->showRange);
 	  connect(showRangeAction, SIGNAL(toggled(bool)), SLOT(setShowRange(bool)));
 	QAction *showDataAction = new QAction(NULL, "Show Data", 0, this);
 	  showDataAction->setToggleAction(TRUE);
 	  showDataAction->setOn(configList->showData);
 	  connect(showDataAction, SIGNAL(toggled(bool)), SLOT(setShowData(bool)));
 	QAction *showAllAction = new QAction(NULL, "Show All Options", 0, this);
 	  showAllAction->setToggleAction(TRUE);
 	  showAllAction->setOn(configList->showAll);
 	  connect(showAllAction, SIGNAL(toggled(bool)), SLOT(setShowAll(bool)));
 	QAction *showDebugAction = new QAction(NULL, "Show Debug Info", 0, this);
 	  showDebugAction->setToggleAction(TRUE);
 	  showDebugAction->setOn(showDebug);
 	  connect(showDebugAction, SIGNAL(toggled(bool)), SLOT(setShowDebug(bool)));
 
 	QAction *showIntroAction = new QAction(NULL, "Introduction", 0, this);
 	  connect(showIntroAction, SIGNAL(activated()), SLOT(showIntro()));
 	QAction *showAboutAction = new QAction(NULL, "About", 0, this);
 	  connect(showAboutAction, SIGNAL(activated()), SLOT(showAbout()));
 
 	// init tool bar
 	backAction->addTo(toolBar);
 	toolBar->addSeparator();
 	loadAction->addTo(toolBar);
 	saveAction->addTo(toolBar);
 	toolBar->addSeparator();
 	singleViewAction->addTo(toolBar);
 	splitViewAction->addTo(toolBar);
 	fullViewAction->addTo(toolBar);
 
 	// create config menu
 	QPopupMenu* config = new QPopupMenu(this);
 	menu->insertItem("&File", config);
 	loadAction->addTo(config);
 	saveAction->addTo(config);
 	saveAsAction->addTo(config);
 	config->insertSeparator();
 	quitAction->addTo(config);
 
 	// create options menu
 	QPopupMenu* optionMenu = new QPopupMenu(this);
 	menu->insertItem("&Option", optionMenu);
 	showNameAction->addTo(optionMenu);
 	showRangeAction->addTo(optionMenu);
 	showDataAction->addTo(optionMenu);
 	optionMenu->insertSeparator();
 	showAllAction->addTo(optionMenu);
 	showDebugAction->addTo(optionMenu);
 
 	// create help menu
 	QPopupMenu* helpMenu = new QPopupMenu(this);
 	menu->insertSeparator();
 	menu->insertItem("&Help", helpMenu);
 	showIntroAction->addTo(helpMenu);
 	showAboutAction->addTo(helpMenu);
 
 	connect(configList, SIGNAL(menuSelected(struct menu *)),
 		SLOT(changeMenu(struct menu *)));
 	connect(configList, SIGNAL(parentSelected()),
 		SLOT(goBack()));
 	connect(menuList, SIGNAL(menuSelected(struct menu *)),
 		SLOT(changeMenu(struct menu *)));
 
 	connect(configList, SIGNAL(gotFocus(void)),
 		SLOT(listFocusChanged(void)));
 	connect(menuList, SIGNAL(gotFocus(void)),
 		SLOT(listFocusChanged(void)));
 
-	//showFullView();
 	showSplitView();
 }
 
 static QString print_filter(const char *str)
 {
 	QRegExp re("[<>&\"\\n]");
 	QString res = str;
 	for (int i = 0; (i = res.find(re, i)) >= 0;) {
 		switch (res[i].latin1()) {
 		case '<':
 			res.replace(i, 1, "&lt;");
 			i += 4;
 			break;
 		case '>':
 			res.replace(i, 1, "&gt;");
 			i += 4;
 			break;
 		case '&':
 			res.replace(i, 1, "&amp;");
 			i += 5;
 			break;
 		case '"':
 			res.replace(i, 1, "&quot;");
 			i += 6;
 			break;
 		case '\n':
 			res.replace(i, 1, "<br>");
 			i += 4;
 			break;
 		}
 	}
 	return res;
 }
 
 static void expr_print_help(void *data, const char *str)
 {
 	((QString*)data)->append(print_filter(str));
 }
 
 /*
  * display a new help entry as soon as a new menu entry is selected
  */
 void ConfigMainWindow::setHelp(QListViewItem* item)
 {
 	struct symbol* sym;
-	struct menu* menu;
+	struct menu* menu = 0;
 
 	configList->parent()->lineEdit->hide();
-	if (item) {
-		QString head, debug, help;
+	if (item)
 		menu = ((ConfigItem*)item)->menu;
-		sym = menu->sym;
-		if (sym) {
-			if (menu->prompt) {
-				head += "<big><b>";
-				head += print_filter(menu->prompt->text);
-				head += "</b></big>";
-				if (sym->name) {
-					head += " (";
-					head += print_filter(sym->name);
-					head += ")";
-				}
-			} else if (sym->name) {
-				head += "<big><b>";
+	if (!menu) {
+		helpText->setText(NULL);
+		return;
+	}
+
+	QString head, debug, help;
+	menu = ((ConfigItem*)item)->menu;
+	sym = menu->sym;
+	if (sym) {
+		if (menu->prompt) {
+			head += "<big><b>";
+			head += print_filter(menu->prompt->text);
+			head += "</b></big>";
+			if (sym->name) {
+				head += " (";
 				head += print_filter(sym->name);
-				head += "</b></big>";
+				head += ")";
 			}
-			head += "<br><br>";
-
-			if (showDebug) {
-				debug += "type: ";
-				debug += print_filter(sym_type_name(sym->type));
+		} else if (sym->name) {
+			head += "<big><b>";
+			head += print_filter(sym->name);
+			head += "</b></big>";
+		}
+		head += "<br><br>";
+
+		if (showDebug) {
+			debug += "type: ";
+			debug += print_filter(sym_type_name(sym->type));
+			if (sym_is_choice(sym))
+				debug += " (choice)";
+			debug += "<br>";
+			if (sym->rev_dep.expr) {
+				debug += "reverse dep: ";
+				expr_print(sym->rev_dep.expr, expr_print_help, &debug, E_NONE);
 				debug += "<br>";
-				for (struct property *prop = sym->prop; prop; prop = prop->next) {
-					switch (prop->type) {
-					case P_PROMPT:
-						debug += "prompt: ";
-						debug += print_filter(prop->text);
-						debug += "<br>";
-						if (prop->visible.expr) {
-							debug += "&nbsp;&nbsp;dep: ";
-							expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
-							debug += "<br>";
-						}
-						break;
-					case P_DEFAULT:
-						debug += "default: ";
-						if (sym_is_choice(sym))
-							debug += print_filter(prop->def->name);
-						else {
-							sym_calc_value(prop->def);
-							debug += print_filter(sym_get_string_value(prop->def));
-						}
-						debug += "<br>";
-						if (prop->visible.expr) {
-							debug += "&nbsp;&nbsp;dep: ";
-							expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
-							debug += "<br>";
-						}
-						break;
-					case P_CHOICE:
-						break;
-					default:
-						debug += "unknown property: ";
-						debug += prop_get_type_name(prop->type);
+			}
+			for (struct property *prop = sym->prop; prop; prop = prop->next) {
+				switch (prop->type) {
+				case P_PROMPT:
+				case P_MENU:
+					debug += "prompt: ";
+					debug += print_filter(prop->text);
+					debug += "<br>";
+					break;
+				case P_DEFAULT:
+					debug += "default: ";
+					expr_print(prop->expr, expr_print_help, &debug, E_NONE);
+					debug += "<br>";
+					break;
+				case P_CHOICE:
+					if (sym_is_choice(sym)) {
+						debug += "choice: ";
+						expr_print(prop->expr, expr_print_help, &debug, E_NONE);
 						debug += "<br>";
 					}
+					break;
+				case P_SELECT:
+					debug += "select: ";
+					expr_print(prop->expr, expr_print_help, &debug, E_NONE);
+					debug += "<br>";
+					break;
+				case P_RANGE:
+					debug += "range: ";
+					expr_print(prop->expr, expr_print_help, &debug, E_NONE);
+					debug += "<br>";
+					break;
+				default:
+					debug += "unknown property: ";
+					debug += prop_get_type_name(prop->type);
+					debug += "<br>";
 				}
-				debug += "<br>";
-			}
-
-			help = print_filter(sym->help);
-		} else if (menu->prompt) {
-			head += "<big><b>";
-			head += print_filter(menu->prompt->text);
-			head += "</b></big><br><br>";
-			if (showDebug) {
-				if (menu->prompt->visible.expr) {
-					debug += "&nbsp;&nbsp;dep: ";
-					expr_print(menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
+				if (prop->visible.expr) {
+					debug += "&nbsp;&nbsp;&nbsp;&nbsp;dep: ";
+					expr_print(prop->visible.expr, expr_print_help, &debug, E_NONE);
 					debug += "<br>";
 				}
 			}
+			debug += "<br>";
+		}
+
+		help = print_filter(sym->help);
+	} else if (menu->prompt) {
+		head += "<big><b>";
+		head += print_filter(menu->prompt->text);
+		head += "</b></big><br><br>";
+		if (showDebug) {
+			if (menu->prompt->visible.expr) {
+				debug += "&nbsp;&nbsp;dep: ";
+				expr_print(menu->prompt->visible.expr, expr_print_help, &debug, E_NONE);
+				debug += "<br><br>";
+			}
 		}
-		helpText->setText(head + debug + help);
-		return;
 	}
-	helpText->setText(NULL);
+	if (showDebug)
+		debug += QString().sprintf("defined at %s:%d<br><br>", menu->file->name, menu->lineno);
+	helpText->setText(head + debug + help);
 }
 
 void ConfigMainWindow::loadConfig(void)
 {
 	QString s = QFileDialog::getOpenFileName(".config", NULL, this);
 	if (s.isNull())
 		return;
 	if (conf_read(s.latin1()))
 		QMessageBox::information(this, "qconf", "Unable to load configuration!");
 	ConfigView::updateListAll();
 }
 
 void ConfigMainWindow::saveConfig(void)
 {
 	if (conf_write(NULL))
 		QMessageBox::information(this, "qconf", "Unable to save configuration!");
 }
 
 void ConfigMainWindow::saveConfigAs(void)
 {
 	QString s = QFileDialog::getSaveFileName(".config", NULL, this);
 	if (s.isNull())
 		return;
 	if (conf_write(s.latin1()))
 		QMessageBox::information(this, "qconf", "Unable to save configuration!");
 }
 
 void ConfigMainWindow::changeMenu(struct menu *menu)
 {
 	configList->setRootMenu(menu);
 	backAction->setEnabled(TRUE);
 }
 
 void ConfigMainWindow::listFocusChanged(void)
 {
 	if (menuList->hasFocus()) {
 		if (menuList->mode == menuMode)
 			configList->clearSelection();
 		setHelp(menuList->selectedItem());
 	} else if (configList->hasFocus()) {
 		setHelp(configList->selectedItem());
 	}
 }
 
 void ConfigMainWindow::goBack(void)
 {
 	ConfigItem* item;
 
 	configList->setParentMenu();
 	if (configList->rootEntry == &rootmenu)
 		backAction->setEnabled(FALSE);
 	item = (ConfigItem*)menuList->selectedItem();
 	while (item) {
 		if (item->menu == configList->rootEntry) {
 			menuList->setSelected(item, TRUE);
 			break;
 		}
 		item = (ConfigItem*)item->parent();
 	}
 }
 
 void ConfigMainWindow::showSingleView(void)
 {
-	menuList->hide();
+	menuView->hide();
 	menuList->setRootMenu(0);
 	configList->mode = singleMode;
 	if (configList->rootEntry == &rootmenu)
 		configList->updateListAll();
 	else
 		configList->setRootMenu(&rootmenu);
 	configList->setAllOpen(TRUE);
 	configList->setFocus();
 }
 
 void ConfigMainWindow::showSplitView(void)
 {
 	configList->mode = symbolMode;
 	if (configList->rootEntry == &rootmenu)
 		configList->updateListAll();
 	else
 		configList->setRootMenu(&rootmenu);
 	configList->setAllOpen(TRUE);
 	configApp->processEvents();
 	menuList->mode = menuMode;
 	menuList->setRootMenu(&rootmenu);
-	menuList->show();
 	menuList->setAllOpen(TRUE);
+	menuView->show();
 	menuList->setFocus();
 }
 
 void ConfigMainWindow::showFullView(void)
 {
-	menuList->hide();
+	menuView->hide();
 	menuList->setRootMenu(0);
 	configList->mode = fullMode;
 	if (configList->rootEntry == &rootmenu)
 		configList->updateListAll();
 	else
 		configList->setRootMenu(&rootmenu);
 	configList->setAllOpen(FALSE);
 	configList->setFocus();
 }
 
 void ConfigMainWindow::setShowAll(bool b)
 {
 	if (configList->showAll == b)
 		return;
 	configList->showAll = b;
 	configList->updateListAll();
 	menuList->showAll = b;
 	menuList->updateListAll();
 }
 
 void ConfigMainWindow::setShowDebug(bool b)
 {
 	if (showDebug == b)
 		return;
 	showDebug = b;
 }
 
 void ConfigMainWindow::setShowName(bool b)
 {
 	if (configList->showName == b)
 		return;
 	configList->showName = b;
 	configList->reinit();
+	menuList->showName = b;
+	menuList->reinit();
 }
 
 void ConfigMainWindow::setShowRange(bool b)
 {
 	if (configList->showRange == b)
 		return;
 	configList->showRange = b;
 	configList->reinit();
+	menuList->showRange = b;
+	menuList->reinit();
 }
 
 void ConfigMainWindow::setShowData(bool b)
 {
 	if (configList->showData == b)
 		return;
 	configList->showData = b;
 	configList->reinit();
+	menuList->showData = b;
+	menuList->reinit();
 }
 
 /*
  * ask for saving configuration before quitting
  * TODO ask only when something changed
  */
 void ConfigMainWindow::closeEvent(QCloseEvent* e)
 {
 	if (!sym_change_count) {
 		e->accept();
 		return;
 	}
 	QMessageBox mb("qconf", "Save configuration?", QMessageBox::Warning,
 			QMessageBox::Yes | QMessageBox::Default, QMessageBox::No, QMessageBox::Cancel | QMessageBox::Escape);
 	mb.setButtonText(QMessageBox::Yes, "&Save Changes");
 	mb.setButtonText(QMessageBox::No, "&Discard Changes");
 	mb.setButtonText(QMessageBox::Cancel, "Cancel Exit");
 	switch (mb.exec()) {
 	case QMessageBox::Yes:
 		conf_write(NULL);
 	case QMessageBox::No:
 		e->accept();
 		break;
 	case QMessageBox::Cancel:
 		e->ignore();
 		break;
 	}
 }
 
 void ConfigMainWindow::showIntro(void)
 {
 	static char str[] = "Welcome to the qconf graphical kernel configuration tool for Linux.\n\n"
 		"For each option, a blank box indicates the feature is disabled, a check\n"
 		"indicates it is enabled, and a dot indicates that it is to be compiled\n"
 		"as a module.  Clicking on the box will cycle through the three states.\n\n"
 		"If you do not see an option (e.g., a device driver) that you believe\n"
 		"should be present, try turning on Show All Options under the Options menu.\n"
 		"Although there is no cross reference yet to help you figure out what other\n"
 		"options must be enabled to support the option you are interested in, you can\n"
 		"still view the help of a grayed-out option.\n\n"
 		"Toggling Show Debug Info under the Options menu will show the dependencies,\n"
 		"which you can then match by examining other options.\n\n";
 
 	QMessageBox::information(this, "qconf", str);
 }
 
 void ConfigMainWindow::showAbout(void)
 {
 	static char str[] = "qconf is Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>.\n\n"
 		"Bug reports and feature request can also be entered at http://bugzilla.kernel.org/\n";
 
 	QMessageBox::information(this, "qconf", str);
 }
 
 void fixup_rootmenu(struct menu *menu)
 {
 	struct menu *child;
+	static int menu_cnt = 0;
 
-	if (!menu->prompt || menu->prompt->type != P_MENU)
-		return;
-	menu->prompt->type = P_ROOTMENU;
-	for (child = menu->list; child; child = child->next)
-		fixup_rootmenu(child);
+	menu->flags |= MENU_ROOT;
+	for (child = menu->list; child; child = child->next) {
+		if (child->prompt && child->prompt->type == P_MENU) {
+			menu_cnt++;
+			fixup_rootmenu(child);
+			menu_cnt--;
+		} else if (!menu_cnt)
+			fixup_rootmenu(child);
+	}
+}
+
+static const char *progname;
+
+static void usage(void)
+{
+	printf("%s <config>\n", progname);
+	exit(0);
 }
 
 int main(int ac, char** av)
 {
 	ConfigMainWindow* v;
 	const char *name;
 
 #ifndef LKC_DIRECT_LINK
 	kconfig_load();
 #endif
 
+	progname = av[0];
 	configApp = new QApplication(ac, av);
 #if QT_VERSION >= 300
 	configSettings = new QSettings;
 #endif
 	if (ac > 1 && av[1][0] == '-') {
 		switch (av[1][1]) {
-		case 'a':
-			//showAll = 1;
-			break;
 		case 'h':
 		case '?':
-			printf("%s <config>\n", av[0]);
-			exit(0);
+			usage();
 		}
 		name = av[2];
 	} else
 		name = av[1];
+	if (!name)
+		usage();
+
 	conf_parse(name);
 	fixup_rootmenu(&rootmenu);
 	conf_read(NULL);
 	//zconfdump(stdout);
 
 	v = new ConfigMainWindow();
 
 	//zconfdump(stdout);
 	v->show();
 	configApp->connect(configApp, SIGNAL(lastWindowClosed()), SLOT(quit()));
 	configApp->exec();
 
 #if QT_VERSION >= 300
 	configSettings->writeEntry("/kconfig/qconf/window x", v->pos().x());
 	configSettings->writeEntry("/kconfig/qconf/window y", v->pos().y());
 	configSettings->writeEntry("/kconfig/qconf/window width", v->size().width());
 	configSettings->writeEntry("/kconfig/qconf/window height", v->size().height());
 	delete configSettings;
 #endif
 	return 0;
 }
diff --git a/scripts/kconfig/qconf.h b/scripts/kconfig/qconf.h
index 6f096b4..c548884 100644
--- a/scripts/kconfig/qconf.h
+++ b/scripts/kconfig/qconf.h
@@ -1,226 +1,238 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <qlistview.h>
 
 class ConfigList;
 class ConfigItem;
 class ConfigLineEdit;
 class ConfigMainWindow;
 
 class ConfigView : public QVBox {
 	Q_OBJECT
 	typedef class QVBox Parent;
 public:
 	ConfigView(QWidget* parent, ConfigMainWindow* cview);
 	~ConfigView(void);
 	static void updateList(ConfigItem* item);
 	static void updateListAll(void);
 
 public:
 	ConfigList* list;
 	ConfigLineEdit* lineEdit;
 
 	static ConfigView* viewList;
 	ConfigView* nextView;
 };
 
 enum colIdx {
 	promptColIdx, nameColIdx, noColIdx, modColIdx, yesColIdx, dataColIdx, colNr
 };
 enum listMode {
 	singleMode, menuMode, symbolMode, fullMode
 };
 
 class ConfigList : public QListView {
 	Q_OBJECT
 	typedef class QListView Parent;
 public:
 	ConfigList(ConfigView* p, ConfigMainWindow* cview);
 	void reinit(void);
 	ConfigView* parent(void) const
 	{
 		return (ConfigView*)Parent::parent();
 	}
 
 protected:
 	ConfigMainWindow* cview;
 
 	void keyPressEvent(QKeyEvent *e);
 	void contentsMousePressEvent(QMouseEvent *e);
 	void contentsMouseReleaseEvent(QMouseEvent *e);
 	void contentsMouseMoveEvent(QMouseEvent *e);
 	void contentsMouseDoubleClickEvent(QMouseEvent *e);
 	void focusInEvent(QFocusEvent *e);
 public slots:
 	void setRootMenu(struct menu *menu);
 
 	void updateList(ConfigItem *item);
 	void setValue(ConfigItem* item, tristate val);
 	void changeValue(ConfigItem* item);
 	void updateSelection(void);
 signals:
 	void menuSelected(struct menu *menu);
 	void parentSelected(void);
 	void gotFocus(void);
 
 public:
 	void updateListAll(void)
 	{
 		updateAll = true;
 		updateList(NULL);
 		updateAll = false;
 	}
 	ConfigList* listView()
 	{
 		return this;
 	}
 	ConfigItem* firstChild() const
 	{
 		return (ConfigItem *)Parent::firstChild();
 	}
 	int mapIdx(colIdx idx)
 	{
 		return colMap[idx];
 	}
 	void addColumn(colIdx idx, const QString& label)
 	{
 		colMap[idx] = Parent::addColumn(label);
 		colRevMap[colMap[idx]] = idx;
 	}
 	void removeColumn(colIdx idx)
 	{
 		int col = colMap[idx];
 		if (col >= 0) {
 			Parent::removeColumn(col);
 			colRevMap[col] = colMap[idx] = -1;
 		}
 	}
 	void setAllOpen(bool open);
 	void setParentMenu(void);
 
+	template <class P>
+	void ConfigList::updateMenuList(P*, struct menu*);
+
 	bool updateAll;
 
 	QPixmap symbolYesPix, symbolModPix, symbolNoPix;
-	QPixmap choiceYesPix, choiceNoPix, menuPix, menuInvPix;
+	QPixmap choiceYesPix, choiceNoPix;
+	QPixmap menuPix, menuInvPix, menuBackPix, voidPix;
 
 	bool showAll, showName, showRange, showData;
 	enum listMode mode;
 	struct menu *rootEntry;
 	QColorGroup disabledColorGroup;
 	QColorGroup inactivedColorGroup;
 
 private:
 	int colMap[colNr];
 	int colRevMap[colNr];
 };
 
 class ConfigItem : public QListViewItem {
 	typedef class QListViewItem Parent;
 public:
 	ConfigItem(QListView *parent, ConfigItem *after, struct menu *m, bool v)
-	: Parent(parent, after), menu(m), visible(v)
+	: Parent(parent, after), menu(m), visible(v), goParent(false)
 	{
 		init();
 	}
 	ConfigItem(ConfigItem *parent, ConfigItem *after, struct menu *m, bool v)
-	: Parent(parent, after), menu(m), visible(v)
+	: Parent(parent, after), menu(m), visible(v), goParent(false)
+	{
+		init();
+	}
+	ConfigItem(QListView *parent, ConfigItem *after, bool v)
+	: Parent(parent, after), menu(0), visible(v), goParent(true)
 	{
 		init();
 	}
 	~ConfigItem(void);
 	void init(void);
 #if QT_VERSION >= 300
 	void okRename(int col);
 #endif
 	void updateMenu(void);
-	bool updateNeeded(void);
+	void testUpdateMenu(bool v);
 	ConfigList* listView() const
 	{
 		return (ConfigList*)Parent::listView();
 	}
 	ConfigItem* firstChild() const
 	{
 		return (ConfigItem *)Parent::firstChild();
 	}
 	ConfigItem* nextSibling() const
 	{
 		return (ConfigItem *)Parent::nextSibling();
 	}
 	void setText(colIdx idx, const QString& text)
 	{
 		Parent::setText(listView()->mapIdx(idx), text);
 	}
 	QString text(colIdx idx) const
 	{
 		return Parent::text(listView()->mapIdx(idx));
 	}
 	void setPixmap(colIdx idx, const QPixmap& pm)
 	{
 		Parent::setPixmap(listView()->mapIdx(idx), pm);
 	}
 	const QPixmap* pixmap(colIdx idx) const
 	{
 		return Parent::pixmap(listView()->mapIdx(idx));
 	}
 	void paintCell(QPainter* p, const QColorGroup& cg, int column, int width, int align);
 
 	ConfigItem* nextItem;
 	struct menu *menu;
 	bool visible;
+	bool goParent;
 };
 
 class ConfigLineEdit : public QLineEdit {
 	Q_OBJECT
 	typedef class QLineEdit Parent;
 public:
 	ConfigLineEdit(ConfigView* parent)
 	: Parent(parent)
 	{ }
 	ConfigView* parent(void) const
 	{
 		return (ConfigView*)Parent::parent();
 	}
 	void show(ConfigItem *i);
 	void keyPressEvent(QKeyEvent *e);
 
 public:
 	ConfigItem *item;
 };
 
 class ConfigMainWindow : public QMainWindow {
 	Q_OBJECT
 public:
 	ConfigMainWindow(void);
 public slots:
 	void setHelp(QListViewItem* item);
 	void changeMenu(struct menu *);
 	void listFocusChanged(void);
 	void goBack(void);
 	void loadConfig(void);
 	void saveConfig(void);
 	void saveConfigAs(void);
 	void showSingleView(void);
 	void showSplitView(void);
 	void showFullView(void);
 	void setShowAll(bool);
 	void setShowDebug(bool);
 	void setShowRange(bool);
 	void setShowName(bool);
 	void setShowData(bool);
 	void showIntro(void);
 	void showAbout(void);
 
 protected:
 	void closeEvent(QCloseEvent *e);
 
+	ConfigView *menuView;
 	ConfigList *menuList;
+	ConfigView *configView;
 	ConfigList *configList;
 	QTextView *helpText;
 	QToolBar *toolBar;
 	QAction *backAction;
 
 	bool showDebug;
 };
diff --git a/scripts/kconfig/symbol.c b/scripts/kconfig/symbol.c
index 845d8a3..11318d9 100644
--- a/scripts/kconfig/symbol.c
+++ b/scripts/kconfig/symbol.c
@@ -1,629 +1,778 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/utsname.h>
 
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 
 struct symbol symbol_yes = {
 	name: "y",
 	curr: { "y", yes },
 	flags: SYMBOL_YES|SYMBOL_VALID,
 }, symbol_mod = {
 	name: "m",
 	curr: { "m", mod },
 	flags: SYMBOL_MOD|SYMBOL_VALID,
 }, symbol_no = {
 	name: "n",
 	curr: { "n", no },
 	flags: SYMBOL_NO|SYMBOL_VALID,
 }, symbol_empty = {
 	name: "",
 	curr: { "", no },
 	flags: SYMBOL_VALID,
 };
 
 int sym_change_count;
 struct symbol *modules_sym;
 
 void sym_add_default(struct symbol *sym, const char *def)
 {
-	struct property *prop = create_prop(P_DEFAULT);
-	struct property **propp;
-
-	prop->sym = sym;
-	prop->def = sym_lookup(def, 1);
+	struct property *prop = prop_alloc(P_DEFAULT, sym);
 
-	/* append property to the prop list of symbol */
-	if (prop->sym) {
-		for (propp = &prop->sym->prop; *propp; propp = &(*propp)->next)
-			;
-		*propp = prop;
-	}
+	prop->expr = expr_alloc_symbol(sym_lookup(def, 1));
 }
 
 void sym_init(void)
 {
 	struct symbol *sym;
 	struct utsname uts;
 	char *p;
 	static bool inited = false;
 
 	if (inited)
 		return;
 	inited = true;
 
 	uname(&uts);
 
 	sym = sym_lookup("ARCH", 0);
 	sym->type = S_STRING;
 	sym->flags |= SYMBOL_AUTO;
 	p = getenv("ARCH");
 	if (p)
 		sym_add_default(sym, p);
 
 	sym = sym_lookup("KERNELRELEASE", 0);
 	sym->type = S_STRING;
 	sym->flags |= SYMBOL_AUTO;
 	p = getenv("KERNELRELEASE");
 	if (p)
 		sym_add_default(sym, p);
 
 	sym = sym_lookup("UNAME_RELEASE", 0);
 	sym->type = S_STRING;
 	sym->flags |= SYMBOL_AUTO;
 	sym_add_default(sym, uts.release);
 }
 
-int sym_get_type(struct symbol *sym)
+enum symbol_type sym_get_type(struct symbol *sym)
 {
-	int type = sym->type;
+	enum symbol_type type = sym->type;
+
 	if (type == S_TRISTATE) {
 		if (sym_is_choice_value(sym) && sym->visible == yes)
 			type = S_BOOLEAN;
 		else {
 			sym_calc_value(modules_sym);
-			if (S_TRI(modules_sym->curr) == no)
+			if (modules_sym->curr.tri == no)
 				type = S_BOOLEAN;
 		}
 	}
 	return type;
 }
 
-const char *sym_type_name(int type)
+const char *sym_type_name(enum symbol_type type)
 {
 	switch (type) {
 	case S_BOOLEAN:
 		return "boolean";
 	case S_TRISTATE:
 		return "tristate";
 	case S_INT:
 		return "integer";
 	case S_HEX:
 		return "hex";
 	case S_STRING:
 		return "string";
 	case S_UNKNOWN:
 		return "unknown";
+	case S_OTHER:
+		break;
 	}
 	return "???";
 }
 
 struct property *sym_get_choice_prop(struct symbol *sym)
 {
 	struct property *prop;
 
 	for_all_choices(sym, prop)
 		return prop;
 	return NULL;
 }
 
 struct property *sym_get_default_prop(struct symbol *sym)
 {
 	struct property *prop;
-	tristate visible;
 
 	for_all_defaults(sym, prop) {
-		visible = E_CALC(prop->visible);
-		if (visible != no)
+		prop->visible.tri = expr_calc_value(prop->visible.expr);
+		if (prop->visible.tri != no)
 			return prop;
 	}
 	return NULL;
 }
 
-void sym_calc_visibility(struct symbol *sym)
+struct property *sym_get_range_prop(struct symbol *sym)
 {
 	struct property *prop;
-	tristate visible, oldvisible;
+
+	for_all_properties(sym, prop, P_RANGE) {
+		prop->visible.tri = expr_calc_value(prop->visible.expr);
+		if (prop->visible.tri != no)
+			return prop;
+	}
+	return NULL;
+}
+
+static void sym_calc_visibility(struct symbol *sym)
+{
+	struct property *prop;
+	tristate tri;
 
 	/* any prompt visible? */
-	oldvisible = sym->visible;
-	visible = no;
-	for_all_prompts(sym, prop)
-		visible = E_OR(visible, E_CALC(prop->visible));
-	if (oldvisible != visible) {
-		sym->visible = visible;
+	tri = no;
+	for_all_prompts(sym, prop) {
+		prop->visible.tri = expr_calc_value(prop->visible.expr);
+		tri = E_OR(tri, prop->visible.tri);
+	}
+	if (sym->visible != tri) {
+		sym->visible = tri;
+		sym_set_changed(sym);
+	}
+	if (sym_is_choice_value(sym))
+		return;
+	tri = no;
+	if (sym->rev_dep.expr)
+		tri = expr_calc_value(sym->rev_dep.expr);
+	if (sym->rev_dep.tri != tri) {
+		sym->rev_dep.tri = tri;
 		sym_set_changed(sym);
 	}
 }
 
+static struct symbol *sym_calc_choice(struct symbol *sym)
+{
+	struct symbol *def_sym;
+	struct property *prop;
+	struct expr *e;
+
+	/* is the user choice visible? */
+	def_sym = sym->user.val;
+	if (def_sym) {
+		sym_calc_visibility(def_sym);
+		if (def_sym->visible != no)
+			return def_sym;
+	}
+
+	/* any of the defaults visible? */
+	for_all_defaults(sym, prop) {
+		prop->visible.tri = expr_calc_value(prop->visible.expr);
+		if (prop->visible.tri == no)
+			continue;
+		def_sym = prop_get_symbol(prop);
+		sym_calc_visibility(def_sym);
+		if (def_sym->visible != no)
+			return def_sym;
+	}
+
+	/* just get the first visible value */
+	prop = sym_get_choice_prop(sym);
+	for (e = prop->expr; e; e = e->left.expr) {
+		def_sym = e->right.sym;
+		sym_calc_visibility(def_sym);
+		if (def_sym->visible != no)
+			return def_sym;
+	}
+
+	/* no choice? reset tristate value */
+	sym->curr.tri = no;
+	return NULL;
+}
+
 void sym_calc_value(struct symbol *sym)
 {
 	struct symbol_value newval, oldval;
-	struct property *prop, *def_prop;
-	struct symbol *def_sym;
+	struct property *prop;
 	struct expr *e;
 
+	if (!sym)
+		return;
+
 	if (sym->flags & SYMBOL_VALID)
 		return;
+	sym->flags |= SYMBOL_VALID;
 
 	oldval = sym->curr;
 
 	switch (sym->type) {
 	case S_INT:
 	case S_HEX:
 	case S_STRING:
 		newval = symbol_empty.curr;
 		break;
 	case S_BOOLEAN:
 	case S_TRISTATE:
 		newval = symbol_no.curr;
 		break;
 	default:
-		S_VAL(newval) = sym->name;
-		S_TRI(newval) = no;
-		if (sym->flags & SYMBOL_CONST) {
-			goto out;
-		}
-		//newval = symbol_empty.curr;
-		// generate warning somewhere here later
-		//S_TRI(newval) = yes;
-		goto out;
+		sym->curr.val = sym->name;
+		sym->curr.tri = no;
+		return;
 	}
-	sym->flags |= SYMBOL_VALID;
 	if (!sym_is_choice_value(sym))
 		sym->flags &= ~SYMBOL_WRITE;
 
 	sym_calc_visibility(sym);
 
 	/* set default if recursively called */
 	sym->curr = newval;
 
-	if (sym->visible != no) {
-		sym->flags |= SYMBOL_WRITE;
-		if (!sym_has_value(sym)) {
-			if (!sym_is_choice(sym)) {
-				prop = sym_get_default_prop(sym);
-				if (prop) {
-					sym_calc_value(prop->def);
-					newval = prop->def->curr;
-				}
-			} else
-				S_TRI(newval) = S_TRI(sym->def);
-		} else
-			newval = sym->def;
-
-		S_TRI(newval) = E_AND(S_TRI(newval), sym->visible);
-		/* if the symbol is visible and not optionial,
-		 * possibly ignore old user choice. */
-		if (!sym_is_optional(sym) && S_TRI(newval) == no)
-			S_TRI(newval) = sym->visible;
+	switch (sym_get_type(sym)) {
+	case S_BOOLEAN:
+	case S_TRISTATE:
 		if (sym_is_choice_value(sym) && sym->visible == yes) {
 			prop = sym_get_choice_prop(sym);
-			S_TRI(newval) = (S_VAL(prop->def->curr) == sym) ? yes : no;
-		}
-	} else {
-		prop = sym_get_default_prop(sym);
-		if (prop) {
+			newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no;
+		} else if (E_OR(sym->visible, sym->rev_dep.tri) != no) {
 			sym->flags |= SYMBOL_WRITE;
-			sym_calc_value(prop->def);
-			newval = prop->def->curr;
+			if (sym_has_value(sym))
+				newval.tri = sym->user.tri;
+			else if (!sym_is_choice(sym)) {
+				prop = sym_get_default_prop(sym);
+				if (prop)
+					newval.tri = expr_calc_value(prop->expr);
+			}
+			newval.tri = E_OR(E_AND(newval.tri, sym->visible), sym->rev_dep.tri);
+		} else if (!sym_is_choice(sym)) {
+			prop = sym_get_default_prop(sym);
+			if (prop) {
+				sym->flags |= SYMBOL_WRITE;
+				newval.tri = expr_calc_value(prop->expr);
+			}
 		}
-	}
-
-	switch (sym_get_type(sym)) {
-	case S_TRISTATE:
-		if (S_TRI(newval) != mod)
-			break;
-		sym_calc_value(modules_sym);
-		if (S_TRI(modules_sym->curr) == no)
-			S_TRI(newval) = yes;
-		break;
-	case S_BOOLEAN:
-		if (S_TRI(newval) == mod)
-			S_TRI(newval) = yes;
-	}
-
-out:
-	sym->curr = newval;
-
-	if (sym_is_choice(sym) && S_TRI(newval) == yes) {
-		def_sym = S_VAL(sym->def);
-		if (def_sym) {
-			sym_calc_visibility(def_sym);
-			if (def_sym->visible == no)
-				def_sym = NULL;
+		if (sym_get_type(sym) == S_BOOLEAN) {
+			if (newval.tri == mod)
+				newval.tri = yes;
+			if (sym->visible == mod)
+				sym->visible = yes;
+			if (sym->rev_dep.tri == mod)
+				sym->rev_dep.tri = yes;
 		}
-		if (!def_sym) {
-			for_all_defaults(sym, def_prop) {
-				if (E_CALC(def_prop->visible) == no)
-					continue;
-				sym_calc_visibility(def_prop->def);
-				if (def_prop->def->visible != no) {
-					def_sym = def_prop->def;
-					break;
-				}
+		break;
+	case S_STRING:
+	case S_HEX:
+	case S_INT:
+		if (sym->visible != no) {
+			sym->flags |= SYMBOL_WRITE;
+			if (sym_has_value(sym)) {
+				newval.val = sym->user.val;
+				break;
 			}
 		}
-
-		if (!def_sym) {
-			prop = sym_get_choice_prop(sym);
-			for (e = prop->dep; e; e = e->left.expr) {
-				sym_calc_visibility(e->right.sym);
-				if (e->right.sym->visible != no) {
-					def_sym = e->right.sym;
-					break;
-				}
+		prop = sym_get_default_prop(sym);
+		if (prop) {
+			struct symbol *ds = prop_get_symbol(prop);
+			if (ds) {
+				sym->flags |= SYMBOL_WRITE;
+				sym_calc_value(ds);
+				newval.val = ds->curr.val;
 			}
 		}
-
-		S_VAL(newval) = def_sym;
+		break;
+	default:
+		;
 	}
 
-	if (memcmp(&oldval, &newval, sizeof(newval)))
-		sym_set_changed(sym);
 	sym->curr = newval;
+	if (sym_is_choice(sym) && newval.tri == yes)
+		sym->curr.val = sym_calc_choice(sym);
+
+	if (memcmp(&oldval, &sym->curr, sizeof(oldval)))
+		sym_set_changed(sym);
 
 	if (sym_is_choice(sym)) {
 		int flags = sym->flags & (SYMBOL_CHANGED | SYMBOL_WRITE);
 		prop = sym_get_choice_prop(sym);
-		for (e = prop->dep; e; e = e->left.expr) {
+		for (e = prop->expr; e; e = e->left.expr) {
 			e->right.sym->flags |= flags;
 			if (flags & SYMBOL_CHANGED)
 				sym_set_changed(e->right.sym);
 		}
 	}
 }
 
 void sym_clear_all_valid(void)
 {
 	struct symbol *sym;
 	int i;
 
 	for_all_symbols(i, sym)
 		sym->flags &= ~SYMBOL_VALID;
 	sym_change_count++;
 }
 
 void sym_set_changed(struct symbol *sym)
 {
 	struct property *prop;
 
 	sym->flags |= SYMBOL_CHANGED;
 	for (prop = sym->prop; prop; prop = prop->next) {
 		if (prop->menu)
 			prop->menu->flags |= MENU_CHANGED;
 	}
 }
 
 void sym_set_all_changed(void)
 {
 	struct symbol *sym;
 	int i;
 
 	for_all_symbols(i, sym)
 		sym_set_changed(sym);
 }
 
 bool sym_tristate_within_range(struct symbol *sym, tristate val)
 {
 	int type = sym_get_type(sym);
 
 	if (sym->visible == no)
 		return false;
 
 	if (type != S_BOOLEAN && type != S_TRISTATE)
 		return false;
 
-	switch (val) {
-	case no:
-		if (sym_is_choice_value(sym) && sym->visible == yes)
-			return false;
-		return sym_is_optional(sym);
-	case mod:
-		if (sym_is_choice_value(sym) && sym->visible == yes)
-			return false;
-		return type == S_TRISTATE;
-	case yes:
-		return type == S_BOOLEAN || sym->visible == yes;
-	}
-	return false;
+	if (type == S_BOOLEAN && val == mod)
+		return false;
+	if (sym->visible <= sym->rev_dep.tri)
+		return false;
+	if (sym_is_choice_value(sym) && sym->visible == yes)
+		return val == yes;
+	return val >= sym->rev_dep.tri && val <= sym->visible;
 }
 
 bool sym_set_tristate_value(struct symbol *sym, tristate val)
 {
 	tristate oldval = sym_get_tristate_value(sym);
 
 	if (oldval != val && !sym_tristate_within_range(sym, val))
 		return false;
 
 	if (sym->flags & SYMBOL_NEW) {
 		sym->flags &= ~SYMBOL_NEW;
 		sym_set_changed(sym);
 	}
 	if (sym_is_choice_value(sym) && val == yes) {
-		struct property *prop = sym_get_choice_prop(sym);
+		struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
 
-		S_VAL(prop->def->def) = sym;
-		prop->def->flags &= ~SYMBOL_NEW;
+		cs->user.val = sym;
+		cs->flags &= ~SYMBOL_NEW;
 	}
 
-	S_TRI(sym->def) = val;
+	sym->user.tri = val;
 	if (oldval != val) {
 		sym_clear_all_valid();
 		if (sym == modules_sym)
 			sym_set_all_changed();
 	}
 
 	return true;
 }
 
 tristate sym_toggle_tristate_value(struct symbol *sym)
 {
 	tristate oldval, newval;
 
 	oldval = newval = sym_get_tristate_value(sym);
 	do {
 		switch (newval) {
 		case no:
 			newval = mod;
 			break;
 		case mod:
 			newval = yes;
 			break;
 		case yes:
 			newval = no;
 			break;
 		}
 		if (sym_set_tristate_value(sym, newval))
 			break;
 	} while (oldval != newval);
 	return newval;
 }
 
 bool sym_string_valid(struct symbol *sym, const char *str)
 {
 	char ch;
 
 	switch (sym->type) {
 	case S_STRING:
 		return true;
 	case S_INT:
 		ch = *str++;
 		if (ch == '-')
 			ch = *str++;
 		if (!isdigit(ch))
 			return false;
 		if (ch == '0' && *str != 0)
 			return false;
 		while ((ch = *str++)) {
 			if (!isdigit(ch))
 				return false;
 		}
 		return true;
 	case S_HEX:
 		if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
 			str += 2;
 		ch = *str++;
 		do {
 			if (!isxdigit(ch))
 				return false;
 		} while ((ch = *str++));
 		return true;
 	case S_BOOLEAN:
 	case S_TRISTATE:
 		switch (str[0]) {
-		case 'y':
-		case 'Y':
+		case 'y': case 'Y':
+		case 'm': case 'M':
+		case 'n': case 'N':
+			return true;
+		}
+		return false;
+	default:
+		return false;
+	}
+}
+
+bool sym_string_within_range(struct symbol *sym, const char *str)
+{
+	struct property *prop;
+	int val;
+
+	switch (sym->type) {
+	case S_STRING:
+		return sym_string_valid(sym, str);
+	case S_INT:
+		if (!sym_string_valid(sym, str))
+			return false;
+		prop = sym_get_range_prop(sym);
+		if (!prop)
+			return true;
+		val = strtol(str, NULL, 10);
+		return val >= strtol(prop->expr->left.sym->name, NULL, 10) &&
+		       val <= strtol(prop->expr->right.sym->name, NULL, 10);
+	case S_HEX:
+		if (!sym_string_valid(sym, str))
+			return false;
+		prop = sym_get_range_prop(sym);
+		if (!prop)
+			return true;
+		val = strtol(str, NULL, 16);
+		return val >= strtol(prop->expr->left.sym->name, NULL, 16) &&
+		       val <= strtol(prop->expr->right.sym->name, NULL, 16);
+	case S_BOOLEAN:
+	case S_TRISTATE:
+		switch (str[0]) {
+		case 'y': case 'Y':
 			return sym_tristate_within_range(sym, yes);
-		case 'm':
-		case 'M':
+		case 'm': case 'M':
 			return sym_tristate_within_range(sym, mod);
-		case 'n':
-		case 'N':
+		case 'n': case 'N':
 			return sym_tristate_within_range(sym, no);
 		}
 		return false;
 	default:
 		return false;
 	}
 }
 
 bool sym_set_string_value(struct symbol *sym, const char *newval)
 {
 	const char *oldval;
 	char *val;
 	int size;
 
 	switch (sym->type) {
 	case S_BOOLEAN:
 	case S_TRISTATE:
 		switch (newval[0]) {
-		case 'y':
-		case 'Y':
+		case 'y': case 'Y':
 			return sym_set_tristate_value(sym, yes);
-		case 'm':
-		case 'M':
+		case 'm': case 'M':
 			return sym_set_tristate_value(sym, mod);
-		case 'n':
-		case 'N':
+		case 'n': case 'N':
 			return sym_set_tristate_value(sym, no);
 		}
 		return false;
 	default:
 		;
 	}
 
-	if (!sym_string_valid(sym, newval))
+	if (!sym_string_within_range(sym, newval))
 		return false;
 
 	if (sym->flags & SYMBOL_NEW) {
 		sym->flags &= ~SYMBOL_NEW;
 		sym_set_changed(sym);
 	}
 
-	oldval = S_VAL(sym->def);
+	oldval = sym->user.val;
 	size = strlen(newval) + 1;
 	if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) {
 		size += 2;
-		S_VAL(sym->def) = val = malloc(size);
+		sym->user.val = val = malloc(size);
 		*val++ = '0';
 		*val++ = 'x';
 	} else if (!oldval || strcmp(oldval, newval))
-		S_VAL(sym->def) = val = malloc(size);
+		sym->user.val = val = malloc(size);
 	else
 		return true;
 
 	strcpy(val, newval);
 	free((void *)oldval);
 	sym_clear_all_valid();
 
 	return true;
 }
 
 const char *sym_get_string_value(struct symbol *sym)
 {
 	tristate val;
 
 	switch (sym->type) {
 	case S_BOOLEAN:
 	case S_TRISTATE:
 		val = sym_get_tristate_value(sym);
 		switch (val) {
 		case no:
 			return "n";
 		case mod:
 			return "m";
 		case yes:
 			return "y";
 		}
 		break;
 	default:
 		;
 	}
-	return (const char *)S_VAL(sym->curr);
+	return (const char *)sym->curr.val;
 }
 
 bool sym_is_changable(struct symbol *sym)
 {
-	if (sym->visible == no)
-		return false;
-	/* at least 'n' and 'y'/'m' is selectable */
-	if (sym_is_optional(sym))
-		return true;
-	/* no 'n', so 'y' and 'm' must be selectable */
-	if (sym_get_type(sym) == S_TRISTATE && sym->visible == yes)
-		return true;
-	return false;
+	return sym->visible > sym->rev_dep.tri;
 }
 
 struct symbol *sym_lookup(const char *name, int isconst)
 {
 	struct symbol *symbol;
 	const char *ptr;
 	char *new_name;
 	int hash = 0;
 
 	if (name) {
 		if (name[0] && !name[1]) {
 			switch (name[0]) {
 			case 'y': return &symbol_yes;
 			case 'm': return &symbol_mod;
 			case 'n': return &symbol_no;
 			}
 		}
 		for (ptr = name; *ptr; ptr++)
 			hash += *ptr;
 		hash &= 0xff;
 
 		for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
 			if (!strcmp(symbol->name, name)) {
 				if ((isconst && symbol->flags & SYMBOL_CONST) ||
 				    (!isconst && !(symbol->flags & SYMBOL_CONST)))
 					return symbol;
 			}
 		}
 		new_name = strdup(name);
 	} else {
 		new_name = NULL;
 		hash = 256;
 	}
 
 	symbol = malloc(sizeof(*symbol));
 	memset(symbol, 0, sizeof(*symbol));
 	symbol->name = new_name;
 	symbol->type = S_UNKNOWN;
 	symbol->flags = SYMBOL_NEW;
 	if (isconst)
 		symbol->flags |= SYMBOL_CONST;
 
 	symbol->next = symbol_hash[hash];
 	symbol_hash[hash] = symbol;
 
 	return symbol;
 }
 
 struct symbol *sym_find(const char *name)
 {
 	struct symbol *symbol = NULL;
 	const char *ptr;
 	int hash = 0;
 
 	if (!name)
 		return NULL;
 
 	if (name[0] && !name[1]) {
 		switch (name[0]) {
 		case 'y': return &symbol_yes;
 		case 'm': return &symbol_mod;
 		case 'n': return &symbol_no;
 		}
 	}
 	for (ptr = name; *ptr; ptr++)
 		hash += *ptr;
 	hash &= 0xff;
 
 	for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
 		if (!strcmp(symbol->name, name) &&
 		    !(symbol->flags & SYMBOL_CONST))
 				break;
 	}
 
 	return symbol;
 }
 
+struct symbol *sym_check_deps(struct symbol *sym);
+
+static struct symbol *sym_check_expr_deps(struct expr *e)
+{
+	struct symbol *sym;
+
+	if (!e)
+		return NULL;
+	switch (e->type) {
+	case E_OR:
+	case E_AND:
+		sym = sym_check_expr_deps(e->left.expr);
+		if (sym)
+			return sym;
+		return sym_check_expr_deps(e->right.expr);
+	case E_NOT:
+		return sym_check_expr_deps(e->left.expr);
+	case E_EQUAL:
+	case E_UNEQUAL:
+		sym = sym_check_deps(e->left.sym);
+		if (sym)
+			return sym;
+		return sym_check_deps(e->right.sym);
+	case E_SYMBOL:
+		return sym_check_deps(e->left.sym);
+	default:
+		break;
+	}
+	printf("Oops! How to check %d?\n", e->type);
+	return NULL;
+}
+
+struct symbol *sym_check_deps(struct symbol *sym)
+{
+	struct symbol *sym2;
+	struct property *prop;
+
+	if (sym->flags & SYMBOL_CHECK_DONE)
+		return NULL;
+	if (sym->flags & SYMBOL_CHECK) {
+		printf("Warning! Found recursive dependency: %s", sym->name);
+		return sym;
+	}
+
+	sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
+	sym2 = sym_check_expr_deps(sym->rev_dep.expr);
+	if (sym2)
+		goto out;
+
+	for (prop = sym->prop; prop; prop = prop->next) {
+		if (prop->type == P_CHOICE)
+			continue;
+		sym2 = sym_check_expr_deps(prop->visible.expr);
+		if (sym2)
+			goto out;
+		if (prop->type != P_DEFAULT || sym_is_choice(sym))
+			continue;
+		sym2 = sym_check_expr_deps(prop->expr);
+		if (sym2)
+			goto out;
+	}
+out:
+	if (sym2)
+		printf(" %s", sym->name);
+	sym->flags &= ~SYMBOL_CHECK;
+	return sym2;
+}
+
+struct property *prop_alloc(enum prop_type type, struct symbol *sym)
+{
+	struct property *prop;
+	struct property **propp;
+
+	prop = malloc(sizeof(*prop));
+	memset(prop, 0, sizeof(*prop));
+	prop->type = type;
+	prop->sym = sym;
+	prop->file = current_file;
+	prop->lineno = zconf_lineno();
+
+	/* append property to the prop list of symbol */
+	if (sym) {
+		for (propp = &sym->prop; *propp; propp = &(*propp)->next)
+			;
+		*propp = prop;
+	}
+
+	return prop;
+}
+
+struct symbol *prop_get_symbol(struct property *prop)
+{
+	if (prop->expr && (prop->expr->type == E_SYMBOL ||
+			   prop->expr->type == E_CHOICE))
+		return prop->expr->left.sym;
+	return NULL;
+}
+
 const char *prop_get_type_name(enum prop_type type)
 {
 	switch (type) {
 	case P_PROMPT:
 		return "prompt";
 	case P_COMMENT:
 		return "comment";
 	case P_MENU:
 		return "menu";
-	case P_ROOTMENU:
-		return "rootmenu";
 	case P_DEFAULT:
 		return "default";
 	case P_CHOICE:
 		return "choice";
-	default:
-		return "unknown";
+	case P_SELECT:
+		return "select";
+	case P_RANGE:
+		return "range";
+	case P_UNKNOWN:
+		break;
 	}
+	return "unknown";
 }
diff --git a/scripts/kconfig/zconf.l b/scripts/kconfig/zconf.l
index 1471630..55517b2 100644
--- a/scripts/kconfig/zconf.l
+++ b/scripts/kconfig/zconf.l
@@ -1,359 +1,366 @@
 %option backup nostdinit noyywrap never-interactive full ecs
 %option 8bit backup nodefault perf-report perf-report
 %x COMMAND HELP STRING PARAM
 %{
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 
 #define START_STRSIZE	16
 
 char *text;
 static char *text_ptr;
 static int text_size, text_asize;
 
 struct buffer {
         struct buffer *parent;
         YY_BUFFER_STATE state;
 };
 
 struct buffer *current_buf;
 
 static int last_ts, first_ts;
 
 static void zconf_endhelp(void);
 static struct buffer *zconf_endfile(void);
 
 void new_string(void)
 {
 	text = malloc(START_STRSIZE);
 	text_asize = START_STRSIZE;
 	text_ptr = text;
 	text_size = 0;
 	*text_ptr = 0;
 }
 
 void append_string(const char *str, int size)
 {
 	int new_size = text_size + size + 1;
 	if (new_size > text_asize) {
 		text = realloc(text, new_size);
 		text_asize = new_size;
 		text_ptr = text + text_size;
 	}
 	memcpy(text_ptr, str, size);
 	text_ptr += size;
 	text_size += size;
 	*text_ptr = 0;
 }
 
 void alloc_string(const char *str, int size)
 {
 	text = malloc(size + 1);
 	memcpy(text, str, size);
 	text[size] = 0;
 }
 %}
 
 ws	[ \n\t]
 n	[A-Za-z0-9_]
 
 %%
 	int str = 0;
 	int ts, i;
 
 [ \t]*#.*\n	current_file->lineno++;
 [ \t]*#.*
 
 [ \t]*\n	current_file->lineno++; return T_EOL;
 
 [ \t]+	{
 	BEGIN(COMMAND);
 }
 
 .	{
 	unput(yytext[0]);
 	BEGIN(COMMAND);
 }
 
 
 <COMMAND>{
 	"mainmenu"		BEGIN(PARAM); return T_MAINMENU;
 	"menu"			BEGIN(PARAM); return T_MENU;
 	"endmenu"		BEGIN(PARAM); return T_ENDMENU;
 	"source"		BEGIN(PARAM); return T_SOURCE;
 	"choice"		BEGIN(PARAM); return T_CHOICE;
 	"endchoice"		BEGIN(PARAM); return T_ENDCHOICE;
 	"comment"		BEGIN(PARAM); return T_COMMENT;
 	"config"		BEGIN(PARAM); return T_CONFIG;
+	"menuconfig"		BEGIN(PARAM); return T_MENUCONFIG;
 	"help"			BEGIN(PARAM); return T_HELP;
 	"if"			BEGIN(PARAM); return T_IF;
 	"endif"			BEGIN(PARAM); return T_ENDIF;
 	"depends"		BEGIN(PARAM); return T_DEPENDS;
 	"requires"		BEGIN(PARAM); return T_REQUIRES;
 	"optional"		BEGIN(PARAM); return T_OPTIONAL;
 	"default"		BEGIN(PARAM); return T_DEFAULT;
 	"prompt"		BEGIN(PARAM); return T_PROMPT;
 	"tristate"		BEGIN(PARAM); return T_TRISTATE;
+	"def_tristate"		BEGIN(PARAM); return T_DEF_TRISTATE;
 	"bool"			BEGIN(PARAM); return T_BOOLEAN;
 	"boolean"		BEGIN(PARAM); return T_BOOLEAN;
+	"def_bool"		BEGIN(PARAM); return T_DEF_BOOLEAN;
+	"def_boolean"		BEGIN(PARAM); return T_DEF_BOOLEAN;
 	"int"			BEGIN(PARAM); return T_INT;
 	"hex"			BEGIN(PARAM); return T_HEX;
 	"string"		BEGIN(PARAM); return T_STRING;
+	"select"		BEGIN(PARAM); return T_SELECT;
+	"enable"		BEGIN(PARAM); return T_SELECT;
+	"range"			BEGIN(PARAM); return T_RANGE;
 	{n}+	{
 		alloc_string(yytext, yyleng);
 		zconflval.string = text;
 		return T_WORD;
 	}
 	.
 	\n	current_file->lineno++; BEGIN(INITIAL);
 }
 
 <PARAM>{
 	"&&"	return T_AND;
 	"||"	return T_OR;
 	"("	return T_OPEN_PAREN;
 	")"	return T_CLOSE_PAREN;
 	"!"	return T_NOT;
 	"="	return T_EQUAL;
 	"!="	return T_UNEQUAL;
 	"if"	return T_IF;
 	"on"	return T_ON;
 	\"|\'	{
 		str = yytext[0];
 		new_string();
 		BEGIN(STRING);
 	}
 	\n	BEGIN(INITIAL); current_file->lineno++; return T_EOL;
 	---	/* ignore */
 	({n}|[-/.])+	{
 		alloc_string(yytext, yyleng);
 		zconflval.string = text;
 		return T_WORD;
 	}
+	#.*	/* comment */
 	\\\n	current_file->lineno++;
 	.
 	<<EOF>> {
 		BEGIN(INITIAL);
 	}
 }
 
 <STRING>{
 	[^'"\\\n]+/\n	{
 		append_string(yytext, yyleng);
 		zconflval.string = text;
-		return T_STRING;
+		return T_WORD_QUOTE;
 	}
 	[^'"\\\n]+	{
 		append_string(yytext, yyleng);
 	}
 	\\.?/\n	{
 		append_string(yytext + 1, yyleng - 1);
 		zconflval.string = text;
-		return T_STRING;
+		return T_WORD_QUOTE;
 	}
 	\\.?	{
 		append_string(yytext + 1, yyleng - 1);
 	}
 	\'|\"	{
 		if (str == yytext[0]) {
 			BEGIN(PARAM);
 			zconflval.string = text;
-			return T_STRING;
+			return T_WORD_QUOTE;
 		} else
 			append_string(yytext, 1);
 	}
 	\n	{
 		printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
 		current_file->lineno++;
 		BEGIN(INITIAL);
 		return T_EOL;
 	}
 	<<EOF>>	{
 		BEGIN(INITIAL);
 	}
 }
 
 <HELP>{
 	[ \t]+	{
 		ts = 0;
 		for (i = 0; i < yyleng; i++) {
 			if (yytext[i] == '\t')
 				ts = (ts & ~7) + 8;
 			else
 				ts++;
 		}
 		last_ts = ts;
 		if (first_ts) {
 			if (ts < first_ts) {
 				zconf_endhelp();
 				return T_HELPTEXT;
 			}
 			ts -= first_ts;
 			while (ts > 8) {
 				append_string("        ", 8);
 				ts -= 8;
 			}
 			append_string("        ", ts);
 		}
-		
 	}
-	\n/[^ \t\n] {
+	[ \t]*\n/[^ \t\n] {
 		current_file->lineno++;
 		zconf_endhelp();
 		return T_HELPTEXT;
 	}
 	[ \t]*\n	{
 		current_file->lineno++;
 		append_string("\n", 1);
 	}
 	[^ \t\n].* {
 		append_string(yytext, yyleng);
 		if (!first_ts)
 			first_ts = last_ts;
 	}
 	<<EOF>>	{
 		zconf_endhelp();
 		return T_HELPTEXT;
 	}
 }
 
 <<EOF>>	{
 	if (current_buf) {
 		zconf_endfile();
 		return T_EOF;
 	}
 	fclose(yyin);
 	yyterminate();
 }
 
 %%
 void zconf_starthelp(void)
 {
 	new_string();
 	last_ts = first_ts = 0;
 	BEGIN(HELP);
 }
 
 static void zconf_endhelp(void)
 {
 	zconflval.string = text;
-	BEGIN(INITIAL); 
+	BEGIN(INITIAL);
 }
 
 
-/* 
+/*
  * Try to open specified file with following names:
  * ./name
  * $(srctree)/name
  * The latter is used when srctree is separate from objtree
  * when compiling the kernel.
  * Return NULL if file is not found.
  */
 FILE *zconf_fopen(const char *name)
 {
 	char *env, fullname[PATH_MAX+1];
 	FILE *f;
 
 	f = fopen(name, "r");
 	if (!f && name[0] != '/') {
 		env = getenv(SRCTREE);
 		if (env) {
 			sprintf(fullname, "%s/%s", env, name);
 			f = fopen(fullname, "r");
 		}
 	}
 	return f;
 }
 
 void zconf_initscan(const char *name)
 {
 	yyin = zconf_fopen(name);
 	if (!yyin) {
 		printf("can't find file %s\n", name);
 		exit(1);
 	}
 
 	current_buf = malloc(sizeof(*current_buf));
 	memset(current_buf, 0, sizeof(*current_buf));
 
 	current_file = file_lookup(name);
 	current_file->lineno = 1;
 	current_file->flags = FILE_BUSY;
 }
 
 void zconf_nextfile(const char *name)
 {
 	struct file *file = file_lookup(name);
 	struct buffer *buf = malloc(sizeof(*buf));
 	memset(buf, 0, sizeof(*buf));
 
 	current_buf->state = YY_CURRENT_BUFFER;
 	yyin = zconf_fopen(name);
 	if (!yyin) {
 		printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
 		exit(1);
 	}
 	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
 	buf->parent = current_buf;
 	current_buf = buf;
 
 	if (file->flags & FILE_BUSY) {
 		printf("recursive scan (%s)?\n", name);
 		exit(1);
 	}
 	if (file->flags & FILE_SCANNED) {
 		printf("file %s already scanned?\n", name);
 		exit(1);
 	}
 	file->flags |= FILE_BUSY;
 	file->lineno = 1;
 	file->parent = current_file;
 	current_file = file;
 }
 
 static struct buffer *zconf_endfile(void)
 {
 	struct buffer *parent;
 
 	current_file->flags |= FILE_SCANNED;
 	current_file->flags &= ~FILE_BUSY;
 	current_file = current_file->parent;
 
 	parent = current_buf->parent;
 	if (parent) {
 		fclose(yyin);
 		yy_delete_buffer(YY_CURRENT_BUFFER);
 		yy_switch_to_buffer(parent->state);
 	}
 	free(current_buf);
 	current_buf = parent;
 
 	return parent;
 }
 
 int zconf_lineno(void)
 {
 	if (current_buf)
-		return current_file->lineno;
+		return current_file->lineno - 1;
 	else
 		return 0;
 }
 
 char *zconf_curname(void)
 {
 	if (current_buf)
 		return current_file->name;
 	else
 		return "<none>";
 }
diff --git a/scripts/kconfig/zconf.y b/scripts/kconfig/zconf.y
index 996b10a..2468068 100644
--- a/scripts/kconfig/zconf.y
+++ b/scripts/kconfig/zconf.y
@@ -1,649 +1,687 @@
 %{
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <ctype.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
 
 #define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
 
 #define PRINTD		0x0001
 #define DEBUG_PARSE	0x0002
 
 int cdebug = PRINTD;
 
 extern int zconflex(void);
 static void zconfprint(const char *err, ...);
 static void zconferror(const char *err);
 static bool zconf_endtoken(int token, int starttoken, int endtoken);
 
 struct symbol *symbol_hash[257];
 
 #define YYERROR_VERBOSE
 %}
-%expect 36
+%expect 40
 
 %union
 {
 	int token;
 	char *string;
 	struct symbol *symbol;
 	struct expr *expr;
 	struct menu *menu;
 }
 
 %token T_MAINMENU
 %token T_MENU
 %token T_ENDMENU
 %token T_SOURCE
 %token T_CHOICE
 %token T_ENDCHOICE
 %token T_COMMENT
 %token T_CONFIG
+%token T_MENUCONFIG
 %token T_HELP
 %token <string> T_HELPTEXT
 %token T_IF
 %token T_ENDIF
 %token T_DEPENDS
 %token T_REQUIRES
 %token T_OPTIONAL
 %token T_PROMPT
 %token T_DEFAULT
 %token T_TRISTATE
+%token T_DEF_TRISTATE
 %token T_BOOLEAN
+%token T_DEF_BOOLEAN
+%token T_STRING
 %token T_INT
 %token T_HEX
 %token <string> T_WORD
-%token <string> T_STRING
+%token <string> T_WORD_QUOTE
 %token T_UNEQUAL
 %token T_EOF
 %token T_EOL
 %token T_CLOSE_PAREN
 %token T_OPEN_PAREN
 %token T_ON
+%token T_SELECT
+%token T_RANGE
 
 %left T_OR
 %left T_AND
 %left T_EQUAL T_UNEQUAL
 %nonassoc T_NOT
 
 %type <string> prompt
 %type <string> source
 %type <symbol> symbol
 %type <expr> expr
 %type <expr> if_expr
 %type <token> end
 
 %{
 #define LKC_DIRECT_LINK
 #include "lkc.h"
 %}
 %%
 input:	  /* empty */
 	| input block
 ;
 
 block:	  common_block
 	| choice_stmt
 	| menu_stmt
 	| T_MAINMENU prompt nl_or_eof
 	| T_ENDMENU		{ zconfprint("unexpected 'endmenu' statement"); }
 	| T_ENDIF		{ zconfprint("unexpected 'endif' statement"); }
 	| T_ENDCHOICE		{ zconfprint("unexpected 'endchoice' statement"); }
 	| error nl_or_eof	{ zconfprint("syntax error"); yyerrok; }
 ;
 
 common_block:
 	  if_stmt
 	| comment_stmt
 	| config_stmt
+	| menuconfig_stmt
 	| source_stmt
 	| nl_or_eof
 ;
 
 
-/* config entry */
+/* config/menuconfig entry */
 
-config_entry_start: T_CONFIG T_WORD
+config_entry_start: T_CONFIG T_WORD T_EOL
 {
 	struct symbol *sym = sym_lookup($2, 0);
 	sym->flags |= SYMBOL_OPTIONAL;
 	menu_add_entry(sym);
 	printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), $2);
 };
 
-config_stmt: config_entry_start T_EOL config_option_list
+config_stmt: config_entry_start config_option_list
 {
 	menu_end_entry();
 	printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
 };
 
+menuconfig_entry_start: T_MENUCONFIG T_WORD T_EOL
+{
+	struct symbol *sym = sym_lookup($2, 0);
+	sym->flags |= SYMBOL_OPTIONAL;
+	menu_add_entry(sym);
+	printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), $2);
+};
+
+menuconfig_stmt: menuconfig_entry_start config_option_list
+{
+	if (current_entry->prompt)
+		current_entry->prompt->type = P_MENU;
+	else
+		zconfprint("warning: menuconfig statement without prompt");
+	menu_end_entry();
+	printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
+};
+
 config_option_list:
 	  /* empty */
-	| config_option_list config_option T_EOL
-	| config_option_list depends T_EOL
+	| config_option_list config_option
+	| config_option_list depends
 	| config_option_list help
 	| config_option_list T_EOL
-{ };
+;
 
-config_option: T_TRISTATE prompt_stmt_opt
+config_option: T_TRISTATE prompt_stmt_opt T_EOL
 {
 	menu_set_type(S_TRISTATE);
 	printd(DEBUG_PARSE, "%s:%d:tristate\n", zconf_curname(), zconf_lineno());
 };
 
-config_option: T_BOOLEAN prompt_stmt_opt
+config_option: T_DEF_TRISTATE expr if_expr T_EOL
+{
+	menu_add_expr(P_DEFAULT, $2, $3);
+	menu_set_type(S_TRISTATE);
+	printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno());
+};
+
+config_option: T_BOOLEAN prompt_stmt_opt T_EOL
 {
 	menu_set_type(S_BOOLEAN);
 	printd(DEBUG_PARSE, "%s:%d:boolean\n", zconf_curname(), zconf_lineno());
 };
 
-config_option: T_INT prompt_stmt_opt
+config_option: T_DEF_BOOLEAN expr if_expr T_EOL
+{
+	menu_add_expr(P_DEFAULT, $2, $3);
+	menu_set_type(S_BOOLEAN);
+	printd(DEBUG_PARSE, "%s:%d:def_boolean\n", zconf_curname(), zconf_lineno());
+};
+
+config_option: T_INT prompt_stmt_opt T_EOL
 {
 	menu_set_type(S_INT);
 	printd(DEBUG_PARSE, "%s:%d:int\n", zconf_curname(), zconf_lineno());
 };
 
-config_option: T_HEX prompt_stmt_opt
+config_option: T_HEX prompt_stmt_opt T_EOL
 {
 	menu_set_type(S_HEX);
 	printd(DEBUG_PARSE, "%s:%d:hex\n", zconf_curname(), zconf_lineno());
 };
 
-config_option: T_STRING prompt_stmt_opt
+config_option: T_STRING prompt_stmt_opt T_EOL
 {
 	menu_set_type(S_STRING);
 	printd(DEBUG_PARSE, "%s:%d:string\n", zconf_curname(), zconf_lineno());
 };
 
-config_option: T_PROMPT prompt if_expr
+config_option: T_PROMPT prompt if_expr T_EOL
 {
-	menu_add_prop(P_PROMPT, $2, NULL, $3);
+	menu_add_prompt(P_PROMPT, $2, $3);
 	printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
 };
 
-config_option: T_DEFAULT symbol if_expr
+config_option: T_DEFAULT expr if_expr T_EOL
 {
-	menu_add_prop(P_DEFAULT, NULL, $2, $3);
+	menu_add_expr(P_DEFAULT, $2, $3);
 	printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno());
 };
 
+config_option: T_SELECT T_WORD if_expr T_EOL
+{
+	menu_add_symbol(P_SELECT, sym_lookup($2, 0), $3);
+	printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
+};
+
+config_option: T_RANGE symbol symbol if_expr T_EOL
+{
+	menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,$2, $3), $4);
+	printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
+};
+
 /* choice entry */
 
-choice: T_CHOICE
+choice: T_CHOICE T_EOL
 {
 	struct symbol *sym = sym_lookup(NULL, 0);
 	sym->flags |= SYMBOL_CHOICE;
 	menu_add_entry(sym);
-	menu_add_prop(P_CHOICE, NULL, NULL, NULL);
+	menu_add_expr(P_CHOICE, NULL, NULL);
 	printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
 };
 
-choice_entry: choice T_EOL choice_option_list
+choice_entry: choice choice_option_list
 {
 	menu_end_entry();
 	menu_add_menu();
 };
 
 choice_end: end
 {
 	if (zconf_endtoken($1, T_CHOICE, T_ENDCHOICE)) {
 		menu_end_menu();
 		printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
 	}
 };
 
 choice_stmt:
-	  choice_entry choice_block choice_end T_EOL
+	  choice_entry choice_block choice_end
 	| choice_entry choice_block
 {
 	printf("%s:%d: missing 'endchoice' for this 'choice' statement\n", current_menu->file->name, current_menu->lineno);
 	zconfnerrs++;
 };
 
 choice_option_list:
 	  /* empty */
-	| choice_option_list choice_option T_EOL
-	| choice_option_list depends T_EOL
+	| choice_option_list choice_option
+	| choice_option_list depends
 	| choice_option_list help
 	| choice_option_list T_EOL
 ;
 
-choice_option: T_PROMPT prompt if_expr
+choice_option: T_PROMPT prompt if_expr T_EOL
 {
-	menu_add_prop(P_PROMPT, $2, NULL, $3);
+	menu_add_prompt(P_PROMPT, $2, $3);
 	printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
 };
 
-choice_option: T_OPTIONAL
+choice_option: T_TRISTATE prompt_stmt_opt T_EOL
+{
+	menu_set_type(S_TRISTATE);
+	printd(DEBUG_PARSE, "%s:%d:tristate\n", zconf_curname(), zconf_lineno());
+};
+
+choice_option: T_BOOLEAN prompt_stmt_opt T_EOL
+{
+	menu_set_type(S_BOOLEAN);
+	printd(DEBUG_PARSE, "%s:%d:boolean\n", zconf_curname(), zconf_lineno());
+};
+
+choice_option: T_OPTIONAL T_EOL
 {
 	current_entry->sym->flags |= SYMBOL_OPTIONAL;
 	printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
 };
 
-choice_option: T_DEFAULT symbol if_expr
+choice_option: T_DEFAULT T_WORD if_expr T_EOL
 {
-	menu_add_prop(P_DEFAULT, NULL, $2, $3);
+	menu_add_symbol(P_DEFAULT, sym_lookup($2, 0), $3);
 	printd(DEBUG_PARSE, "%s:%d:default\n", zconf_curname(), zconf_lineno());
 };
 
 choice_block:
 	  /* empty */
 	| choice_block common_block
 ;
 
 /* if entry */
 
-if: T_IF expr
+if: T_IF expr T_EOL
 {
 	printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
 	menu_add_entry(NULL);
 	menu_add_dep($2);
 	menu_end_entry();
 	menu_add_menu();
 };
 
 if_end: end
 {
 	if (zconf_endtoken($1, T_IF, T_ENDIF)) {
 		menu_end_menu();
 		printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
 	}
 };
 
 if_stmt:
-	  if T_EOL if_block if_end T_EOL
-	| if T_EOL if_block
+	  if if_block if_end
+	| if if_block
 {
 	printf("%s:%d: missing 'endif' for this 'if' statement\n", current_menu->file->name, current_menu->lineno);
 	zconfnerrs++;
 };
 
 if_block:
 	  /* empty */
 	| if_block common_block
 	| if_block menu_stmt
 	| if_block choice_stmt
 ;
 
 /* menu entry */
 
-menu: T_MENU prompt
+menu: T_MENU prompt T_EOL
 {
 	menu_add_entry(NULL);
 	menu_add_prop(P_MENU, $2, NULL, NULL);
 	printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
 };
 
-menu_entry: menu T_EOL depends_list
+menu_entry: menu depends_list
 {
 	menu_end_entry();
 	menu_add_menu();
 };
 
 menu_end: end
 {
 	if (zconf_endtoken($1, T_MENU, T_ENDMENU)) {
 		menu_end_menu();
 		printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
 	}
 };
 
 menu_stmt:
-	  menu_entry menu_block menu_end T_EOL
+	  menu_entry menu_block menu_end
 	| menu_entry menu_block
 {
 	printf("%s:%d: missing 'endmenu' for this 'menu' statement\n", current_menu->file->name, current_menu->lineno);
 	zconfnerrs++;
 };
 
 menu_block:
 	  /* empty */
 	| menu_block common_block
 	| menu_block menu_stmt
 	| menu_block choice_stmt
 	| menu_block error T_EOL		{ zconfprint("invalid menu option"); yyerrok; }
 ;
 
-source: T_SOURCE prompt
+source: T_SOURCE prompt T_EOL
 {
 	$$ = $2;
 	printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), $2);
 };
 
-source_stmt: source T_EOL
+source_stmt: source
 {
 	zconf_nextfile($1);
 };
 
 /* comment entry */
 
-comment: T_COMMENT prompt
+comment: T_COMMENT prompt T_EOL
 {
 	menu_add_entry(NULL);
 	menu_add_prop(P_COMMENT, $2, NULL, NULL);
 	printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
 };
 
-comment_stmt: comment T_EOL depends_list
+comment_stmt: comment depends_list
 {
 	menu_end_entry();
 };
 
 /* help option */
 
 help_start: T_HELP T_EOL
 {
 	printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
 	zconf_starthelp();
 };
 
 help: help_start T_HELPTEXT
 {
 	current_entry->sym->help = $2;
 };
 
 /* depends option */
 
 depends_list:	  /* empty */
-		| depends_list depends T_EOL
+		| depends_list depends
 		| depends_list T_EOL
-{ };
+;
 
-depends: T_DEPENDS T_ON expr
+depends: T_DEPENDS T_ON expr T_EOL
 {
 	menu_add_dep($3);
 	printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
 }
-	| T_DEPENDS expr
+	| T_DEPENDS expr T_EOL
 {
 	menu_add_dep($2);
 	printd(DEBUG_PARSE, "%s:%d:depends\n", zconf_curname(), zconf_lineno());
 }
-	| T_REQUIRES expr
+	| T_REQUIRES expr T_EOL
 {
 	menu_add_dep($2);
 	printd(DEBUG_PARSE, "%s:%d:requires\n", zconf_curname(), zconf_lineno());
 };
 
 /* prompt statement */
 
 prompt_stmt_opt:
 	  /* empty */
-	| prompt
-{
-	menu_add_prop(P_PROMPT, $1, NULL, NULL);
-}
-	| prompt T_IF expr
+	| prompt if_expr
 {
-	menu_add_prop(P_PROMPT, $1, NULL, $3);
+	menu_add_prop(P_PROMPT, $1, NULL, $2);
 };
 
 prompt:	  T_WORD
-	| T_STRING
+	| T_WORD_QUOTE
 ;
 
-end:	  T_ENDMENU		{ $$ = T_ENDMENU; }
-	| T_ENDCHOICE		{ $$ = T_ENDCHOICE; }
-	| T_ENDIF		{ $$ = T_ENDIF; }
+end:	  T_ENDMENU nl_or_eof	{ $$ = T_ENDMENU; }
+	| T_ENDCHOICE nl_or_eof	{ $$ = T_ENDCHOICE; }
+	| T_ENDIF nl_or_eof	{ $$ = T_ENDIF; }
 ;
 
 nl_or_eof:
 	T_EOL | T_EOF;
 
 if_expr:  /* empty */			{ $$ = NULL; }
 	| T_IF expr			{ $$ = $2; }
 ;
 
 expr:	  symbol				{ $$ = expr_alloc_symbol($1); }
 	| symbol T_EQUAL symbol			{ $$ = expr_alloc_comp(E_EQUAL, $1, $3); }
 	| symbol T_UNEQUAL symbol		{ $$ = expr_alloc_comp(E_UNEQUAL, $1, $3); }
 	| T_OPEN_PAREN expr T_CLOSE_PAREN	{ $$ = $2; }
 	| T_NOT expr				{ $$ = expr_alloc_one(E_NOT, $2); }
 	| expr T_OR expr			{ $$ = expr_alloc_two(E_OR, $1, $3); }
 	| expr T_AND expr			{ $$ = expr_alloc_two(E_AND, $1, $3); }
 ;
 
 symbol:	  T_WORD	{ $$ = sym_lookup($1, 0); free($1); }
-	| T_STRING	{ $$ = sym_lookup($1, 1); free($1); }
+	| T_WORD_QUOTE	{ $$ = sym_lookup($1, 1); free($1); }
 ;
 
 %%
 
 void conf_parse(const char *name)
 {
+	struct symbol *sym;
+	int i;
+
 	zconf_initscan(name);
 
 	sym_init();
 	menu_init();
-	rootmenu.prompt = menu_add_prop(P_MENU, "Configuration", NULL, NULL);
+	modules_sym = sym_lookup("MODULES", 0);
+	rootmenu.prompt = menu_add_prop(P_MENU, "Build Configuration", NULL, NULL);
 
 	//zconfdebug = 1;
 	zconfparse();
 	if (zconfnerrs)
 		exit(1);
 	menu_finalize(&rootmenu);
-
-	modules_sym = sym_lookup("MODULES", 0);
+	for_all_symbols(i, sym) {
+                if (!(sym->flags & SYMBOL_CHECKED) && sym_check_deps(sym))
+                        printf("\n");
+		else
+			sym->flags |= SYMBOL_CHECK_DONE;
+        }
 
 	sym_change_count = 1;
 }
 
 const char *zconf_tokenname(int token)
 {
 	switch (token) {
 	case T_MENU:		return "menu";
 	case T_ENDMENU:		return "endmenu";
 	case T_CHOICE:		return "choice";
 	case T_ENDCHOICE:	return "endchoice";
 	case T_IF:		return "if";
 	case T_ENDIF:		return "endif";
 	}
 	return "<token>";
-} 
+}
 
 static bool zconf_endtoken(int token, int starttoken, int endtoken)
 {
 	if (token != endtoken) {
 		zconfprint("unexpected '%s' within %s block", zconf_tokenname(token), zconf_tokenname(starttoken));
 		zconfnerrs++;
 		return false;
 	}
 	if (current_menu->file != current_file) {
 		zconfprint("'%s' in different file than '%s'", zconf_tokenname(token), zconf_tokenname(starttoken));
 		zconfprint("location of the '%s'", zconf_tokenname(starttoken));
 		zconfnerrs++;
 		return false;
 	}
 	return true;
 }
 
 static void zconfprint(const char *err, ...)
 {
 	va_list ap;
 
-	fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
+	fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno() + 1);
 	va_start(ap, err);
 	vfprintf(stderr, err, ap);
 	va_end(ap);
 	fprintf(stderr, "\n");
 }
 
 static void zconferror(const char *err)
 {
-	fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno(), err);
+	fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
 }
 
 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 = p + 1;
 	}
 	fputs(str, out);
 	putc('"', out);
 }
 
 void print_symbol(FILE *out, struct menu *menu)
 {
 	struct symbol *sym = menu->sym;
 	struct property *prop;
 
-	//sym->flags |= SYMBOL_PRINTED;
-
 	if (sym_is_choice(sym))
 		fprintf(out, "choice\n");
 	else
 		fprintf(out, "config %s\n", sym->name);
 	switch (sym->type) {
 	case S_BOOLEAN:
 		fputs("  boolean\n", out);
 		break;
 	case S_TRISTATE:
 		fputs("  tristate\n", out);
 		break;
 	case S_STRING:
 		fputs("  string\n", out);
 		break;
 	case S_INT:
 		fputs("  integer\n", out);
 		break;
 	case S_HEX:
 		fputs("  hex\n", out);
 		break;
 	default:
 		fputs("  ???\n", out);
 		break;
 	}
-#if 0
-	if (!expr_is_yes(sym->dep)) {
-		fputs("  depends ", out);
-		expr_fprint(sym->dep, out);
-		fputc('\n', out);
-	}
-#endif
 	for (prop = sym->prop; prop; prop = prop->next) {
 		if (prop->menu != menu)
 			continue;
 		switch (prop->type) {
 		case P_PROMPT:
 			fputs("  prompt ", out);
 			print_quoted_string(out, prop->text);
-			if (prop->def) {
-				fputc(' ', out);
-				if (prop->def->flags & SYMBOL_CONST)
-					print_quoted_string(out, prop->def->name);
-				else
-					fputs(prop->def->name, out);
-			}
-			if (!expr_is_yes(E_EXPR(prop->visible))) {
+			if (!expr_is_yes(prop->visible.expr)) {
 				fputs(" if ", out);
-				expr_fprint(E_EXPR(prop->visible), out);
+				expr_fprint(prop->visible.expr, out);
 			}
 			fputc('\n', out);
 			break;
 		case P_DEFAULT:
 			fputs( "  default ", out);
-			print_quoted_string(out, prop->def->name);
-			if (!expr_is_yes(E_EXPR(prop->visible))) {
+			expr_fprint(prop->expr, out);
+			if (!expr_is_yes(prop->visible.expr)) {
 				fputs(" if ", out);
-				expr_fprint(E_EXPR(prop->visible), out);
+				expr_fprint(prop->visible.expr, out);
 			}
 			fputc('\n', out);
 			break;
 		case P_CHOICE:
 			fputs("  #choice value\n", out);
 			break;
 		default:
 			fprintf(out, "  unknown prop %d!\n", prop->type);
 			break;
 		}
 	}
 	if (sym->help) {
 		int len = strlen(sym->help);
 		while (sym->help[--len] == '\n')
 			sym->help[len] = 0;
 		fprintf(out, "  help\n%s\n", sym->help);
 	}
 	fputc('\n', out);
 }
 
 void zconfdump(FILE *out)
 {
-	//struct file *file;
 	struct property *prop;
 	struct symbol *sym;
 	struct menu *menu;
 
 	menu = rootmenu.list;
 	while (menu) {
 		if ((sym = menu->sym))
 			print_symbol(out, menu);
 		else if ((prop = menu->prompt)) {
 			switch (prop->type) {
-			//case T_MAINMENU:
-			//	fputs("\nmainmenu ", out);
-			//	print_quoted_string(out, prop->text);
-			//	fputs("\n", out);
-			//	break;
 			case P_COMMENT:
 				fputs("\ncomment ", out);
 				print_quoted_string(out, prop->text);
 				fputs("\n", out);
 				break;
 			case P_MENU:
 				fputs("\nmenu ", out);
 				print_quoted_string(out, prop->text);
 				fputs("\n", out);
 				break;
-			//case T_SOURCE:
-			//	fputs("\nsource ", out);
-			//	print_quoted_string(out, prop->text);
-			//	fputs("\n", out);
-			//	break;
-			//case T_IF:
-			//	fputs("\nif\n", out);
 			default:
 				;
 			}
-			if (!expr_is_yes(E_EXPR(prop->visible))) {
+			if (!expr_is_yes(prop->visible.expr)) {
 				fputs("  depends ", out);
-				expr_fprint(E_EXPR(prop->visible), out);
+				expr_fprint(prop->visible.expr, out);
 				fputc('\n', out);
 			}
 			fputs("\n", out);
 		}
 
 		if (menu->list)
 			menu = menu->list;
 		else if (menu->next)
 			menu = menu->next;
 		else while ((menu = menu->parent)) {
 			if (menu->prompt && menu->prompt->type == P_MENU)
 				fputs("\nendmenu\n", out);
 			if (menu->next) {
 				menu = menu->next;
 				break;
 			}
 		}
 	}
 }
 
 #include "lex.zconf.c"
 #include "confdata.c"
 #include "expr.c"
 #include "symbol.c"
 #include "menu.c"