1 files changed, 146 insertions, 95 deletions

diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c
index f81f263b64f2..9df80114b47b 100644
--- a/scripts/kconfig/confdata.c
+++ b/scripts/kconfig/confdata.c
@@ -5,6 +5,7 @@
 
 #include <sys/stat.h>
 #include <ctype.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -18,6 +19,9 @@
 static void conf_warning(const char *fmt, ...)
         __attribute__ ((format (printf, 1, 2)));
 
+static void conf_message(const char *fmt, ...)
+        __attribute__ ((format (printf, 1, 2)));
+
 static const char *conf_filename;
 static int conf_lineno, conf_warnings, conf_unsaved;
 
@@ -34,6 +38,29 @@ static void conf_warning(const char *fmt, ...)
         conf_warnings++;
 }
 
+static void conf_default_message_callback(const char *fmt, va_list ap)
+{
+        printf("#\n# ");
+        vprintf(fmt, ap);
+        printf("\n#\n");
+}
+
+static void (*conf_message_callback) (const char *fmt, va_list ap) =
+        conf_default_message_callback;
+void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))
+{
+        conf_message_callback = fn;
+}
+
+static void conf_message(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        if (conf_message_callback)
+                conf_message_callback(fmt, ap);
+}
+
 const char *conf_get_configname(void)
 {
         char *name = getenv("KCONFIG_CONFIG");
@@ -183,9 +210,8 @@ int conf_read_simple(const char *name, int def)
                         name = conf_expand_value(prop->expr->left.sym->name);
                         in = zconf_fopen(name);
                         if (in) {
-                                printf(_("#\n"
-                                         "# using defaults found in %s\n"
-                                         "#\n"), name);
+                                conf_message(_("using defaults found in %s"),
+                                         name);
                                 goto load;
                         }
                 }
@@ -220,24 +246,23 @@ load:
         while (fgets(line, sizeof(line), in)) {
                 conf_lineno++;
                 sym = NULL;
-                switch (line[0]) {
-                case '#':
-                        if (memcmp(line + 2, "CONFIG_", 7))
+                if (line[0] == '#') {
+                        if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
                                 continue;
-                        p = strchr(line + 9, ' ');
+                        p = strchr(line + 2 + strlen(CONFIG_), ' ');
                         if (!p)
                                 continue;
                         *p++ = 0;
                         if (strncmp(p, "is not set", 10))
                                 continue;
                         if (def == S_DEF_USER) {
-                                sym = sym_find(line + 9);
+                                sym = sym_find(line + 2 + strlen(CONFIG_));
                                 if (!sym) {
                                         sym_add_change_count(1);
-                                        break;
+                                        goto setsym;
                                 }
                         } else {
-                                sym = sym_lookup(line + 9, 0);
+                                sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
                                 if (sym->type == S_UNKNOWN)
                                         sym->type = S_BOOLEAN;
                         }
@@ -253,13 +278,8 @@ load:
                         default:
                                 ;
                         }
-                        break;
-                case 'C':
-                        if (memcmp(line, "CONFIG_", 7)) {
-                                conf_warning("unexpected data");
-                                continue;
-                        }
-                        p = strchr(line + 7, '=');
+                } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
+                        p = strchr(line + strlen(CONFIG_), '=');
                         if (!p)
                                 continue;
                         *p++ = 0;
@@ -270,13 +290,13 @@ load:
                                         *p2 = 0;
                         }
                         if (def == S_DEF_USER) {
-                                sym = sym_find(line + 7);
+                                sym = sym_find(line + strlen(CONFIG_));
                                 if (!sym) {
                                         sym_add_change_count(1);
-                                        break;
+                                        goto setsym;
                                 }
                         } else {
-                                sym = sym_lookup(line + 7, 0);
+                                sym = sym_lookup(line + strlen(CONFIG_), 0);
                                 if (sym->type == S_UNKNOWN)
                                         sym->type = S_OTHER;
                         }
@@ -285,14 +305,12 @@ load:
                         }
                         if (conf_set_sym_val(sym, def, def_flags, p))
                                 continue;
-                        break;
-                case '\r':
-                case '\n':
-                        break;
-                default:
-                        conf_warning("unexpected data");
+                } else {
+                        if (line[0] != '\r' && line[0] != '\n')
+                                conf_warning("unexpected data");
                         continue;
                 }
+setsym:
                 if (sym && sym_is_choice_value(sym)) {
                         struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
                         switch (sym->def[def].tri) {
@@ -405,14 +423,14 @@ static void conf_write_string(bool headerfile, const char *name,
 {
         int l;
         if (headerfile)
-                fprintf(out, "#define CONFIG_%s \"", name);
+                fprintf(out, "#define %s%s \"", CONFIG_, name);
         else
-                fprintf(out, "CONFIG_%s=\"", name);
+                fprintf(out, "%s%s=\"", CONFIG_, name);
 
         while (1) {
                 l = strcspn(str, "\"\\");
                 if (l) {
-                        fwrite(str, l, 1, out);
+                        xfwrite(str, l, 1, out);
                         str += l;
                 }
                 if (!*str)
@@ -433,13 +451,14 @@ static void conf_write_symbol(struct symbol *sym, enum symbol_type type,
                 switch (sym_get_tristate_value(sym)) {
                 case no:
                         if (write_no)
-                                fprintf(out, "# CONFIG_%s is not set\n", sym->name);
+                                fprintf(out, "# %s%s is not set\n",
+                                    CONFIG_, sym->name);
                         break;
                 case mod:
-                        fprintf(out, "CONFIG_%s=m\n", sym->name);
+                        fprintf(out, "%s%s=m\n", CONFIG_, sym->name);
                         break;
                 case yes:
-                        fprintf(out, "CONFIG_%s=y\n", sym->name);
+                        fprintf(out, "%s%s=y\n", CONFIG_, sym->name);
                         break;
                 }
                 break;
@@ -449,7 +468,7 @@ static void conf_write_symbol(struct symbol *sym, enum symbol_type type,
         case S_HEX:
         case S_INT:
                 str = sym_get_string_value(sym);
-                fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
+                fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str);
                 break;
         case S_OTHER:
         case S_UNKNOWN:
@@ -497,7 +516,9 @@ int conf_write_defconfig(const char *filename)
                         /*
                          * If symbol is a choice value and equals to the
                          * default for a choice - skip.
-                         * But only if value equal to "y".
+                         * But only if value is bool and equal to "y" and
+                         * choice is not "optional".
+                         * (If choice is "optional" then all values can be "n")
                          */
                         if (sym_is_choice_value(sym)) {
                                 struct symbol *cs;
@@ -505,10 +526,9 @@ int conf_write_defconfig(const char *filename)
 
                                 cs = prop_get_symbol(sym_get_choice_prop(sym));
                                 ds = sym_choice_default(cs);
-                                if (sym == ds) {
-                                        if ((sym->type == S_BOOLEAN ||
-                                        sym->type == S_TRISTATE) &&
-                                        sym_get_tristate_value(sym) == yes)
+                                if (!sym_is_optional(cs) && sym == ds) {
+                                        if ((sym->type == S_BOOLEAN) &&
+                                            sym_get_tristate_value(sym) == yes)
                                                 goto next_menu;
                                 }
                         }
@@ -540,7 +560,7 @@ int conf_write(const char *name)
         struct menu *menu;
         const char *basename;
         const char *str;
-        char dirname[128], tmpname[128], newname[128];
+        char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];
         enum symbol_type type;
         time_t now;
         int use_timestamp = 1;
@@ -580,8 +600,6 @@ int conf_write(const char *name)
         if (!out)
                 return 1;
 
-        sym = sym_lookup("KERNELVERSION", 0);
-        sym_calc_value(sym);
         time(&now);
         env = getenv("KCONFIG_NOTIMESTAMP");
         if (env && *env)
@@ -589,10 +607,10 @@ int conf_write(const char *name)
 
         fprintf(out, _("#\n"
                        "# Automatically generated make config: don't edit\n"
-                       "# Linux kernel version: %s\n"
+                       "# %s\n"
                        "%s%s"
                        "#\n"),
-                     sym_get_string_value(sym),
+                     rootmenu.prompt->text,
                      use_timestamp ? "# " : "",
                      use_timestamp ? ctime(&now) : "");
 
@@ -649,9 +667,7 @@ next:
                         return 1;
         }
 
-        printf(_("#\n"
-                 "# configuration written to %s\n"
-                 "#\n"), newname);
+        conf_message(_("configuration written to %s"), newname);
 
         sym_set_change_count(0);
 
@@ -661,7 +677,7 @@ next:
 static int conf_split_config(void)
 {
         const char *name;
-        char path[128];
+        char path[PATH_MAX+1];
         char *s, *d, c;
         struct symbol *sym;
         struct stat sb;
@@ -803,25 +819,23 @@ int conf_write_autoconf(void)
                 return 1;
         }
 
-        sym = sym_lookup("KERNELVERSION", 0);
-        sym_calc_value(sym);
         time(&now);
         fprintf(out, "#\n"
                      "# Automatically generated make config: don't edit\n"
-                     "# Linux kernel version: %s\n"
+                     "# %s\n"
                      "# %s"
                      "#\n",
-                     sym_get_string_value(sym), ctime(&now));
+                     rootmenu.prompt->text, ctime(&now));
         fprintf(tristate, "#\n"
                           "# Automatically generated - do not edit\n"
                           "\n");
         fprintf(out_h, "/*\n"
                        " * Automatically generated C config: don't edit\n"
-                       " * Linux kernel version: %s\n"
+                       " * %s\n"
                        " * %s"
                        " */\n"
                        "#define AUTOCONF_INCLUDED\n",
-                       sym_get_string_value(sym), ctime(&now));
+                       rootmenu.prompt->text, ctime(&now));
 
         for_all_symbols(i, sym) {
                 sym_calc_value(sym);
@@ -839,14 +853,17 @@ int conf_write_autoconf(void)
                         case no:
                                 break;
                         case mod:
-                                fprintf(tristate, "CONFIG_%s=M\n", sym->name);
-                                fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
+                                fprintf(tristate, "%s%s=M\n",
+                                    CONFIG_, sym->name);
+                                fprintf(out_h, "#define %s%s_MODULE 1\n",
+                                    CONFIG_, sym->name);
                                 break;
                         case yes:
                                 if (sym->type == S_TRISTATE)
-                                        fprintf(tristate, "CONFIG_%s=Y\n",
-                                                        sym->name);
-                                fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
+                                        fprintf(tristate,"%s%s=Y\n",
+                                            CONFIG_, sym->name);
+                                fprintf(out_h, "#define %s%s 1\n",
+                                    CONFIG_, sym->name);
                                 break;
                         }
                         break;
@@ -856,12 +873,14 @@ int conf_write_autoconf(void)
                 case S_HEX:
                         str = sym_get_string_value(sym);
                         if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
-                                fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
+                                fprintf(out_h, "#define %s%s 0x%s\n",
+                                    CONFIG_, sym->name, str);
                                 break;
                         }
                 case S_INT:
                         str = sym_get_string_value(sym);
-                        fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
+                        fprintf(out_h, "#define %s%s %s\n",
+                            CONFIG_, sym->name, str);
                         break;
                 default:
                         break;
@@ -919,13 +938,73 @@ void conf_set_changed_callback(void (*fn)(void))
         conf_changed_callback = fn;
 }
 
+static void randomize_choice_values(struct symbol *csym)
+{
+        struct property *prop;
+        struct symbol *sym;
+        struct expr *e;
+        int cnt, def;
 
-void conf_set_all_new_symbols(enum conf_def_mode mode)
+        /*
+         * If choice is mod then we may have more items slected
+         * and if no then no-one.
+         * In both cases stop.
+         */
+        if (csym->curr.tri != yes)
+                return;
+
+        prop = sym_get_choice_prop(csym);
+
+        /* count entries in choice block */
+        cnt = 0;
+        expr_list_for_each_sym(prop->expr, e, sym)
+                cnt++;
+
+        /*
+         * find a random value and set it to yes,
+         * set the rest to no so we have only one set
+         */
+        def = (rand() % cnt);
+
+        cnt = 0;
+        expr_list_for_each_sym(prop->expr, e, sym) {
+                if (def == cnt++) {
+                        sym->def[S_DEF_USER].tri = yes;
+                        csym->def[S_DEF_USER].val = sym;
+                }
+                else {
+                        sym->def[S_DEF_USER].tri = no;
+                }
+        }
+        csym->flags |= SYMBOL_DEF_USER;
+        /* clear VALID to get value calculated */
+        csym->flags &= ~(SYMBOL_VALID);
+}
+
+static void set_all_choice_values(struct symbol *csym)
 {
-        struct symbol *sym, *csym;
         struct property *prop;
+        struct symbol *sym;
         struct expr *e;
-        int i, cnt, def;
+
+        prop = sym_get_choice_prop(csym);
+
+        /*
+         * Set all non-assinged choice values to no
+         */
+        expr_list_for_each_sym(prop->expr, e, sym) {
+                if (!sym_has_value(sym))
+                        sym->def[S_DEF_USER].tri = no;
+        }
+        csym->flags |= SYMBOL_DEF_USER;
+        /* clear VALID to get value calculated */
+        csym->flags &= ~(SYMBOL_VALID);
+}
+
+void conf_set_all_new_symbols(enum conf_def_mode mode)
+{
+        struct symbol *sym, *csym;
+        int i, cnt;
 
         for_all_symbols(i, sym) {
                 if (sym_has_value(sym))
@@ -961,8 +1040,6 @@ void conf_set_all_new_symbols(enum conf_def_mode mode)
 
         sym_clear_all_valid();
 
-        if (mode != def_random)
-                return;
         /*
          * We have different type of choice blocks.
          * If curr.tri equal to mod then we can select several
@@ -977,35 +1054,9 @@ void conf_set_all_new_symbols(enum conf_def_mode mode)
                         continue;
 
                 sym_calc_value(csym);
-
-                if (csym->curr.tri != yes)
-                        continue;
-
-                prop = sym_get_choice_prop(csym);
-
-                /* count entries in choice block */
-                cnt = 0;
-                expr_list_for_each_sym(prop->expr, e, sym)
-                        cnt++;
-
-                /*
-                 * find a random value and set it to yes,
-                 * set the rest to no so we have only one set
-                 */
-                def = (rand() % cnt);
-
-                cnt = 0;
-                expr_list_for_each_sym(prop->expr, e, sym) {
-                        if (def == cnt++) {
-                                sym->def[S_DEF_USER].tri = yes;
-                                csym->def[S_DEF_USER].val = sym;
-                        }
-                        else {
-                                sym->def[S_DEF_USER].tri = no;
-                        }
-                }
-                csym->flags |= SYMBOL_DEF_USER;
-                /* clear VALID to get value calculated */
-                csym->flags &= ~(SYMBOL_VALID);
+                if (mode == def_random)
+                        randomize_choice_values(csym);
+                else
+                        set_all_choice_values(csym);
         }
 }