1 files changed, 310 insertions, 33 deletions

diff --git a/scripts/kconfig/symbol.c b/scripts/kconfig/symbol.c
index 2e7a048e0cfc..c0efe102d655 100644
--- a/scripts/kconfig/symbol.c
+++ b/scripts/kconfig/symbol.c
@@ -205,6 +205,16 @@ static void sym_calc_visibility(struct symbol *sym)
         }
         if (sym_is_choice_value(sym))
                 return;
+        /* defaulting to "yes" if no explicit "depends on" are given */
+        tri = yes;
+        if (sym->dir_dep.expr)
+                tri = expr_calc_value(sym->dir_dep.expr);
+        if (tri == mod)
+                tri = yes;
+        if (sym->dir_dep.tri != tri) {
+                sym->dir_dep.tri = tri;
+                sym_set_changed(sym);
+        }
         tri = no;
         if (sym->rev_dep.expr)
                 tri = expr_calc_value(sym->rev_dep.expr);
@@ -216,44 +226,63 @@ static void sym_calc_visibility(struct symbol *sym)
         }
 }
 
-static struct symbol *sym_calc_choice(struct symbol *sym)
+/*
+ * Find the default symbol for a choice.
+ * First try the default values for the choice symbol
+ * Next locate the first visible choice value
+ * Return NULL if none was found
+ */
+struct symbol *sym_choice_default(struct symbol *sym)
 {
         struct symbol *def_sym;
         struct property *prop;
         struct expr *e;
 
-        /* is the user choice visible? */
-        def_sym = sym->def[S_DEF_USER].val;
-        if (def_sym) {
-                sym_calc_visibility(def_sym);
-                if (def_sym->visible != no)
-                        return def_sym;
-        }
-
         /* any of the defaults visible? */
         for_all_defaults(sym, prop) {
                 prop->visible.tri = expr_calc_value(prop->visible.expr);
                 if (prop->visible.tri == no)
                         continue;
                 def_sym = prop_get_symbol(prop);
-                sym_calc_visibility(def_sym);
                 if (def_sym->visible != no)
                         return def_sym;
         }
 
         /* just get the first visible value */
         prop = sym_get_choice_prop(sym);
-        expr_list_for_each_sym(prop->expr, e, def_sym) {
-                sym_calc_visibility(def_sym);
+        expr_list_for_each_sym(prop->expr, e, def_sym)
                 if (def_sym->visible != no)
                         return def_sym;
-        }
 
-        /* no choice? reset tristate value */
-        sym->curr.tri = no;
+        /* failed to locate any defaults */
         return NULL;
 }
 
+static struct symbol *sym_calc_choice(struct symbol *sym)
+{
+        struct symbol *def_sym;
+        struct property *prop;
+        struct expr *e;
+
+        /* first calculate all choice values' visibilities */
+        prop = sym_get_choice_prop(sym);
+        expr_list_for_each_sym(prop->expr, e, def_sym)
+                sym_calc_visibility(def_sym);
+
+        /* is the user choice visible? */
+        def_sym = sym->def[S_DEF_USER].val;
+        if (def_sym && def_sym->visible != no)
+                return def_sym;
+
+        def_sym = sym_choice_default(sym);
+
+        if (def_sym == NULL)
+                /* no choice? reset tristate value */
+                sym->curr.tri = no;
+
+        return def_sym;
+}
+
 void sym_calc_value(struct symbol *sym)
 {
         struct symbol_value newval, oldval;
@@ -321,6 +350,14 @@ void sym_calc_value(struct symbol *sym)
                                 }
                         }
                 calc_newval:
+                        if (sym->dir_dep.tri == no && sym->rev_dep.tri != no) {
+                                fprintf(stderr, "warning: (");
+                                expr_fprint(sym->rev_dep.expr, stderr);
+                                fprintf(stderr, ") selects %s which has unmet direct dependencies (",
+                                        sym->name);
+                                expr_fprint(sym->dir_dep.expr, stderr);
+                                fprintf(stderr, ")\n");
+                        }
                         newval.tri = EXPR_OR(newval.tri, sym->rev_dep.tri);
                 }
                 if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN)
@@ -365,12 +402,13 @@ void sym_calc_value(struct symbol *sym)
 
         if (sym_is_choice(sym)) {
                 struct symbol *choice_sym;
-                int flags = sym->flags & (SYMBOL_CHANGED | SYMBOL_WRITE);
 
                 prop = sym_get_choice_prop(sym);
                 expr_list_for_each_sym(prop->expr, e, choice_sym) {
-                        choice_sym->flags |= flags;
-                        if (flags & SYMBOL_CHANGED)
+                        if ((sym->flags & SYMBOL_WRITE) &&
+                            choice_sym->visible != no)
+                                choice_sym->flags |= SYMBOL_WRITE;
+                        if (sym->flags & SYMBOL_CHANGED)
                                 sym_set_changed(choice_sym);
                 }
         }
@@ -623,6 +661,80 @@ bool sym_set_string_value(struct symbol *sym, const char *newval)
         return true;
 }
 
+/*
+ * Find the default value associated to a symbol.
+ * For tristate symbol handle the modules=n case
+ * in which case "m" becomes "y".
+ * If the symbol does not have any default then fallback
+ * to the fixed default values.
+ */
+const char *sym_get_string_default(struct symbol *sym)
+{
+        struct property *prop;
+        struct symbol *ds;
+        const char *str;
+        tristate val;
+
+        sym_calc_visibility(sym);
+        sym_calc_value(modules_sym);
+        val = symbol_no.curr.tri;
+        str = symbol_empty.curr.val;
+
+        /* If symbol has a default value look it up */
+        prop = sym_get_default_prop(sym);
+        if (prop != NULL) {
+                switch (sym->type) {
+                case S_BOOLEAN:
+                case S_TRISTATE:
+                        /* The visibility imay limit the value from yes => mod */
+                        val = EXPR_AND(expr_calc_value(prop->expr), prop->visible.tri);
+                        break;
+                default:
+                        /*
+                         * The following fails to handle the situation
+                         * where a default value is further limited by
+                         * the valid range.
+                         */
+                        ds = prop_get_symbol(prop);
+                        if (ds != NULL) {
+                                sym_calc_value(ds);
+                                str = (const char *)ds->curr.val;
+                        }
+                }
+        }
+
+        /* Handle select statements */
+        val = EXPR_OR(val, sym->rev_dep.tri);
+
+        /* transpose mod to yes if modules are not enabled */
+        if (val == mod)
+                if (!sym_is_choice_value(sym) && modules_sym->curr.tri == no)
+                        val = yes;
+
+        /* transpose mod to yes if type is bool */
+        if (sym->type == S_BOOLEAN && val == mod)
+                val = yes;
+
+        switch (sym->type) {
+        case S_BOOLEAN:
+        case S_TRISTATE:
+                switch (val) {
+                case no: return "n";
+                case mod: return "m";
+                case yes: return "y";
+                }
+        case S_INT:
+        case S_HEX:
+                return str;
+        case S_STRING:
+                return str;
+        case S_OTHER:
+        case S_UNKNOWN:
+                break;
+        }
+        return "";
+}
+
 const char *sym_get_string_value(struct symbol *sym)
 {
         tristate val;
@@ -728,6 +840,55 @@ struct symbol *sym_find(const char *name)
         return symbol;
 }
 
+/*
+ * Expand symbol's names embedded in the string given in argument. Symbols'
+ * name to be expanded shall be prefixed by a '$'. Unknown symbol expands to
+ * the empty string.
+ */
+const char *sym_expand_string_value(const char *in)
+{
+        const char *src;
+        char *res;
+        size_t reslen;
+
+        reslen = strlen(in) + 1;
+        res = malloc(reslen);
+        res[0] = '\0';
+
+        while ((src = strchr(in, '$'))) {
+                char *p, name[SYMBOL_MAXLENGTH];
+                const char *symval = "";
+                struct symbol *sym;
+                size_t newlen;
+
+                strncat(res, in, src - in);
+                src++;
+
+                p = name;
+                while (isalnum(*src) || *src == '_')
+                        *p++ = *src++;
+                *p = '\0';
+
+                sym = sym_find(name);
+                if (sym != NULL) {
+                        sym_calc_value(sym);
+                        symval = sym_get_string_value(sym);
+                }
+
+                newlen = strlen(res) + strlen(symval) + strlen(src);
+                if (newlen > reslen) {
+                        reslen = newlen;
+                        res = realloc(res, reslen);
+                }
+
+                strcat(res, symval);
+                in = src;
+        }
+        strcat(res, in);
+
+        return res;
+}
+
 struct symbol **sym_re_search(const char *pattern)
 {
         struct symbol *sym, **sym_arr = NULL;
@@ -765,6 +926,112 @@ struct symbol **sym_re_search(const char *pattern)
         return sym_arr;
 }
 
+/*
+ * When we check for recursive dependencies we use a stack to save
+ * current state so we can print out relevant info to user.
+ * The entries are located on the call stack so no need to free memory.
+ * Note inser() remove() must always match to properly clear the stack.
+ */
+static struct dep_stack {
+        struct dep_stack *prev, *next;
+        struct symbol *sym;
+        struct property *prop;
+        struct expr *expr;
+} *check_top;
+
+static void dep_stack_insert(struct dep_stack *stack, struct symbol *sym)
+{
+        memset(stack, 0, sizeof(*stack));
+        if (check_top)
+                check_top->next = stack;
+        stack->prev = check_top;
+        stack->sym = sym;
+        check_top = stack;
+}
+
+static void dep_stack_remove(void)
+{
+        check_top = check_top->prev;
+        if (check_top)
+                check_top->next = NULL;
+}
+
+/*
+ * Called when we have detected a recursive dependency.
+ * check_top point to the top of the stact so we use
+ * the ->prev pointer to locate the bottom of the stack.
+ */
+static void sym_check_print_recursive(struct symbol *last_sym)
+{
+        struct dep_stack *stack;
+        struct symbol *sym, *next_sym;
+        struct menu *menu = NULL;
+        struct property *prop;
+        struct dep_stack cv_stack;
+
+        if (sym_is_choice_value(last_sym)) {
+                dep_stack_insert(&cv_stack, last_sym);
+                last_sym = prop_get_symbol(sym_get_choice_prop(last_sym));
+        }
+
+        for (stack = check_top; stack != NULL; stack = stack->prev)
+                if (stack->sym == last_sym)
+                        break;
+        if (!stack) {
+                fprintf(stderr, "unexpected recursive dependency error\n");
+                return;
+        }
+
+        for (; stack; stack = stack->next) {
+                sym = stack->sym;
+                next_sym = stack->next ? stack->next->sym : last_sym;
+                prop = stack->prop;
+                if (prop == NULL)
+                        prop = stack->sym->prop;
+
+                /* for choice values find the menu entry (used below) */
+                if (sym_is_choice(sym) || sym_is_choice_value(sym)) {
+                        for (prop = sym->prop; prop; prop = prop->next) {
+                                menu = prop->menu;
+                                if (prop->menu)
+                                        break;
+                        }
+                }
+                if (stack->sym == last_sym)
+                        fprintf(stderr, "%s:%d:error: recursive dependency detected!\n",
+                                prop->file->name, prop->lineno);
+                if (stack->expr) {
+                        fprintf(stderr, "%s:%d:\tsymbol %s %s value contains %s\n",
+                                prop->file->name, prop->lineno,
+                                sym->name ? sym->name : "<choice>",
+                                prop_get_type_name(prop->type),
+                                next_sym->name ? next_sym->name : "<choice>");
+                } else if (stack->prop) {
+                        fprintf(stderr, "%s:%d:\tsymbol %s depends on %s\n",
+                                prop->file->name, prop->lineno,
+                                sym->name ? sym->name : "<choice>",
+                                next_sym->name ? next_sym->name : "<choice>");
+                } else if (sym_is_choice(sym)) {
+                        fprintf(stderr, "%s:%d:\tchoice %s contains symbol %s\n",
+                                menu->file->name, menu->lineno,
+                                sym->name ? sym->name : "<choice>",
+                                next_sym->name ? next_sym->name : "<choice>");
+                } else if (sym_is_choice_value(sym)) {
+                        fprintf(stderr, "%s:%d:\tsymbol %s is part of choice %s\n",
+                                menu->file->name, menu->lineno,
+                                sym->name ? sym->name : "<choice>",
+                                next_sym->name ? next_sym->name : "<choice>");
+                } else {
+                        fprintf(stderr, "%s:%d:\tsymbol %s is selected by %s\n",
+                                prop->file->name, prop->lineno,
+                                sym->name ? sym->name : "<choice>",
+                                next_sym->name ? next_sym->name : "<choice>");
+                }
+        }
+
+        if (check_top == &cv_stack)
+                dep_stack_remove();
+}
 
 static struct symbol *sym_check_expr_deps(struct expr *e)
 {
@@ -801,24 +1068,33 @@ static struct symbol *sym_check_sym_deps(struct symbol *sym)
 {
         struct symbol *sym2;
         struct property *prop;
+        struct dep_stack stack;
+
+        dep_stack_insert(&stack, sym);
 
         sym2 = sym_check_expr_deps(sym->rev_dep.expr);
         if (sym2)
-                return sym2;
+                goto out;
 
         for (prop = sym->prop; prop; prop = prop->next) {
                 if (prop->type == P_CHOICE || prop->type == P_SELECT)
                         continue;
+                stack.prop = prop;
                 sym2 = sym_check_expr_deps(prop->visible.expr);
                 if (sym2)
                         break;
                 if (prop->type != P_DEFAULT || sym_is_choice(sym))
                         continue;
+                stack.expr = prop->expr;
                 sym2 = sym_check_expr_deps(prop->expr);
                 if (sym2)
                         break;
+                stack.expr = NULL;
         }
 
+out:
+        dep_stack_remove();
+
         return sym2;
 }
 
@@ -827,6 +1103,9 @@ static struct symbol *sym_check_choice_deps(struct symbol *choice)
         struct symbol *sym, *sym2;
         struct property *prop;
         struct expr *e;
+        struct dep_stack stack;
+
+        dep_stack_insert(&stack, choice);
 
         prop = sym_get_choice_prop(choice);
         expr_list_for_each_sym(prop->expr, e, sym)
@@ -840,10 +1119,8 @@ static struct symbol *sym_check_choice_deps(struct symbol *choice)
 
         expr_list_for_each_sym(prop->expr, e, sym) {
                 sym2 = sym_check_sym_deps(sym);
-                if (sym2) {
-                        fprintf(stderr, " -> %s", sym->name);
+                if (sym2)
                         break;
-                }
         }
 out:
         expr_list_for_each_sym(prop->expr, e, sym)
@@ -853,6 +1130,8 @@ out:
             prop_get_symbol(sym_get_choice_prop(sym2)) == choice)
                 sym2 = choice;
 
+        dep_stack_remove();
+
         return sym2;
 }
 
@@ -862,18 +1141,20 @@ struct symbol *sym_check_deps(struct symbol *sym)
         struct property *prop;
 
         if (sym->flags & SYMBOL_CHECK) {
-                fprintf(stderr, "%s:%d:error: found recursive dependency: %s",
-                        sym->prop->file->name, sym->prop->lineno,
-                        sym->name ? sym->name : "<choice>");
+                sym_check_print_recursive(sym);
                 return sym;
         }
         if (sym->flags & SYMBOL_CHECKED)
                 return NULL;
 
         if (sym_is_choice_value(sym)) {
+                struct dep_stack stack;
+
                 /* for choice groups start the check with main choice symbol */
+                dep_stack_insert(&stack, sym);
                 prop = sym_get_choice_prop(sym);
                 sym2 = sym_check_deps(prop_get_symbol(prop));
+                dep_stack_remove();
         } else if (sym_is_choice(sym)) {
                 sym2 = sym_check_choice_deps(sym);
         } else {
@@ -882,14 +1163,8 @@ struct symbol *sym_check_deps(struct symbol *sym)
                 sym->flags &= ~SYMBOL_CHECK;
         }
 
-        if (sym2) {
-                fprintf(stderr, " -> %s", sym->name ? sym->name : "<choice>");
-                if (sym2 == sym) {
-                        fprintf(stderr, "\n");
-                        zconfnerrs++;
-                        sym2 = NULL;
-                }
-        }
+        if (sym2 && sym2 == sym)
+                sym2 = NULL;
 
         return sym2;
 }
@@ -943,6 +1218,8 @@ const char *prop_get_type_name(enum prop_type type)
                 return "select";
         case P_RANGE:
                 return "range";
+        case P_SYMBOL:
+                return "symbol";
         case P_UNKNOWN:
                 break;
         }