kconfig: drop 'boolean' keyword

[carl9170fw.git] / config / menu.c

diff --git a/config/menu.c b/config/menu.c
index 41c79bef3d075fa1122643ceb3cdae9e8289e8d5..47bec3434fef16f1b0c46e0f8d908ee704aa57ca 100644 (file)
--- a/config/menu.c
+++ b/config/menu.c
@@ -62,13 +62,8 @@ void menu_add_entry(struct symbol *sym)
                menu_add_symbol(P_SYMBOL, sym, NULL);
 }
 
-void menu_end_entry(void)
-{
-}
-
 struct menu *menu_add_menu(void)
 {
-       menu_end_entry();
        last_entry_ptr = &current_entry->list;
        return current_menu = current_entry;
 }
@@ -274,13 +269,13 @@ static void sym_check_prop(struct symbol *sym)
                        if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE)
                                prop_warn(prop,
                                    "config symbol '%s' uses %s, but is "
-                                   "not boolean or tristate", sym->name, use);
+                                   "not bool or tristate", sym->name, use);
                        else if (sym2->type != S_UNKNOWN &&
                                 sym2->type != S_BOOLEAN &&
                                 sym2->type != S_TRISTATE)
                                prop_warn(prop,
                                    "'%s' has wrong type. '%s' only "
-                                   "accept arguments of boolean and "
+                                   "accept arguments of bool and "
                                    "tristate type", sym2->name, use);
                        break;
                case P_RANGE:
@@ -418,25 +413,63 @@ void menu_finalize(struct menu *parent)
                for (menu = parent->list; menu; menu = menu->next)
                        menu_finalize(menu);
        } else if (sym) {
+               /*
+                * Automatic submenu creation. If sym is a symbol and A, B, C,
+                * ... are consecutive items (symbols, menus, ifs, etc.) that
+                * all depend on sym, then the following menu structure is
+                * created:
+                *
+                *      sym
+                *       +-A
+                *       +-B
+                *       +-C
+                *       ...
+                *
+                * This also works recursively, giving the following structure
+                * if A is a symbol and B depends on A:
+                *
+                *      sym
+                *       +-A
+                *       | +-B
+                *       +-C
+                *       ...
+                */
+
                basedep = parent->prompt ? parent->prompt->visible.expr : NULL;
                basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no);
                basedep = expr_eliminate_dups(expr_transform(basedep));
+
+               /* Examine consecutive elements after sym */
                last_menu = NULL;
                for (menu = parent->next; menu; menu = menu->next) {
                        dep = menu->prompt ? menu->prompt->visible.expr : menu->dep;
                        if (!expr_contains_symbol(dep, sym))
+                               /* No dependency, quit */
                                break;
                        if (expr_depends_symbol(dep, sym))
+                               /* Absolute dependency, put in submenu */
                                goto next;
+
+                       /*
+                        * Also consider it a dependency on sym if our
+                        * dependencies contain sym and are a "superset" of
+                        * sym's dependencies, e.g. '(sym || Q) && R' when sym
+                        * depends on R.
+                        *
+                        * Note that 'R' might be from an enclosing menu or if,
+                        * making this a more common case than it might seem.
+                        */
                        dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no);
                        dep = expr_eliminate_dups(expr_transform(dep));
                        dep2 = expr_copy(basedep);
                        expr_eliminate_eq(&dep, &dep2);
                        expr_free(dep);
                        if (!expr_is_yes(dep2)) {
+                               /* Not superset, quit */
                                expr_free(dep2);
                                break;
                        }
+                       /* Superset, put in submenu */
                        expr_free(dep2);
                next:
                        menu_finalize(menu);