1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
13 static const char nohelp_text[] = "There is no help available for this option.";
16 static struct menu **last_entry_ptr;
18 struct file *file_list;
19 struct file *current_file;
21 void menu_warn(struct menu *menu, const char *fmt, ...)
25 fprintf(stderr, "%s:%d:warning: ", menu->file->name, menu->lineno);
26 vfprintf(stderr, fmt, ap);
27 fprintf(stderr, "\n");
31 static void prop_warn(struct property *prop, const char *fmt, ...)
35 fprintf(stderr, "%s:%d:warning: ", prop->file->name, prop->lineno);
36 vfprintf(stderr, fmt, ap);
37 fprintf(stderr, "\n");
43 current_entry = current_menu = &rootmenu;
44 last_entry_ptr = &rootmenu.list;
47 void menu_add_entry(struct symbol *sym)
51 menu = xmalloc(sizeof(*menu));
52 memset(menu, 0, sizeof(*menu));
54 menu->parent = current_menu;
55 menu->file = current_file;
56 menu->lineno = zconf_lineno();
58 *last_entry_ptr = menu;
59 last_entry_ptr = &menu->next;
62 menu_add_symbol(P_SYMBOL, sym, NULL);
65 struct menu *menu_add_menu(void)
67 last_entry_ptr = ¤t_entry->list;
68 current_menu = current_entry;
72 void menu_end_menu(void)
74 last_entry_ptr = ¤t_menu->next;
75 current_menu = current_menu->parent;
79 * Rewrites 'm' to 'm' && MODULES, so that it evaluates to 'n' when running
82 static struct expr *rewrite_m(struct expr *e)
89 e->left.expr = rewrite_m(e->left.expr);
93 e->left.expr = rewrite_m(e->left.expr);
94 e->right.expr = rewrite_m(e->right.expr);
97 /* change 'm' into 'm' && MODULES */
98 if (e->left.sym == &symbol_mod)
99 return expr_alloc_and(e, expr_alloc_symbol(modules_sym));
107 void menu_add_dep(struct expr *dep)
109 current_entry->dep = expr_alloc_and(current_entry->dep, dep);
112 void menu_set_type(int type)
114 struct symbol *sym = current_entry->sym;
116 if (sym->type == type)
118 if (sym->type == S_UNKNOWN) {
122 menu_warn(current_entry,
123 "ignoring type redefinition of '%s' from '%s' to '%s'",
124 sym->name ? sym->name : "<choice>",
125 sym_type_name(sym->type), sym_type_name(type));
128 static struct property *menu_add_prop(enum prop_type type, struct expr *expr,
131 struct property *prop;
133 prop = xmalloc(sizeof(*prop));
134 memset(prop, 0, sizeof(*prop));
136 prop->file = current_file;
137 prop->lineno = zconf_lineno();
138 prop->menu = current_entry;
140 prop->visible.expr = dep;
142 /* append property to the prop list of symbol */
143 if (current_entry->sym) {
144 struct property **propp;
146 for (propp = ¤t_entry->sym->prop;
148 propp = &(*propp)->next)
156 struct property *menu_add_prompt(enum prop_type type, char *prompt,
159 struct property *prop = menu_add_prop(type, NULL, dep);
161 if (isspace(*prompt)) {
162 prop_warn(prop, "leading whitespace ignored");
163 while (isspace(*prompt))
166 if (current_entry->prompt)
167 prop_warn(prop, "prompt redefined");
169 /* Apply all upper menus' visibilities to actual prompts. */
170 if (type == P_PROMPT) {
171 struct menu *menu = current_entry;
173 while ((menu = menu->parent) != NULL) {
174 struct expr *dup_expr;
176 if (!menu->visibility)
179 * Do not add a reference to the menu's visibility
180 * expression but use a copy of it. Otherwise the
181 * expression reduction functions will modify
182 * expressions that have multiple references which
183 * can cause unwanted side effects.
185 dup_expr = expr_copy(menu->visibility);
187 prop->visible.expr = expr_alloc_and(prop->visible.expr,
192 current_entry->prompt = prop;
198 void menu_add_visibility(struct expr *expr)
200 current_entry->visibility = expr_alloc_and(current_entry->visibility,
204 void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep)
206 menu_add_prop(type, expr, dep);
209 void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep)
211 menu_add_prop(type, expr_alloc_symbol(sym), dep);
214 void menu_add_option_modules(void)
217 zconf_error("symbol '%s' redefines option 'modules' already defined by symbol '%s'",
218 current_entry->sym->name, modules_sym->name);
219 modules_sym = current_entry->sym;
222 void menu_add_option_allnoconfig_y(void)
224 current_entry->sym->flags |= SYMBOL_ALLNOCONFIG_Y;
227 static int menu_validate_number(struct symbol *sym, struct symbol *sym2)
229 return sym2->type == S_INT || sym2->type == S_HEX ||
230 (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name));
233 static void sym_check_prop(struct symbol *sym)
235 struct property *prop;
239 for (prop = sym->prop; prop; prop = prop->next) {
240 switch (prop->type) {
242 if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) &&
243 prop->expr->type != E_SYMBOL)
245 "default for config symbol '%s'"
246 " must be a single symbol", sym->name);
247 if (prop->expr->type != E_SYMBOL)
249 sym2 = prop_get_symbol(prop);
250 if (sym->type == S_HEX || sym->type == S_INT) {
251 if (!menu_validate_number(sym, sym2))
253 "'%s': number is invalid",
256 if (sym_is_choice(sym)) {
257 struct property *choice_prop =
258 sym_get_choice_prop(sym2);
261 prop_get_symbol(choice_prop) != sym)
263 "choice default symbol '%s' is not contained in the choice",
269 use = prop->type == P_SELECT ? "select" : "imply";
270 sym2 = prop_get_symbol(prop);
271 if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE)
273 "config symbol '%s' uses %s, but is "
274 "not bool or tristate", sym->name, use);
275 else if (sym2->type != S_UNKNOWN &&
276 sym2->type != S_BOOLEAN &&
277 sym2->type != S_TRISTATE)
279 "'%s' has wrong type. '%s' only "
280 "accept arguments of bool and "
281 "tristate type", sym2->name, use);
284 if (sym->type != S_INT && sym->type != S_HEX)
285 prop_warn(prop, "range is only allowed "
286 "for int or hex symbols");
287 if (!menu_validate_number(sym, prop->expr->left.sym) ||
288 !menu_validate_number(sym, prop->expr->right.sym))
289 prop_warn(prop, "range is invalid");
297 void menu_finalize(struct menu *parent)
299 struct menu *menu, *last_menu;
301 struct property *prop;
302 struct expr *parentdep, *basedep, *dep, *dep2, **ep;
307 * This menu node has children. We (recursively) process them
308 * and propagate parent dependencies before moving on.
311 if (sym && sym_is_choice(sym)) {
312 if (sym->type == S_UNKNOWN) {
313 /* find the first choice value to find out choice type */
314 current_entry = parent;
315 for (menu = parent->list; menu; menu = menu->next) {
316 if (menu->sym && menu->sym->type != S_UNKNOWN) {
317 menu_set_type(menu->sym->type);
322 /* set the type of the remaining choice values */
323 for (menu = parent->list; menu; menu = menu->next) {
324 current_entry = menu;
325 if (menu->sym && menu->sym->type == S_UNKNOWN)
326 menu_set_type(sym->type);
330 * Use the choice itself as the parent dependency of
331 * the contained items. This turns the mode of the
332 * choice into an upper bound on the visibility of the
333 * choice value symbols.
335 parentdep = expr_alloc_symbol(sym);
337 /* Menu node for 'menu', 'if' */
338 parentdep = parent->dep;
341 /* For each child menu node... */
342 for (menu = parent->list; menu; menu = menu->next) {
344 * Propagate parent dependencies to the child menu
345 * node, also rewriting and simplifying expressions
347 basedep = rewrite_m(menu->dep);
348 basedep = expr_transform(basedep);
349 basedep = expr_alloc_and(expr_copy(parentdep), basedep);
350 basedep = expr_eliminate_dups(basedep);
355 * Note: For symbols, all prompts are included
356 * too in the symbol's own property list
358 prop = menu->sym->prop;
361 * For non-symbol menu nodes, we just need to
366 /* For each property... */
367 for (; prop; prop = prop->next) {
368 if (prop->menu != menu)
372 * 1. The property lacks dependencies
373 * and so isn't location-specific,
376 * 2. The property belongs to a symbol
377 * defined in multiple locations and
378 * is from some other location. It
379 * will be handled there in that
387 * Propagate parent dependencies to the
388 * property's condition, rewriting and
389 * simplifying expressions at the same time
391 dep = rewrite_m(prop->visible.expr);
392 dep = expr_transform(dep);
393 dep = expr_alloc_and(expr_copy(basedep), dep);
394 dep = expr_eliminate_dups(dep);
395 if (menu->sym && menu->sym->type != S_TRISTATE)
396 dep = expr_trans_bool(dep);
397 prop->visible.expr = dep;
400 * Handle selects and implies, which modify the
401 * dependencies of the selected/implied symbol
403 if (prop->type == P_SELECT) {
404 struct symbol *es = prop_get_symbol(prop);
405 es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr,
406 expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep)));
407 } else if (prop->type == P_IMPLY) {
408 struct symbol *es = prop_get_symbol(prop);
409 es->implied.expr = expr_alloc_or(es->implied.expr,
410 expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep)));
415 if (sym && sym_is_choice(sym))
416 expr_free(parentdep);
419 * Recursively process children in the same fashion before
422 for (menu = parent->list; menu; menu = menu->next)
426 * Automatic submenu creation. If sym is a symbol and A, B, C,
427 * ... are consecutive items (symbols, menus, ifs, etc.) that
428 * all depend on sym, then the following menu structure is
437 * This also works recursively, giving the following structure
438 * if A is a symbol and B depends on A:
447 basedep = parent->prompt ? parent->prompt->visible.expr : NULL;
448 basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no);
449 basedep = expr_eliminate_dups(expr_transform(basedep));
451 /* Examine consecutive elements after sym */
453 for (menu = parent->next; menu; menu = menu->next) {
454 dep = menu->prompt ? menu->prompt->visible.expr : menu->dep;
455 if (!expr_contains_symbol(dep, sym))
456 /* No dependency, quit */
458 if (expr_depends_symbol(dep, sym))
459 /* Absolute dependency, put in submenu */
463 * Also consider it a dependency on sym if our
464 * dependencies contain sym and are a "superset" of
465 * sym's dependencies, e.g. '(sym || Q) && R' when sym
468 * Note that 'R' might be from an enclosing menu or if,
469 * making this a more common case than it might seem.
471 dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no);
472 dep = expr_eliminate_dups(expr_transform(dep));
473 dep2 = expr_copy(basedep);
474 expr_eliminate_eq(&dep, &dep2);
476 if (!expr_is_yes(dep2)) {
477 /* Not superset, quit */
481 /* Superset, put in submenu */
485 menu->parent = parent;
490 parent->list = parent->next;
491 parent->next = last_menu->next;
492 last_menu->next = NULL;
495 sym->dir_dep.expr = expr_alloc_or(sym->dir_dep.expr, parent->dep);
497 for (menu = parent->list; menu; menu = menu->next) {
498 if (sym && sym_is_choice(sym) &&
499 menu->sym && !sym_is_choice_value(menu->sym)) {
500 current_entry = menu;
501 menu->sym->flags |= SYMBOL_CHOICEVAL;
503 menu_warn(menu, "choice value must have a prompt");
504 for (prop = menu->sym->prop; prop; prop = prop->next) {
505 if (prop->type == P_DEFAULT)
506 prop_warn(prop, "defaults for choice "
507 "values not supported");
508 if (prop->menu == menu)
510 if (prop->type == P_PROMPT &&
511 prop->menu->parent->sym != sym)
512 prop_warn(prop, "choice value used outside its choice group");
514 /* Non-tristate choice values of tristate choices must
515 * depend on the choice being set to Y. The choice
516 * values' dependencies were propagated to their
517 * properties above, so the change here must be re-
520 if (sym->type == S_TRISTATE && menu->sym->type != S_TRISTATE) {
521 basedep = expr_alloc_comp(E_EQUAL, sym, &symbol_yes);
522 menu->dep = expr_alloc_and(basedep, menu->dep);
523 for (prop = menu->sym->prop; prop; prop = prop->next) {
524 if (prop->menu != menu)
526 prop->visible.expr = expr_alloc_and(expr_copy(basedep),
530 menu_add_symbol(P_CHOICE, sym, NULL);
531 prop = sym_get_choice_prop(sym);
532 for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr)
534 *ep = expr_alloc_one(E_LIST, NULL);
535 (*ep)->right.sym = menu->sym;
539 * This code serves two purposes:
541 * (1) Flattening 'if' blocks, which do not specify a submenu
542 * and only add dependencies.
544 * (Automatic submenu creation might still create a submenu
545 * from an 'if' before this code runs.)
547 * (2) "Undoing" any automatic submenus created earlier below
548 * promptless symbols.
553 * if ... (or promptless symbol)
561 * if ... (or promptless symbol)
566 if (menu->list && (!menu->prompt || !menu->prompt->text)) {
567 for (last_menu = menu->list; ; last_menu = last_menu->next) {
568 last_menu->parent = parent;
569 if (!last_menu->next)
572 last_menu->next = menu->next;
573 menu->next = menu->list;
578 if (sym && !(sym->flags & SYMBOL_WARNED)) {
579 if (sym->type == S_UNKNOWN)
580 menu_warn(parent, "config symbol defined without type");
582 if (sym_is_choice(sym) && !parent->prompt)
583 menu_warn(parent, "choice must have a prompt");
585 /* Check properties connected to this symbol */
587 sym->flags |= SYMBOL_WARNED;
591 * For non-optional choices, add a reverse dependency (corresponding to
592 * a select) of '<visibility> && m'. This prevents the user from
593 * setting the choice mode to 'n' when the choice is visible.
595 * This would also work for non-choice symbols, but only non-optional
596 * choices clear SYMBOL_OPTIONAL as of writing. Choices are implemented
597 * as a type of symbol.
599 if (sym && !sym_is_optional(sym) && parent->prompt) {
600 sym->rev_dep.expr = expr_alloc_or(sym->rev_dep.expr,
601 expr_alloc_and(parent->prompt->visible.expr,
602 expr_alloc_symbol(&symbol_mod)));
606 bool menu_has_prompt(struct menu *menu)
614 * Determine if a menu is empty.
615 * A menu is considered empty if it contains no or only
618 bool menu_is_empty(struct menu *menu)
622 for (child = menu->list; child; child = child->next) {
623 if (menu_is_visible(child))
629 bool menu_is_visible(struct menu *menu)
638 if (menu->visibility) {
639 if (expr_calc_value(menu->visibility) == no)
646 visible = menu->prompt->visible.tri;
648 visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr);
653 if (!sym || sym_get_tristate_value(menu->sym) == no)
656 for (child = menu->list; child; child = child->next) {
657 if (menu_is_visible(child)) {
659 sym->flags |= SYMBOL_DEF_USER;
667 const char *menu_get_prompt(struct menu *menu)
670 return menu->prompt->text;
672 return menu->sym->name;
676 struct menu *menu_get_root_menu(struct menu *menu)
681 struct menu *menu_get_parent_menu(struct menu *menu)
685 for (; menu != &rootmenu; menu = menu->parent) {
686 type = menu->prompt ? menu->prompt->type : 0;
693 bool menu_has_help(struct menu *menu)
695 return menu->help != NULL;
698 const char *menu_get_help(struct menu *menu)
706 static void get_def_str(struct gstr *r, struct menu *menu)
708 str_printf(r, "Defined at %s:%d\n",
709 menu->file->name, menu->lineno);
712 static void get_dep_str(struct gstr *r, struct expr *expr, const char *prefix)
714 if (!expr_is_yes(expr)) {
715 str_append(r, prefix);
716 expr_gstr_print(expr, r);
721 static void get_prompt_str(struct gstr *r, struct property *prop,
722 struct list_head *head)
725 struct menu *submenu[8], *menu, *location = NULL;
726 struct jump_key *jump = NULL;
728 str_printf(r, " Prompt: %s\n", prop->text);
730 get_dep_str(r, prop->menu->dep, " Depends on: ");
732 * Most prompts in Linux have visibility that exactly matches their
733 * dependencies. For these, we print only the dependencies to improve
734 * readability. However, prompts with inline "if" expressions and
735 * prompts with a parent that has a "visible if" expression have
736 * differing dependencies and visibility. In these rare cases, we
739 if (!expr_eq(prop->menu->dep, prop->visible.expr))
740 get_dep_str(r, prop->visible.expr, " Visible if: ");
742 menu = prop->menu->parent;
743 for (i = 0; menu != &rootmenu && i < 8; menu = menu->parent) {
744 bool accessible = menu_is_visible(menu);
747 if (location == NULL && accessible)
750 if (head && location) {
751 jump = xmalloc(sizeof(struct jump_key));
753 if (menu_is_visible(prop->menu)) {
755 * There is not enough room to put the hint at the
756 * beginning of the "Prompt" line. Put the hint on the
757 * last "Location" line even when it would belong on
760 jump->target = prop->menu;
762 jump->target = location;
764 if (list_empty(head))
767 jump->index = list_entry(head->prev, struct jump_key,
770 list_add_tail(&jump->entries, head);
774 str_printf(r, " Location:\n");
775 for (j = 4; --i >= 0; j += 2) {
777 if (jump && menu == location)
778 jump->offset = strlen(r->s);
779 str_printf(r, "%*c-> %s", j, ' ',
780 menu_get_prompt(menu));
782 str_printf(r, " (%s [=%s])", menu->sym->name ?
783 menu->sym->name : "<choice>",
784 sym_get_string_value(menu->sym));
791 static void get_symbol_props_str(struct gstr *r, struct symbol *sym,
792 enum prop_type tok, const char *prefix)
795 struct property *prop;
797 for_all_properties(sym, prop, tok) {
799 str_append(r, prefix);
802 str_printf(r, " && ");
803 expr_gstr_print(prop->expr, r);
810 * head is optional and may be NULL
812 static void get_symbol_str(struct gstr *r, struct symbol *sym,
813 struct list_head *head)
815 struct property *prop;
817 if (sym && sym->name) {
818 str_printf(r, "Symbol: %s [=%s]\n", sym->name,
819 sym_get_string_value(sym));
820 str_printf(r, "Type : %s\n", sym_type_name(sym->type));
821 if (sym->type == S_INT || sym->type == S_HEX) {
822 prop = sym_get_range_prop(sym);
824 str_printf(r, "Range : ");
825 expr_gstr_print(prop->expr, r);
831 /* Print the definitions with prompts before the ones without */
832 for_all_properties(sym, prop, P_SYMBOL) {
833 if (prop->menu->prompt) {
834 get_def_str(r, prop->menu);
835 get_prompt_str(r, prop->menu->prompt, head);
839 for_all_properties(sym, prop, P_SYMBOL) {
840 if (!prop->menu->prompt) {
841 get_def_str(r, prop->menu);
842 get_dep_str(r, prop->menu->dep, " Depends on: ");
846 get_symbol_props_str(r, sym, P_SELECT, "Selects: ");
847 if (sym->rev_dep.expr) {
848 expr_gstr_print_revdep(sym->rev_dep.expr, r, yes, "Selected by [y]:\n");
849 expr_gstr_print_revdep(sym->rev_dep.expr, r, mod, "Selected by [m]:\n");
850 expr_gstr_print_revdep(sym->rev_dep.expr, r, no, "Selected by [n]:\n");
853 get_symbol_props_str(r, sym, P_IMPLY, "Implies: ");
854 if (sym->implied.expr) {
855 expr_gstr_print_revdep(sym->implied.expr, r, yes, "Implied by [y]:\n");
856 expr_gstr_print_revdep(sym->implied.expr, r, mod, "Implied by [m]:\n");
857 expr_gstr_print_revdep(sym->implied.expr, r, no, "Implied by [n]:\n");
860 str_append(r, "\n\n");
863 struct gstr get_relations_str(struct symbol **sym_arr, struct list_head *head)
866 struct gstr res = str_new();
869 for (i = 0; sym_arr && (sym = sym_arr[i]); i++)
870 get_symbol_str(&res, sym, head);
872 str_append(&res, "No matches found.\n");
877 void menu_get_ext_help(struct menu *menu, struct gstr *help)
879 struct symbol *sym = menu->sym;
880 const char *help_text = nohelp_text;
882 if (menu_has_help(menu)) {
884 str_printf(help, "%s%s:\n\n", CONFIG_, sym->name);
885 help_text = menu_get_help(menu);
887 str_printf(help, "%s\n", help_text);
889 get_symbol_str(help, sym, NULL);