Update LinuxKernelConf to 1.3, latest available.

14 files changed, 542 insertions, 257 deletions

diff --git a/scripts/kconfig/Makefile b/scripts/kconfig/Makefile
index 7e257be..5a0d7e5 100644
--- a/scripts/kconfig/Makefile
+++ b/scripts/kconfig/Makefile
@@ -1,207 +1,181 @@
-VERSION=1.2
+VERSION=1.3
 CC=gcc
 CXX=g++
-CFLAGS=-O2 -Wall -g -fPIC
+CFLAGS=-O0 -Wall -g -fPIC
 CXXFLAGS=$(CFLAGS) -I$(HOSTQTDIR)/include
 LDFLAGS=
 LXXFLAGS=$(LDFLAGS) -L$(HOSTQTDIR)/lib -Wl,-rpath,$(HOSTQTDIR)/lib
 LEX=flex
+LFLAGS=-L
 YACC=bison
-YFLAGS=-d -t #-v
+YFLAGS=-l
+#YFLAGS=-d -t -v -l
 ifndef HOSTQTDIR
-ifeq ($(shell if [ -e /usr/share/qt ]; then echo foundit; fi),foundit)
 HOSTQTDIR=/usr/share/qt
-else
-ifeq ($(shell if [ -e /usr/lib/qt ]; then echo foundit; fi),foundit)
-HOSTQTDIR=/usr/lib/qt
-endif
-endif
-endif
-
-ifndef QTLIB
-ifeq ($(shell if [ -e $(HOSTQTDIR)/lib/libqt-mt.so ]; then echo foundit; fi),foundit)
-QTLIB=-lqt-mt
-else
-ifneq ($(shell if [ -e $(HOSTQTDIR)/lib/libqt.so ]; then echo foundit; fi),foundit)
-$(warning Unable to locate libqt.so!)
 endif
-QTLIB=-lqt
-endif
-endif
-
 MOC=$(wildcard $(HOSTQTDIR)/bin/moc)
 
 parse_SRC=zconf.y
 conf_SRC=conf.c $(parse_SRC)
 mconf_SRC=mconf.c $(parse_SRC)
 qconf_SRC=qconf.cc
-lkcc_SRC=cml1.y cml1.l help.l cml1.h expr1.c
 HDR=expr.h lkc.h lkc_proto.h qconf.h
-OTHER=README lkc_spec lkc_overview Makefile.kernel convert-all prepare-all.diff fixup-all.diff \
+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 $(parse_SRC) $(HDR)
-INSTGEN=lex.zconf.c zconf.tab.c zconf.tab.h
+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)
+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) $(lkcc_SRC)
+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))))))
-lkcc_OBJ=$(filter %.o, \
-                $(patsubst %.c,%.o, \
-                $(patsubst %.y,%.tab.o, \
-                $(patsubst %.l,lex.%.o, \
-                        $(lkcc_SRC)))))
-OBJ=$(conf_OBJ) $(mconf_OBJ) $(qconf_OBJ) $(lkcc_OBJ)
+OBJ=$(conf_OBJ) $(mconf_OBJ) $(qconf_OBJ)
 
 ifeq ($(MOC),)
-all: lkcc conf mconf
+all: conf mconf
 else
-all: lkcc conf mconf qconf libkconfig.so
+all: conf mconf qconf libkconfig.so
 endif
 
-lex.help.c: help.l
-lex.help.o: lex.help.c cml1.h expr.h
-lex.cml1.c: cml1.l
-lex.cml1.o: lex.cml1.c cml1.tab.h cml1.h expr.h
-cml1.tab.c: cml1.y
-cml1.tab.h: cml1.y
-cml1.tab.o: cml1.tab.c cml1.h expr.h
-expr1.o: expr1.c expr.h
-
 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)
 
 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 environment variable is set to the correct location.
         @false
 else
-qconf: $(qconf_OBJ) libkconfig.so
-        $(CXX) $(LXXFLAGS) $^ $(QTLIB) -o $@
+qconf: $(qconf_OBJ)
+        $(CXX) $(LXXFLAGS) $^ -lqt -o $@
 endif
 
-lkcc: $(lkcc_OBJ)
-        $(CC) $(LDFLAGS) $^ -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) lkcc conf qconf mconf *.moc lex.* *.tab.? *.output
+        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 -f lkc-$(VERSION).tar.gz 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 $@
 
 %.o: %.c
         $(CC) $(CFLAGS) -c $< -o $@
 
 %.o: %.cc
         $(CXX) $(CXXFLAGS) -c $< -o $@
 
 ifdef KERNELSRC
-install: lkcc $(INSTGEN)
-        set -x; mkdir $(KERNELSRC)/scripts/kconfig; \
-        cp $(sort $(INST)) $(KERNELSRC)/scripts/kconfig; \
+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; \
-        LKCSRC=$$PWD; export LKCSRC; \
-        cd $(KERNELSRC); \
-        patch -p0 -N < $$LKCSRC/prepare-all.diff; \
-        sh $$LKCSRC/convert-all; \
-        patch -p0 -N < $$LKCSRC/fixup-all.diff
-
-        #cp Makefile $(KERNELSRC)/scripts/kconfig/Makefile; \
-
-uninstall:
-        patch -p0 -N -R -d $(KERNELSRC) < prepare-all.diff; \
-        cd $(KERNELSRC); \
-        find -name "Kconfig*" | xargs rm; \
-        rm -rf scripts/kconfig log.*
+        cp Makefile.kernel $(KERNELSRC)/scripts/kconfig/Makefile
+
+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
 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
 
-.PHONY: all tgz clean 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 beb4dcf..22724a7 100644
--- a/scripts/kconfig/Makefile.kernel
+++ b/scripts/kconfig/Makefile.kernel
@@ -1,84 +1,94 @@
 #################
 #
 # 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
 #
 
 # object files used by all lkc flavours
 libkconfig-objs := zconf.tab.o
 
         host-progs:= conf mconf qconf
         conf-objs:= conf.o  libkconfig.so
         mconf-objs:= mconf.o libkconfig.so
 
         qconf-objs:= kconfig_load.o
         qconf-cxxobjs:= qconf.o
 
         clean-files:= libkconfig.so lkc_defs.h qconf.moc .tmp_qtcheck \
                    zconf.tab.c zconf.tab.h lex.zconf.c
 
 include $(TOPDIR)/Rules.make
 
-# QT needs some extra effort...
-ifndef QTDIR
-        QTDIR   := /usr/share/qt
-endif
-
-# Executable to generate the .moc file
-MOC=$(wildcard $(QTDIR)/bin/moc)
-
 # 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 -lqt -ldl
-        HOSTCXXFLAGS_qconf.o:= -I$(QTDIR)/include 
+        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
 
 $(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:
-ifeq ($(MOC),)
-        @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.
-        @false
-else
-        @touch $@
+        @set -e; for d in $$QTDIR /usr/share/qt /usr/lib/qt3; 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)/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)/%.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$@ $<
 
diff --git a/scripts/kconfig/conf.c b/scripts/kconfig/conf.c
index 74c94c2..1602d5f 100644
--- a/scripts/kconfig/conf.c
+++ b/scripts/kconfig/conf.c
@@ -86,64 +86,65 @@ static void strip(char *str)
         if (!l)
                 return;
         p = str + l - 1;
         while ((isspace(*p)))
                 *p-- = 0;
 }
 
 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;
 
         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);
                 }
         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;
@@ -313,87 +314,89 @@ static int conf_choice(struct menu *menu)
                         break;
                 }
         } else {
                 sym->def = sym->curr;
                 if (S_TRI(sym->curr) == mod) {
                         printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
                         return 0;
                 }
         }
 
         while (1) {
                 printf("%*s%s ", 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))
                                 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 {
                         printf("\n");
                         return 1;
                 }
                 switch (input_mode) {
                 case ask_new:
                 case ask_silent:
                 case ask_all:
+                        if (is_new)
+                                sym->flags |= SYMBOL_NEW;
                         conf_askvalue(sym, menu_get_prompt(def_menu));
                         strip(line);
                         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;
                 }
                 if (line[0]) {
-                        len = strlen(line) - 1;
+                        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 (!strncmp(line, menu_get_prompt(cmenu), len)) {
+                                if (!strncasecmp(line, menu_get_prompt(cmenu), len)) {
                                         def_menu = cmenu;
                                         break;
                                 }
                         }
                 }
                 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;
                 }
         }
 }
 
 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) {
diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c
index 0f5fd97..9bf7af9 100644
--- a/scripts/kconfig/confdata.c
+++ b/scripts/kconfig/confdata.c
@@ -1,208 +1,227 @@
 /*
  * 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 <limits.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";
-char conf_filename[PATH_MAX+1];
 
 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)
 {
-        return conf_expand_value(conf_defname);
+        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[128];
+        char line[1024];
         char *p, *p2;
         int lineno = 0;
         struct symbol *sym;
         struct property *prop;
         struct expr *e;
         int i;
 
         if (name) {
-                in = fopen(name, "r");
-                if (in)
-                        strcpy(conf_filename, name);
+                in = zconf_fopen(name);
         } else {
                 const char **names = conf_confnames;
                 while ((name = *names++)) {
                         name = conf_expand_value(name);
-                        in = fopen(name, "r");
+                        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;
+                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)) {
+                        if (S_VAL(sym->def))
                                 free(S_VAL(sym->def));
-                                S_VAL(sym->def) = NULL;
-                        }
                 default:
-                        ;
+                        S_VAL(sym->def) = NULL;
+                        S_TRI(sym->def) = no;
                 }
         }
 
-        while (fgets(line, 128, in)) {
+        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;
-                        //printf("%s -> n\n", line + 9);
                         sym = sym_lookup(line + 9, 0);
                         switch (sym->type) {
                         case S_BOOLEAN:
                         case S_TRISTATE:
                                 sym->def = 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;
-                        //printf("%s -> %s\n", line + 7, p);
                         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_BOOLEAN:
-                                sym->def = symbol_yes.curr;
-                                sym->flags &= ~SYMBOL_NEW;
-                                break;
                         case S_TRISTATE:
-                                if (p[0] == 'm')
-                                        sym->def = symbol_mod.curr;
-                                else
-                                        sym->def = symbol_yes.curr;
-                                sym->flags &= ~SYMBOL_NEW;
+                                if (p[0] == 'm') {
+                                        S_TRI(sym->def) = mod;
+                                        sym->flags &= ~SYMBOL_NEW;
+                                        break;
+                                }
+                        case S_BOOLEAN:
+                                if (p[0] == 'y') {
+                                        S_TRI(sym->def) = yes;
+                                        sym->flags &= ~SYMBOL_NEW;
+                                        break;
+                                }
+                                if (p[0] == 'n') {
+                                        S_TRI(sym->def) = 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->flags &= ~SYMBOL_NEW;
-                                } else
-                                        fprintf(stderr, "%s:%d:symbol value '%s' invalid for %s\n", name, lineno, p, sym->name);
+                                } 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)) {
                                 case mod:
                                         if (S_TRI(prop->def->def) == yes)
                                                 /* warn? */;
                                         break;
                                 case yes:
                                         if (S_TRI(prop->def->def) != no)
                                                 /* warn? */;
                                         S_VAL(prop->def->def) = sym;
                                         break;
                                 case no:
                                         break;
                                 }
                                 S_TRI(prop->def->def) = S_TRI(sym->def);
                         }
                         break;
                 case '\n':
                         break;
                 default:
                         continue;
                 }
         }
         fclose(in);
 
         for_all_symbols(i, sym) {
                 if (!sym_is_choice(sym))
@@ -323,38 +342,37 @@ int conf_write(const char *name)
                                 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) {
                 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))
                 return 1;
-        strcpy(conf_filename, name);
 
         sym_change_count = 0;
 
         return 0;
 }
diff --git a/scripts/kconfig/expr.h b/scripts/kconfig/expr.h
index fd9c32a..896a296 100644
--- a/scripts/kconfig/expr.h
+++ b/scripts/kconfig/expr.h
@@ -137,70 +137,73 @@ struct property {
 #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 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)
 
 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;
+        void *data;
 };
 
+        #define MENU_CHANGED    0x0001
+
 #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_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);
diff --git a/scripts/kconfig/kconfig.i b/scripts/kconfig/kconfig.i
index 699cb13..77405fc 100644
--- a/scripts/kconfig/kconfig.i
+++ b/scripts/kconfig/kconfig.i
@@ -2,64 +2,69 @@
 %{
 #include "kconfig_load.c"
 %}
 
 %init %{
         kconfig_load();
 %}
 
 %nodefault;
 
 #ifdef SWIGRUBY
 %typemap (out) char * {
         if ($1 == NULL)
                 $result = Qnil;
         else
                 $result = rb_str_new2($1);
 }
 %typemap (in) char * {
         if ($input == Qnil)
                 $1 = NULL;
         else
                 $1 = STR2CSTR($input);
 }
 
 %{
 static void expr_to_s_help(void *data, const char *str)
 {
         rb_str_cat((VALUE)data, str, strlen(str));
 }
 %}
 #endif
 
+#ifdef SWIGPYTHON
+%rename (Property) property;
+%rename (default) def;
+#endif
+
 %immutable;
 %include "expr.h"
 #define P(name,type,arg)        extern type name arg
 %include "lkc_proto.h"
 %mutable;
 
 #ifdef SWIGRUBY
 %predicate menu::isVisible;
 %predicate symbol::isChangable;
 %predicate symbol::isChoice;
 %predicate symbol::isChoiceValue;
 #endif
 
 %extend menu {
         bool isVisible(void) {
                 return menu_is_visible(self);
         }
 #ifdef SWIGRUBY
         void each(void) {
                 struct menu *child;
                 for (child = self->list; child; child = child->next)
                         rb_yield(SWIG_NewPointerObj(child, SWIGTYPE_p_menu, 0));
         }
         static void each_menu(void) {
                 struct menu *child;
                 for (child = rootmenu.list; child; child = child->next)
                         rb_yield(SWIG_NewPointerObj(child, SWIGTYPE_p_menu, 0));
         }
 #endif
 }
 
 %extend symbol {
diff --git a/scripts/kconfig/lkc.h b/scripts/kconfig/lkc.h
index 688945b..cdd04a9 100644
--- a/scripts/kconfig/lkc.h
+++ b/scripts/kconfig/lkc.h
@@ -1,95 +1,98 @@
 /*
  * 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
 
-void symbol_end(char *help);
+#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);
 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);
 
 static inline tristate sym_get_tristate_value(struct symbol *sym)
 {
         return S_TRI(sym->curr);
 }
 
 
 static inline struct symbol *sym_get_choice_value(struct symbol *sym)
 {
         return (struct symbol *)S_VAL(sym->curr);
 }
 
 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;
 }
 
diff --git a/scripts/kconfig/mconf.c b/scripts/kconfig/mconf.c
index dec8603..eba5ff7 100644
--- a/scripts/kconfig/mconf.c
+++ b/scripts/kconfig/mconf.c
@@ -1,144 +1,167 @@
 /*
  * 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 option.\n",
+        "There is no help available for this kernel 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\n"
+        "For various reasons, one may wish to keep several different kernel\n"
         "configurations available on a single machine.\n"
         "\n"
         "If you have saved a previous configuration in a file other than the\n"
-        "default, entering the name of the file here will allow you\n"
+        "kernel's 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\n"
+        "For various reasons, one may wish to keep different kernel\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)
 {
         bufptr = buf;
         argptr = args;
         memset(args, 0, sizeof(args));
         indent = 0;
         child_count = 0;
         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);
@@ -245,68 +268,78 @@ static int exec_conf(void)
 #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 (menu->parent != &rootmenu)
-                                        cprint1("   %*c", indent + 1, ' ');
-                                cprint1("%s  --->", prompt);
+
+                                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);
+                                }
+
                                 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:
@@ -363,195 +396,209 @@ static void build_conf(struct menu *menu)
                         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)");
                                 cprint_done();
                                 goto conf_childs;
                         }
                 }
                 cprint1("%*c%s%s", indent + 1, ' ', menu_get_prompt(menu),
                         sym_has_value(sym) ? "" : " (NEW)");
                 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("S");
                         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':
-                                conf(submenu);
+                                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);
                                 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 = menu->sym->help;
+        help = sym->help;
         if (!help)
                 help = nohelp_text;
-        show_helptext(menu_get_prompt(menu), help);
+        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);
@@ -602,110 +649,132 @@ static void conf_string(struct menu *menu)
                 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", conf_filename);
+                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", conf_filename);
+                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);
 
-        sprintf(menu_backtitle, "Configuration");
+        sym = sym_lookup("KERNELRELEASE", 0);
+        sym_calc_value(sym);
+        sprintf(menu_backtitle, "Linux Kernel v%s Configuration",
+                sym_get_string_value(sym));
+
+        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 configuration.\n"
-                        "*** Check the top-level Makefile for additional configuration.\n");
+                        "*** End of Linux kernel configuration.\n"
+                        "*** Check the top-level Makefile for additional configuration.\n"
+                        "*** Next, you may run 'make bzImage', 'make bzdisk', or 'make install'.\n\n");
         } else
-                printf("\n\nYour configuration changes were NOT saved.\n\n");
+                printf("\n\nYour kernel configuration changes were NOT saved.\n\n");
 
         return 0;
 }
diff --git a/scripts/kconfig/menu.c b/scripts/kconfig/menu.c
index 4595110..24be0ec 100644
--- a/scripts/kconfig/menu.c
+++ b/scripts/kconfig/menu.c
@@ -261,49 +261,49 @@ struct menu *menu_get_parent_menu(struct menu *menu)
         while (menu != &rootmenu) {
                 menu = menu->parent;
                 type = menu->prompt ? menu->prompt->type : 0;
                 if (type == P_MENU || type == P_ROOTMENU)
                         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";
+                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 feefa1c..bed541d 100644
--- a/scripts/kconfig/qconf.cc
+++ b/scripts/kconfig/qconf.cc
@@ -1,318 +1,341 @@
 /*
  * 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)
 {
         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;
         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)
                                 goto hide;
                         break;
                 case symbolMode:
                         if (type == P_ROOTMENU)
                                 goto hide;
                         break;
                 default:
                         break;
                 }
 
                 visible = menu_is_visible(child);
                 if (showAll || visible) {
                         if (!item || item->menu != child)
-                                item = new ConfigItem(parent, last, child);
-                        item->visible = visible;
-                        item->updateMenu();
+                                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();
+                        }
 
                         if (mode == fullMode || mode == menuMode ||
                             (type != P_MENU && type != P_ROOTMENU))
                                 updateMenuList(item, child);
                         else
                                 updateMenuList(item, 0);
                         last = item;
                         continue;
                 }
                 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;
         QString prompt;
         int type;
         enum prop_type ptype;
         tristate expr;
-        bool update;
 
         list = listView();
-        update = doInit;
-        if (update)
-                doInit = false;
-        else
-                update = list->updateAll;
 
         sym = menu->sym;
         if (!sym) {
-                if (update) {
-                        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))
-                                setPixmap(promptColIdx, list->menuPix);
-                        else
-                                setPixmap(promptColIdx, 0);
-                }
+                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))
+                        setPixmap(promptColIdx, list->menuPix);
+                else
+                        setPixmap(promptColIdx, 0);
                 return;
         }
 
-        sym_calc_value(sym);
-        if (!(sym->flags & SYMBOL_CHANGED) && !update)
-                return;
-
-        sym->flags &= ~SYMBOL_CHANGED;
-
-        setText(nameColIdx, menu->sym->name);
+        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) {
                         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
-                setRenameEnabled(list->mapIdx(dataColIdx), TRUE);
+                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);
                 else
                         prompt.sprintf("(%s) %s", data, menu_get_prompt(menu));
                 break;
         }
         if (!sym_has_value(sym) && visible)
                 prompt += " (NEW)";
         setText(promptColIdx, prompt);
 }
 
+bool ConfigItem::updateNeeded(void)
+{
+        struct symbol* sym = menu->sym;
+        if (sym)
+                sym_calc_value(sym);
+        if (menu->flags & MENU_CHANGED) {
+                menu->flags &= ~MENU_CHANGED;
+                return true;
+        }
+        return false;
+}
+
 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();
-#if QT_VERSION < 300
-        visible = TRUE;
-#endif
-        //menu->data = this;
+        nextItem = (ConfigItem*)menu->data;
+        menu->data = this;
+
         if (list->mode != fullMode)
                 setOpen(TRUE);
-        doInit= true;
+        if (menu->sym)
+                sym_calc_value(menu->sym);
+        updateMenu();
 }
 
 /*
  * destruct a menu entry
  */
 ConfigItem::~ConfigItem(void)
 {
-        //menu->data = 0;
+        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());
-                emit lineChanged(item);
+                parent()->updateList(item);
                 break;
         default:
                 Parent::keyPressEvent(e);
                 return;
         }
         e->accept();
+        parent()->list->setFocus();
         hide();
 }
 
-ConfigList::ConfigList(QWidget* p, ConfigView* cv)
+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),
           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);
@@ -323,137 +346,138 @@ void ConfigList::reinit(void)
         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;
         type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
         if (mode == menuMode && (type == P_MENU || type == P_ROOTMENU))
                 emit menuSelected(menu);
 }
 
 void ConfigList::updateList(ConfigItem* item)
 {
                 (void)item;// unused so far
         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;
         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);
-                emit symbolChanged(item);
+                parent()->updateList(item);
                 break;
         }
 }
 
 void ConfigList::changeValue(ConfigItem* item)
 {
         struct symbol* sym;
         struct menu* menu;
         int type, oldexpr, newexpr;
 
         menu = item->menu;
         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)
-                        emit symbolChanged(item);
+                        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
-                        lineEdit->show(item);
+                        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)
                 return;
         updateMenuList(this, 0);
         rootEntry = menu;
         updateListAll();
         setSelected(currentItem(), hasFocus());
 }
 
 void ConfigList::setParentMenu(void)
 {
         ConfigItem* item;
         struct menu *oldroot, *newroot;
 
         oldroot = rootEntry;
         newroot = menu_get_parent_menu(oldroot);
         if (newroot == oldroot)
                 return;
         setRootMenu(newroot);
 
         QListViewItemIterator it(this);
         for (; (item = (ConfigItem*)it.current()); it++) {
@@ -487,323 +511,391 @@ void ConfigList::keyPressEvent(QKeyEvent* ev)
         switch (ev->key()) {
         case Key_Return:
         case Key_Enter:
                 menu = item->menu;
                 type = menu->prompt ? menu->prompt->type : P_UNKNOWN;
                 if ((type == P_MENU || type == P_ROOTMENU) && mode != fullMode) {
                         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());
-        QListView::contentsMousePressEvent(e);
+        Parent::contentsMousePressEvent(e);
 }
 
 void ConfigList::contentsMouseReleaseEvent(QMouseEvent* e)
 {
         QPoint p(contentsToViewport(e->pos()));
         ConfigItem* item = (ConfigItem*)itemAt(p);
         struct menu *menu;
         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
                                         emit menuSelected(menu);
                         }
                 }
                 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());
-        QListView::contentsMouseReleaseEvent(e);
+        Parent::contentsMouseReleaseEvent(e);
 }
 
 void ConfigList::contentsMouseMoveEvent(QMouseEvent* e)
 {
         //QPoint p(contentsToViewport(e->pos()));
         //printf("contentsMouseMoveEvent: %d,%d\n", p.x(), p.y());
-        QListView::contentsMouseMoveEvent(e);
+        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;
         menu = item->menu;
         ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
         if ((ptype == P_ROOTMENU || 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());
-        QListView::contentsMouseDoubleClickEvent(e);
+        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
  */
-ConfigView::ConfigView(void)
+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);
 
-        menuList = new ConfigList(split1, this);
+        view = new ConfigView(split1, this);
+        menuList = view->list;
 
         split2 = new QSplitter(split1);
         split2->setOrientation(QSplitter::Vertical);
 
         // create config tree
-        QVBox* box = new QVBox(split2);
-        configList = new ConfigList(box, this);
-        configList->lineEdit = new ConfigLineEdit(box);
-        configList->lineEdit->hide();
-        configList->connect(configList, SIGNAL(symbolChanged(ConfigItem*)),
-                            configList, SLOT(updateList(ConfigItem*)));
-        configList->connect(configList, SIGNAL(symbolChanged(ConfigItem*)),
-                            menuList, SLOT(updateList(ConfigItem*)));
-        configList->connect(configList->lineEdit, SIGNAL(lineChanged(ConfigItem*)),
-                            SLOT(updateList(ConfigItem*)));
+        view = new ConfigView(split2, this);
+        configList = view->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 ConfigView::setHelp(QListViewItem* item)
+void ConfigMainWindow::setHelp(QListViewItem* item)
 {
         struct symbol* sym;
         struct menu* menu;
 
-        configList->lineEdit->hide();
+        configList->parent()->lineEdit->hide();
         if (item) {
                 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 += ")";
                                 }
                         } 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));
                                 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) {
@@ -828,246 +920,284 @@ void ConfigView::setHelp(QListViewItem* item)
                                                 }
                                                 break;
                                         case P_CHOICE:
                                                 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);
                                         debug += "<br>";
                                 }
                         }
                 }
                 helpText->setText(head + debug + help);
                 return;
         }
         helpText->setText(NULL);
 }
 
-void ConfigView::loadConfig(void)
+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 ConfigView::saveConfig(void)
+void ConfigMainWindow::saveConfig(void)
 {
         if (conf_write(NULL))
                 QMessageBox::information(this, "qconf", "Unable to save configuration!");
 }
 
-void ConfigView::saveConfigAs(void)
+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 ConfigView::changeMenu(struct menu *menu)
+void ConfigMainWindow::changeMenu(struct menu *menu)
 {
         configList->setRootMenu(menu);
         backAction->setEnabled(TRUE);
 }
 
-void ConfigView::listFocusChanged(void)
+void ConfigMainWindow::listFocusChanged(void)
 {
         if (menuList->hasFocus()) {
                 if (menuList->mode == menuMode)
                         configList->clearSelection();
                 setHelp(menuList->selectedItem());
         } else if (configList->hasFocus()) {
                 setHelp(configList->selectedItem());
         }
 }
 
-void ConfigView::goBack(void)
+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 ConfigView::showSingleView(void)
+void ConfigMainWindow::showSingleView(void)
 {
         menuList->hide();
         menuList->setRootMenu(0);
         configList->mode = singleMode;
         if (configList->rootEntry == &rootmenu)
                 configList->updateListAll();
         else
                 configList->setRootMenu(&rootmenu);
         configList->setAllOpen(TRUE);
         configList->setFocus();
 }
 
-void ConfigView::showSplitView(void)
+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);
         menuList->setFocus();
 }
 
-void ConfigView::showFullView(void)
+void ConfigMainWindow::showFullView(void)
 {
         menuList->hide();
         menuList->setRootMenu(0);
         configList->mode = fullMode;
         if (configList->rootEntry == &rootmenu)
                 configList->updateListAll();
         else
                 configList->setRootMenu(&rootmenu);
         configList->setAllOpen(FALSE);
         configList->setFocus();
 }
 
-void ConfigView::setShowAll(bool b)
+void ConfigMainWindow::setShowAll(bool b)
 {
         if (configList->showAll == b)
                 return;
         configList->showAll = b;
         configList->updateListAll();
         menuList->showAll = b;
         menuList->updateListAll();
 }
 
-void ConfigView::setShowDebug(bool b)
+void ConfigMainWindow::setShowDebug(bool b)
 {
         if (showDebug == b)
                 return;
         showDebug = b;
 }
 
-void ConfigView::setShowName(bool b)
+void ConfigMainWindow::setShowName(bool b)
 {
         if (configList->showName == b)
                 return;
         configList->showName = b;
         configList->reinit();
 }
 
-void ConfigView::setShowRange(bool b)
+void ConfigMainWindow::setShowRange(bool b)
 {
         if (configList->showRange == b)
                 return;
         configList->showRange = b;
         configList->reinit();
 }
 
-void ConfigView::setShowData(bool b)
+void ConfigMainWindow::setShowData(bool b)
 {
         if (configList->showData == b)
                 return;
         configList->showData = b;
         configList->reinit();
 }
 
 /*
  * ask for saving configuration before quitting
  * TODO ask only when something changed
  */
-void ConfigView::closeEvent(QCloseEvent* e)
+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;
 
         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);
 }
 
 int main(int ac, char** av)
 {
-        ConfigView* v;
+        ConfigMainWindow* v;
         const char *name;
 
 #ifndef LKC_DIRECT_LINK
         kconfig_load();
 #endif
 
         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);
                 }
                 name = av[2];
         } else
                 name = av[1];
         conf_parse(name);
         fixup_rootmenu(&rootmenu);
         conf_read(NULL);
         //zconfdump(stdout);
-        v = new ConfigView();
+
+        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 f8f3669..6f096b4 100644
--- a/scripts/kconfig/qconf.h
+++ b/scripts/kconfig/qconf.h
@@ -1,201 +1,226 @@
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  * Released under the terms of the GNU GPL v2.0.
  */
 
 #include <qlistview.h>
 
-class ConfigLineEdit;
+class ConfigList;
 class ConfigItem;
-class ConfigView;
+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(QWidget* p, ConfigView* cview);
+        ConfigList(ConfigView* p, ConfigMainWindow* cview);
         void reinit(void);
+        ConfigView* parent(void) const
+        {
+                return (ConfigView*)Parent::parent();
+        }
 
-        ConfigLineEdit* lineEdit;
 protected:
-        ConfigView* cview;
+        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 symbolChanged(ConfigItem* item);
         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);
 
         bool updateAll;
 
         QPixmap symbolYesPix, symbolModPix, symbolNoPix;
         QPixmap choiceYesPix, choiceNoPix, menuPix, menuInvPix;
 
         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)
-        : Parent(parent, after), menu(m)
+        ConfigItem(QListView *parent, ConfigItem *after, struct menu *m, bool v)
+        : Parent(parent, after), menu(m), visible(v)
         {
                 init();
         }
-        ConfigItem(ConfigItem *parent, ConfigItem *after, struct menu *m)
-        : Parent(parent, after), menu(m)
+        ConfigItem(ConfigItem *parent, ConfigItem *after, struct menu *m, bool v)
+        : Parent(parent, after), menu(m), visible(v)
         {
                 init();
         }
         ~ConfigItem(void);
         void init(void);
 #if QT_VERSION >= 300
         void okRename(int col);
 #endif
         void updateMenu(void);
+        bool updateNeeded(void);
         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 doInit;
 };
 
 class ConfigLineEdit : public QLineEdit {
         Q_OBJECT
         typedef class QLineEdit Parent;
 public:
-        ConfigLineEdit(QWidget * parent)
-        : QLineEdit(parent)
+        ConfigLineEdit(ConfigView* parent)
+        : Parent(parent)
         { }
+        ConfigView* parent(void) const
+        {
+                return (ConfigView*)Parent::parent();
+        }
         void show(ConfigItem *i);
         void keyPressEvent(QKeyEvent *e);
-signals:
-        void lineChanged(ConfigItem *item);
 
 public:
         ConfigItem *item;
 };
 
-class ConfigView : public QMainWindow {
+class ConfigMainWindow : public QMainWindow {
         Q_OBJECT
 public:
-        ConfigView(void);
+        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);
 
         ConfigList *menuList;
         ConfigList *configList;
         QTextView *helpText;
         QToolBar *toolBar;
         QAction *backAction;
 
         bool showDebug;
 };
diff --git a/scripts/kconfig/symbol.c b/scripts/kconfig/symbol.c
index 59c88d2..845d8a3 100644
--- a/scripts/kconfig/symbol.c
+++ b/scripts/kconfig/symbol.c
@@ -120,120 +120,121 @@ 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)
                         return prop;
         }
         return NULL;
 }
 
 void sym_calc_visibility(struct symbol *sym)
 {
         struct property *prop;
         tristate visible, oldvisible;
 
         /* 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;
-                sym->flags |= SYMBOL_CHANGED;
+                sym_set_changed(sym);
         }
 }
 
 void sym_calc_value(struct symbol *sym)
 {
         struct symbol_value newval, oldval;
         struct property *prop, *def_prop;
         struct symbol *def_sym;
         struct expr *e;
 
         if (sym->flags & SYMBOL_VALID)
                 return;
 
         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->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;
                 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) {
                         sym->flags |= SYMBOL_WRITE;
                         sym_calc_value(prop->def);
                         newval = prop->def->curr;
                 }
         }
 
         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;
@@ -247,129 +248,143 @@ out:
                 if (def_sym) {
                         sym_calc_visibility(def_sym);
                         if (def_sym->visible == no)
                                 def_sym = NULL;
                 }
                 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;
                                 }
                         }
                 }
 
                 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;
                                 }
                         }
                 }
 
                 S_VAL(newval) = def_sym;
         }
 
         if (memcmp(&oldval, &newval, sizeof(newval)))
-                sym->flags |= SYMBOL_CHANGED;
+                sym_set_changed(sym);
         sym->curr = newval;
 
         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->dep; 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->flags |= SYMBOL_CHANGED;
+                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;
 }
 
 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->flags |= SYMBOL_CHANGED;
+                sym_set_changed(sym);
         }
         if (sym_is_choice_value(sym) && val == yes) {
                 struct property *prop = sym_get_choice_prop(sym);
 
                 S_VAL(prop->def->def) = sym;
                 prop->def->flags &= ~SYMBOL_NEW;
         }
 
         S_TRI(sym->def) = 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:
@@ -431,169 +446,165 @@ bool sym_string_valid(struct symbol *sym, const char *str)
 }
 
 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':
                         return sym_set_tristate_value(sym, yes);
                 case 'm':
                 case 'M':
                         return sym_set_tristate_value(sym, mod);
                 case 'n':
                 case 'N':
                         return sym_set_tristate_value(sym, no);
                 }
                 return false;
         default:
                 ;
         }
 
         if (!sym_string_valid(sym, newval))
                 return false;
 
         if (sym->flags & SYMBOL_NEW) {
                 sym->flags &= ~SYMBOL_NEW;
-                sym->flags |= SYMBOL_CHANGED;
+                sym_set_changed(sym);
         }
 
         oldval = S_VAL(sym->def);
         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);
                 *val++ = '0';
                 *val++ = 'x';
         } else if (!oldval || strcmp(oldval, newval))
                 S_VAL(sym->def) = 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);
 }
 
 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;
 }
 
 struct symbol *sym_lookup(const char *name, int isconst)
 {
         struct symbol *symbol;
         const char *ptr;
         char *new_name;
         int hash = 0;
 
-        //printf("lookup: %s -> ", name);
         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))) {
-                                        //printf("h:%p\n", symbol);
+                                    (!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;
 
-        //printf("n:%p\n", 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;
 }
 
diff --git a/scripts/kconfig/zconf.l b/scripts/kconfig/zconf.l
index 6d81e5e..1471630 100644
--- a/scripts/kconfig/zconf.l
+++ b/scripts/kconfig/zconf.l
@@ -1,49 +1,49 @@
-%option backup nostdinit noyywrap full ecs
+%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"
-#include "zconf.tab.h"
 
         #define START_STRSIZE16
 
 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) {
@@ -54,270 +54,306 @@ void append_string(const char *str, int 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]*#.*\ncurrent_file->lineno++;
 [ \t]*#.*
 
         [ \t]*\ncurrent_file->lineno++; return T_EOL;
 
         [ \t]+{
         BEGIN(COMMAND);
 }
 
         .{
         unput(yytext[0]);
-        //printf("new config: ");
-        //symbol_end(NULL);
         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;
                 "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;
                 "bool"          BEGIN(PARAM); return T_BOOLEAN;
                 "boolean"       BEGIN(PARAM); return T_BOOLEAN;
                 "int"           BEGIN(PARAM); return T_INT;
                 "hex"           BEGIN(PARAM); return T_HEX;
                 "string"        BEGIN(PARAM); return T_STRING;
                 {n}+{
                 alloc_string(yytext, yyleng);
                 zconflval.string = text;
                 return T_WORD;
         }
         .
                 \ncurrent_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);
         }
                 \nBEGIN(INITIAL); current_file->lineno++; return T_EOL;
                 ---/* ignore */
                 ({n}|[-/.])+{
                 alloc_string(yytext, yyleng);
                 zconflval.string = text;
                 return T_WORD;
         }
+                \\\ncurrent_file->lineno++;
         .
+        <<EOF>> {
+                BEGIN(INITIAL);
+        }
 }
 
 <STRING>{
-                [^'"\n\\]+{
+                [^'"\\\n]+/\n{
+                append_string(yytext, yyleng);
+                zconflval.string = text;
+                return T_STRING;
+        }
+                [^'"\\\n]+{
                 append_string(yytext, yyleng);
         }
+                \\.?/\n{
+                append_string(yytext + 1, yyleng - 1);
+                zconflval.string = text;
+                return T_STRING;
+        }
+                \\.?{
+                append_string(yytext + 1, yyleng - 1);
+        }
                 \'|\"{
                 if (str == yytext[0]) {
                         BEGIN(PARAM);
                         zconflval.string = text;
-                        //printf("s:%s\n", text);
                         return T_STRING;
                 } else
                         append_string(yytext, 1);
         }
-                \\[ \t]*\nappend_string(yytext+yyleng-1, 1); current_file->lineno++;
-                \\[ \t]*append_string(yytext+1, yyleng-1);
-                \\.     append_string(yytext+1, 1);
                 \n{
-                //printf(":%d: open string!\n", current_file->lineno+1);
-                exit(0);
+                printf("%s:%d:warning: multi-line strings not supported\n", zconf_curname(), zconf_lineno());
+                current_file->lineno++;
+                BEGIN(INITIAL);
+                return T_EOL;
         }
                 <<EOF>>{
-                //printf(":%d: open string!\n", current_file->lineno+1);
-                exit(0);
+                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] {
                 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); 
 }
 
+
+/* 
+ * 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 = fopen(name, "r");
+        yyin = zconf_fopen(name);
         if (!yyin) {
                 printf("can't find file %s\n", name);
                 exit(1);
         }
-        //fprintf(stderr, "zconf_initscan: %s\n", name);
 
         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 = fopen(name, "r");
+        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;
 
-        //fprintf(stderr, "zconf_nextfile: %s\n", name);
-
         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;
         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 c3f1bd0..996b10a 100644
--- a/scripts/kconfig/zconf.y
+++ b/scripts/kconfig/zconf.y
@@ -198,83 +198,81 @@ choice_end: end
                 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
 {
         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 help
         | choice_option_list T_EOL
 ;
 
 choice_option: T_PROMPT prompt if_expr
 {
         menu_add_prop(P_PROMPT, $2, NULL, $3);
         printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
 };
 
 choice_option: T_OPTIONAL
 {
         current_entry->sym->flags |= SYMBOL_OPTIONAL;
         printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
 };
 
-choice_option: T_DEFAULT symbol
+choice_option: T_DEFAULT symbol if_expr
 {
-        menu_add_prop(P_DEFAULT, NULL, $2, NULL);
-        //current_choice->prop->def = $2;
+        menu_add_prop(P_DEFAULT, NULL, $2, $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
 {
         printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
         menu_add_entry(NULL);
-        //current_entry->prompt = menu_add_prop(T_IF, NULL, NULL, $2);
         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
 {
         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
 {