kconfig: tristate choices with mixed tristate and boolean values

Change kconfig behavior so that mixing bool and tristate config
settings in a choice is possible and has the desired effect of offering
just the tristate options individually if the choice gets set to M, and
a normal boolean selection if the choice gets set to Y.

Also fix scripts/kconfig/conf's handling of children of choice values -
there may be more than one immediate child, and all of them need to be
processed.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
Cc: "Roman Zippel" <zippel@linux-m68k.org>
Signed-off-by: Sam Ravnborg <sam@ravnborg.org>

3 files changed, 45 insertions, 7 deletions

diff --git a/scripts/kconfig/conf.c b/scripts/kconfig/conf.c
index d1a0368bd438..fda63136ae68 100644
--- a/scripts/kconfig/conf.c
+++ b/scripts/kconfig/conf.c
@@ -400,9 +400,9 @@ static int conf_choice(struct menu *menu)
                         continue;
                 }
                 sym_set_choice_value(sym, child->sym);
-                if (child->list) {
+                for (child = child->list; child; child = child->next) {
                         indent += 2;
-                        conf(child->list);
+                        conf(child);
                         indent -= 2;
                 }
                 return 1;
diff --git a/scripts/kconfig/expr.c b/scripts/kconfig/expr.c
index 13788ada5228..579ece4fa584 100644
--- a/scripts/kconfig/expr.c
+++ b/scripts/kconfig/expr.c
@@ -1034,12 +1034,18 @@ void expr_print(struct expr *e, void (*fn)(void *, struct symbol *, const char *
                 expr_print(e->left.expr, fn, data, E_NOT);
                 break;
         case E_EQUAL:
-                fn(data, e->left.sym, e->left.sym->name);
+                if (e->left.sym->name)
+                        fn(data, e->left.sym, e->left.sym->name);
+                else
+                        fn(data, NULL, "<choice>");
                 fn(data, NULL, "=");
                 fn(data, e->right.sym, e->right.sym->name);
                 break;
         case E_UNEQUAL:
-                fn(data, e->left.sym, e->left.sym->name);
+                if (e->left.sym->name)
+                        fn(data, e->left.sym, e->left.sym->name);
+                else
+                        fn(data, NULL, "<choice>");
                 fn(data, NULL, "!=");
                 fn(data, e->right.sym, e->right.sym->name);
                 break;
diff --git a/scripts/kconfig/menu.c b/scripts/kconfig/menu.c
index e6ef171e5b14..fdad17367f61 100644
--- a/scripts/kconfig/menu.c
+++ b/scripts/kconfig/menu.c
@@ -242,9 +242,11 @@ void menu_finalize(struct menu *parent)
                         for (menu = parent->list; menu; menu = menu->next) {
                                 if (menu->sym) {
                                         current_entry = parent;
-                                        menu_set_type(menu->sym->type);
+                                        if (sym->type == S_UNKNOWN)
+                                                menu_set_type(menu->sym->type);
                                         current_entry = menu;
-                                        menu_set_type(sym->type);
+                                        if (menu->sym->type == S_UNKNOWN)
+                                                menu_set_type(sym->type);
                                         break;
                                 }
                         }
@@ -329,7 +331,37 @@ void menu_finalize(struct menu *parent)
                                             "values not supported");
                         }
                         current_entry = menu;
-                        menu_set_type(sym->type);
+                        if (menu->sym->type == S_UNKNOWN)
+                                menu_set_type(sym->type);
+                        /* Non-tristate choice values of tristate choices must
+                         * depend on the choice being set to Y. The choice
+                         * values' dependencies were propagated to their
+                         * properties above, so the change here must be re-
+                         * propagated. */
+                        if (sym->type == S_TRISTATE && menu->sym->type != S_TRISTATE) {
+                                basedep = expr_alloc_comp(E_EQUAL, sym, &symbol_yes);
+                                basedep = expr_alloc_and(basedep, menu->dep);
+                                basedep = expr_eliminate_dups(basedep);
+                                menu->dep = basedep;
+                                for (prop = menu->sym->prop; prop; prop = prop->next) {
+                                        if (prop->menu != menu)
+                                                continue;
+                                        dep = expr_alloc_and(expr_copy(basedep),
+                                                             prop->visible.expr);
+                                        dep = expr_eliminate_dups(dep);
+                                        dep = expr_trans_bool(dep);
+                                        prop->visible.expr = dep;
+                                        if (prop->type == P_SELECT) {
+                                                struct symbol *es = prop_get_symbol(prop);
+                                                dep2 = expr_alloc_symbol(menu->sym);
+                                                dep = expr_alloc_and(dep2,
+                                                                     expr_copy(dep));
+                                                dep = expr_alloc_or(es->rev_dep.expr, dep);
+                                                dep = expr_eliminate_dups(dep);
+                                                es->rev_dep.expr = dep;
+                                        }
+                                }
+                        }
                         menu_add_symbol(P_CHOICE, sym, NULL);
                         prop = sym_get_choice_prop(sym);
                         for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr)