Merge git://git.kernel.org/pub/scm/linux/kernel/git/hskinnemoen/avr32-2.6

[linux-2.6] / scripts / kconfig / confdata.c

diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c
index e4fa3f302541c155ef552ca843cad003cb2ac3f4..07597611cc504deca5098cdd7638ace892cd4441 100644 (file)
--- a/scripts/kconfig/confdata.c
+++ b/scripts/kconfig/confdata.c
@@ -145,33 +145,6 @@ static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
        return 0;
 }
 
-/* Read an environment variable and assign the value to the symbol */
-int conf_set_env_sym(const char *env, const char *symname, int def)
-{
-       struct symbol *sym;
-       char *p;
-       int def_flags;
-
-       p = getenv(env);
-       if (p) {
-               char warning[200];
-               sprintf(warning, "Environment variable (%s = \"%s\")", env, p);
-               conf_filename = warning;
-               def_flags = SYMBOL_DEF << def;
-               if (def == S_DEF_USER) {
-                       sym = sym_find(symname);
-                       if (!sym)
-                               return 1;
-               } else {
-                       sym = sym_lookup(symname, 0);
-                       if (sym->type == S_UNKNOWN)
-                               sym->type = S_OTHER;
-               }
-               conf_set_sym_val(sym, def, def_flags, p);
-       }
-       return 0;
-}
-
 int conf_read_simple(const char *name, int def)
 {
        FILE *in = NULL;
@@ -259,8 +232,7 @@ load:
                                        sym->type = S_BOOLEAN;
                        }
                        if (sym->flags & def_flags) {
-                               conf_warning("trying to reassign symbol %s", sym->name);
-                               break;
+                               conf_warning("override: reassigning to symbol %s", sym->name);
                        }
                        switch (sym->type) {
                        case S_BOOLEAN:
@@ -299,8 +271,7 @@ load:
                                        sym->type = S_OTHER;
                        }
                        if (sym->flags & def_flags) {
-                               conf_warning("trying to reassign symbol %s", sym->name);
-                               break;
+                               conf_warning("override: reassigning to symbol %s", sym->name);
                        }
                        if (conf_set_sym_val(sym, def, def_flags, p))
                                continue;
@@ -324,14 +295,12 @@ load:
                                }
                                break;
                        case yes:
-                               if (cs->def[def].tri != no) {
-                                       conf_warning("%s creates inconsistent choice state", sym->name);
-                                       cs->flags &= ~def_flags;
-                               } else
-                                       cs->def[def].val = sym;
+                               if (cs->def[def].tri != no)
+                                       conf_warning("override: %s changes choice state", sym->name);
+                               cs->def[def].val = sym;
                                break;
                        }
-                       cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].tri);
+                       cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
                }
        }
        fclose(in);
@@ -343,7 +312,7 @@ load:
 
 int conf_read(const char *name)
 {
-       struct symbol *sym;
+       struct symbol *sym, *choice_sym;
        struct property *prop;
        struct expr *e;
        int i, flags;
@@ -384,9 +353,9 @@ int conf_read(const char *name)
                 */
                prop = sym_get_choice_prop(sym);
                flags = sym->flags;
-               for (e = prop->expr; e; e = e->left.expr)
-                       if (e->right.sym->visible != no)
-                               flags &= e->right.sym->flags;
+               expr_list_for_each_sym(prop->expr, e, choice_sym)
+                       if (choice_sym->visible != no)
+                               flags &= choice_sym->flags;
                sym->flags &= flags | ~SYMBOL_DEF_USER;
        }
 
@@ -843,3 +812,73 @@ void conf_set_changed_callback(void (*fn)(void))
 {
        conf_changed_callback = fn;
 }
+
+
+void conf_set_all_new_symbols(enum conf_def_mode mode)
+{
+       struct symbol *sym, *csym;
+       struct property *prop;
+       struct expr *e;
+       int i, cnt, def;
+
+       for_all_symbols(i, sym) {
+               if (sym_has_value(sym))
+                       continue;
+               switch (sym_get_type(sym)) {
+               case S_BOOLEAN:
+               case S_TRISTATE:
+                       switch (mode) {
+                       case def_yes:
+                               sym->def[S_DEF_USER].tri = yes;
+                               break;
+                       case def_mod:
+                               sym->def[S_DEF_USER].tri = mod;
+                               break;
+                       case def_no:
+                               sym->def[S_DEF_USER].tri = no;
+                               break;
+                       case def_random:
+                               sym->def[S_DEF_USER].tri = (tristate)(rand() % 3);
+                               break;
+                       default:
+                               continue;
+                       }
+                       if (!sym_is_choice(sym) || mode != def_random)
+                               sym->flags |= SYMBOL_DEF_USER;
+                       break;
+               default:
+                       break;
+               }
+
+       }
+
+       if (modules_sym)
+               sym_calc_value(modules_sym);
+
+       if (mode != def_random)
+               return;
+
+       for_all_symbols(i, csym) {
+               if (sym_has_value(csym) || !sym_is_choice(csym))
+                       continue;
+
+               sym_calc_value(csym);
+               prop = sym_get_choice_prop(csym);
+               def = -1;
+               while (1) {
+                       cnt = 0;
+                       expr_list_for_each_sym(prop->expr, e, sym) {
+                               if (sym->visible == no)
+                                       continue;
+                               if (def == cnt++) {
+                                       csym->def[S_DEF_USER].val = sym;
+                                       break;
+                               }
+                       }
+                       if (def >= 0 || cnt < 2)
+                               break;
+                       def = (rand() % cnt) + 1;
+               }
+               csym->flags |= SYMBOL_DEF_USER;
+       }
+}