Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org> */
#include <ctype.h>#include <stdarg.h>#include <stdlib.h>#include <string.h>
#include <list.h>#include <xalloc.h>#include "lkc.h"#include "internal.h"
static const char nohelp_text[] = "There is no help available for this option.";
struct menu rootmenu = { .type = M_MENU };static struct menu **last_entry_ptr;
/** * menu_next - return the next menu entry with depth-first traversal * @menu: pointer to the current menu * @root: root of the sub-tree to traverse. If NULL is given, the traveral * continues until it reaches the end of the entire menu tree. * return: the menu to visit next, or NULL when it reaches the end. */struct menu *menu_next(struct menu *menu, struct menu *root){ if (menu->list) return menu->list;
while (menu != root && !menu->next) menu = menu->parent;
if (menu == root) return NULL;
return menu->next;}
void menu_warn(const struct menu *menu, const char *fmt, ...){ va_list ap; va_start(ap, fmt); fprintf(stderr, "%s:%d:warning: ", menu->filename, menu->lineno); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap);}
static void prop_warn(const struct property *prop, const char *fmt, ...){ va_list ap; va_start(ap, fmt); fprintf(stderr, "%s:%d:warning: ", prop->filename, prop->lineno); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap);}
void _menu_init(void){ current_entry = current_menu = &rootmenu; last_entry_ptr = &rootmenu.list;}
void menu_add_entry(struct symbol *sym, enum menu_type type){ struct menu *menu;
menu = xmalloc(sizeof(*menu)); memset(menu, 0, sizeof(*menu)); menu->type = type; menu->sym = sym; menu->parent = current_menu; menu->filename = cur_filename; menu->lineno = cur_lineno;
*last_entry_ptr = menu; last_entry_ptr = &menu->next; current_entry = menu; if (sym) list_add_tail(&menu->link, &sym->menus);}
struct menu *menu_add_menu(void){ last_entry_ptr = ¤t_entry->list; current_menu = current_entry; return current_menu;}
void menu_end_menu(void){ last_entry_ptr = ¤t_menu->next; current_menu = current_menu->parent;}
/* * Rewrites 'm' to 'm' && MODULES, so that it evaluates to 'n' when running * without modules */static struct expr *rewrite_m(struct expr *e){ if (!e) return e;
switch (e->type) { case E_NOT: e = expr_alloc_one(E_NOT, rewrite_m(e->left.expr)); break; case E_OR: case E_AND: e = expr_alloc_two(e->type, rewrite_m(e->left.expr), rewrite_m(e->right.expr)); break; case E_SYMBOL: /* change 'm' into 'm' && MODULES */ if (e->left.sym == &symbol_mod) return expr_alloc_and(e, expr_alloc_symbol(modules_sym)); break; default: break; } return e;}
void menu_add_dep(struct expr *dep, struct expr *cond){ if (cond) { /* * We have "depends on X if Y" and we want: * Y != n --> X * Y == n --> y * That simplifies to: (X || (Y == n)) */ dep = expr_alloc_or(dep, expr_trans_compare(cond, E_EQUAL, &symbol_no)); } current_entry->dep = expr_alloc_and(current_entry->dep, dep);}
void menu_set_type(int type){ struct symbol *sym = current_entry->sym;
if (sym->type == type) return; if (sym->type == S_UNKNOWN) { sym->type = type; return; } menu_warn(current_entry, "ignoring type redefinition of '%s' from '%s' to '%s'", sym->name ? sym->name : "<choice>", sym_type_name(sym->type), sym_type_name(type));}
static struct property *menu_add_prop(enum prop_type type, struct expr *expr, struct expr *dep){ struct property *prop;
prop = xmalloc(sizeof(*prop)); memset(prop, 0, sizeof(*prop)); prop->type = type; prop->filename = cur_filename; prop->lineno = cur_lineno; prop->menu = current_entry; prop->expr = expr; prop->visible.expr = dep;
/* append property to the prop list of symbol */ if (current_entry->sym) { struct property **propp;
for (propp = ¤t_entry->sym->prop; *propp; propp = &(*propp)->next) ; *propp = prop; }
return prop;}
struct property *menu_add_prompt(enum prop_type type, const char *prompt, struct expr *dep){ struct property *prop = menu_add_prop(type, NULL, dep);
if (isspace(*prompt)) { prop_warn(prop, "leading whitespace ignored"); while (isspace(*prompt)) prompt++; } if (current_entry->prompt) prop_warn(prop, "prompt redefined");
/* Apply all upper menus' visibilities to actual prompts. */ if (type == P_PROMPT) { struct menu *menu = current_entry;
while ((menu = menu->parent) != NULL) {
if (!menu->visibility) continue; prop->visible.expr = expr_alloc_and(prop->visible.expr, menu->visibility); } }
current_entry->prompt = prop; prop->text = prompt;
return prop;}
void menu_add_visibility(struct expr *expr){ current_entry->visibility = expr_alloc_and(current_entry->visibility, expr);}
void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep){ menu_add_prop(type, expr, dep);}
void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep){ menu_add_prop(type, expr_alloc_symbol(sym), dep);}
static int menu_validate_number(struct symbol *sym, struct symbol *sym2){ return sym2->type == S_INT || sym2->type == S_HEX || (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name));}
static void sym_check_prop(struct symbol *sym){ struct property *prop; struct symbol *sym2; char *use;
for (prop = sym->prop; prop; prop = prop->next) { switch (prop->type) { case P_DEFAULT: if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) && prop->expr->type != E_SYMBOL) prop_warn(prop, "default for config symbol '%s'" " must be a single symbol", sym->name); if (prop->expr->type != E_SYMBOL) break; sym2 = prop_get_symbol(prop); if (sym->type == S_HEX || sym->type == S_INT) { if (!menu_validate_number(sym, sym2)) prop_warn(prop, "'%s': number is invalid", sym->name); } if (sym_is_choice(sym)) { struct menu *choice = sym_get_choice_menu(sym2);
if (!choice || choice->sym != sym) prop_warn(prop, "choice default symbol '%s' is not contained in the choice", sym2->name); } break; case P_SELECT: case P_IMPLY: use = prop->type == P_SELECT ? "select" : "imply"; sym2 = prop_get_symbol(prop); if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE) prop_warn(prop, "config symbol '%s' uses %s, but is " "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 bool and " "tristate type", sym2->name, use); break; case P_RANGE: if (sym->type != S_INT && sym->type != S_HEX) prop_warn(prop, "range is only allowed " "for int or hex symbols"); if (!menu_validate_number(sym, prop->expr->left.sym) || !menu_validate_number(sym, prop->expr->right.sym)) prop_warn(prop, "range is invalid"); break; default: ; } }}
static void _menu_finalize(struct menu *parent, bool inside_choice){ struct menu *menu, *last_menu; struct symbol *sym; struct property *prop; struct expr *basedep, *dep, *dep2;
sym = parent->sym; if (parent->list) { /* * This menu node has children. We (recursively) process them * and propagate parent dependencies before moving on. */
/* For each child menu node... */ for (menu = parent->list; menu; menu = menu->next) { /* * Propagate parent dependencies to the child menu * node, also rewriting and simplifying expressions */ basedep = rewrite_m(menu->dep); basedep = expr_transform(basedep); basedep = expr_alloc_and(parent->dep, basedep); basedep = expr_eliminate_dups(basedep); menu->dep = basedep;
if (menu->sym) /* * Note: For symbols, all prompts are included * too in the symbol's own property list */ prop = menu->sym->prop; else /* * For non-symbol menu nodes, we just need to * handle the prompt */ prop = menu->prompt;
/* For each property... */ for (; prop; prop = prop->next) { if (prop->menu != menu) /* * Two possibilities: * * 1. The property lacks dependencies * and so isn't location-specific, * e.g. an 'option' * * 2. The property belongs to a symbol * defined in multiple locations and * is from some other location. It * will be handled there in that * case. * * Skip the property. */ continue;
/* * Propagate parent dependencies to the * property's condition, rewriting and * simplifying expressions at the same time */ dep = rewrite_m(prop->visible.expr); dep = expr_transform(dep); dep = expr_alloc_and(basedep, dep); dep = expr_eliminate_dups(dep); prop->visible.expr = dep;
/* * Handle selects and implies, which modify the * dependencies of the selected/implied symbol */ if (prop->type == P_SELECT) { struct symbol *es = prop_get_symbol(prop); es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr, expr_alloc_and(expr_alloc_symbol(menu->sym), dep)); } else if (prop->type == P_IMPLY) { struct symbol *es = prop_get_symbol(prop); es->implied.expr = expr_alloc_or(es->implied.expr, expr_alloc_and(expr_alloc_symbol(menu->sym), dep)); } } }
/* * Recursively process children in the same fashion before * moving on */ for (menu = parent->list; menu; menu = menu->next) _menu_finalize(menu, sym && sym_is_choice(sym)); } else if (!inside_choice && 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 = basedep; expr_eliminate_eq(&dep, &dep2); if (!expr_is_yes(dep2)) { /* Not superset, quit */ break; } /* Superset, put in submenu */ next: _menu_finalize(menu, false); menu->parent = parent; last_menu = menu; } if (last_menu) { parent->list = parent->next; parent->next = last_menu->next; last_menu->next = NULL; }
sym->dir_dep.expr = expr_alloc_or(sym->dir_dep.expr, parent->dep); } for (menu = parent->list; menu; menu = menu->next) { /* * This code serves two purposes: * * (1) Flattening 'if' blocks, which do not specify a submenu * and only add dependencies. * * (Automatic submenu creation might still create a submenu * from an 'if' before this code runs.) * * (2) "Undoing" any automatic submenus created earlier below * promptless symbols. * * Before: * * A * if ... (or promptless symbol) * +-B * +-C * D * * After: * * A * if ... (or promptless symbol) * B * C * D */ if (menu->list && (!menu->prompt || !menu->prompt->text)) { for (last_menu = menu->list; ; last_menu = last_menu->next) { last_menu->parent = parent; if (!last_menu->next) break; } last_menu->next = menu->next; menu->next = menu->list; menu->list = NULL; } }
if (sym && !(sym->flags & SYMBOL_WARNED)) { if (sym->type == S_UNKNOWN) menu_warn(parent, "config symbol defined without type");
/* Check properties connected to this symbol */ sym_check_prop(sym); sym->flags |= SYMBOL_WARNED; }}
void menu_finalize(void){ _menu_finalize(&rootmenu, false);}
bool menu_has_prompt(const struct menu *menu){ if (!menu->prompt) return false; return true;}
/* * Determine if a menu is empty. * A menu is considered empty if it contains no or only * invisible entries. */bool menu_is_empty(struct menu *menu){ struct menu *child;
for (child = menu->list; child; child = child->next) { if (menu_is_visible(child)) return(false); } return(true);}
bool menu_is_visible(struct menu *menu){ struct menu *child; struct symbol *sym; tristate visible;
if (!menu->prompt) return false;
if (menu->visibility) { if (expr_calc_value(menu->visibility) == no) return false; }
sym = menu->sym; if (sym) { sym_calc_value(sym); visible = menu->prompt->visible.tri; } else visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr);
if (visible != no) return true;
if (!sym || sym_get_tristate_value(menu->sym) == no) return false;
for (child = menu->list; child; child = child->next) if (menu_is_visible(child)) return true;
return false;}
const char *menu_get_prompt(const struct menu *menu){ if (menu->prompt) return menu->prompt->text; else if (menu->sym) return menu->sym->name; return NULL;}
/** * menu_get_parent_menu - return the parent menu or NULL * @menu: pointer to the menu * return: the parent menu, or NULL if there is no parent. */struct menu *menu_get_parent_menu(struct menu *menu){ for (menu = menu->parent; menu; menu = menu->parent) if (menu->type == M_MENU) return menu;
return NULL;}
/** * menu_get_menu_or_parent_menu - return the parent menu or the menu itself * @menu: pointer to the menu * return: the parent menu. If the given argument is already a menu, return * itself. */struct menu *menu_get_menu_or_parent_menu(struct menu *menu){ enum prop_type type;
for (; menu != &rootmenu; menu = menu->parent) { type = menu->prompt ? menu->prompt->type : 0; if (type == P_MENU) break; } return menu;}
static void get_def_str(struct gstr *r, const struct menu *menu){ str_printf(r, "Defined at %s:%d\n", menu->filename, menu->lineno);}
static void get_dep_str(struct gstr *r, const struct expr *expr, const char *prefix){ if (!expr_is_yes(expr)) { str_append(r, prefix); expr_gstr_print(expr, r); str_append(r, "\n"); }}
int __attribute__((weak)) get_jump_key_char(void){ return -1;}
static void get_prompt_str(struct gstr *r, struct property *prop, struct list_head *head){ int i, j; struct menu *submenu[8], *menu, *location = NULL; struct jump_key *jump = NULL;
str_printf(r, " Prompt: %s\n", prop->text);
get_dep_str(r, prop->menu->dep, " Depends on: "); /* * Most prompts in Linux have visibility that exactly matches their * dependencies. For these, we print only the dependencies to improve * readability. However, prompts with inline "if" expressions and * prompts with a parent that has a "visible if" expression have * differing dependencies and visibility. In these rare cases, we * print both. */ if (!expr_eq(prop->menu->dep, prop->visible.expr)) get_dep_str(r, prop->visible.expr, " Visible if: ");
menu = prop->menu; for (i = 0; menu != &rootmenu && i < 8; menu = menu->parent) { submenu[i++] = menu; if (location == NULL && menu_is_visible(menu)) location = menu; } if (head && location) { jump = xmalloc(sizeof(struct jump_key)); jump->target = location; list_add_tail(&jump->entries, head); }
str_printf(r, " Location:\n"); for (j = 0; --i >= 0; j++) { int jk = -1; int indent = 2 * j + 4;
menu = submenu[i]; if (jump && menu == location) { jump->offset = strlen(r->s); jk = get_jump_key_char(); }
if (jk >= 0) { str_printf(r, "(%c)", jk); indent -= 3; }
str_printf(r, "%*c-> %s", indent, ' ', menu_get_prompt(menu)); if (menu->sym) { str_printf(r, " (%s [=%s])", menu->sym->name ? menu->sym->name : "<choice>", sym_get_string_value(menu->sym)); } str_append(r, "\n"); }}
static void get_symbol_props_str(struct gstr *r, struct symbol *sym, enum prop_type tok, const char *prefix){ bool hit = false; struct property *prop;
for_all_properties(sym, prop, tok) { if (!hit) { str_append(r, prefix); hit = true; } else str_printf(r, " && "); expr_gstr_print(prop->expr, r); } if (hit) str_append(r, "\n");}
/* * head is optional and may be NULL */static void get_symbol_str(struct gstr *r, struct symbol *sym, struct list_head *head){ struct property *prop; struct menu *menu;
if (sym && sym->name) { str_printf(r, "Symbol: %s [=%s]\n", sym->name, sym_get_string_value(sym)); str_printf(r, "Type : %s\n", sym_type_name(sym->type)); if (sym->type == S_INT || sym->type == S_HEX) { prop = sym_get_range_prop(sym); if (prop) { str_printf(r, "Range : "); expr_gstr_print(prop->expr, r); str_append(r, "\n"); } } }
/* Print the definitions with prompts before the ones without */ list_for_each_entry(menu, &sym->menus, link) { if (menu->prompt) { get_def_str(r, menu); get_prompt_str(r, menu->prompt, head); } }
list_for_each_entry(menu, &sym->menus, link) { if (!menu->prompt) { get_def_str(r, menu); get_dep_str(r, menu->dep, " Depends on: "); } }
get_symbol_props_str(r, sym, P_SELECT, "Selects: "); if (sym->rev_dep.expr) { expr_gstr_print_revdep(sym->rev_dep.expr, r, yes, "Selected by [y]:\n"); expr_gstr_print_revdep(sym->rev_dep.expr, r, mod, "Selected by [m]:\n"); expr_gstr_print_revdep(sym->rev_dep.expr, r, no, "Selected by [n]:\n"); }
get_symbol_props_str(r, sym, P_IMPLY, "Implies: "); if (sym->implied.expr) { expr_gstr_print_revdep(sym->implied.expr, r, yes, "Implied by [y]:\n"); expr_gstr_print_revdep(sym->implied.expr, r, mod, "Implied by [m]:\n"); expr_gstr_print_revdep(sym->implied.expr, r, no, "Implied by [n]:\n"); }
str_append(r, "\n\n");}
struct gstr get_relations_str(struct symbol **sym_arr, struct list_head *head){ struct symbol *sym; struct gstr res = str_new(); int i;
for (i = 0; sym_arr && (sym = sym_arr[i]); i++) get_symbol_str(&res, sym, head); if (!i) str_append(&res, "No matches found.\n"); return res;}
void menu_get_ext_help(struct menu *menu, struct gstr *help){ struct symbol *sym = menu->sym; const char *help_text = nohelp_text;
if (menu->help) { if (sym->name) str_printf(help, "%s%s:\n\n", CONFIG_, sym->name); help_text = menu->help; } str_printf(help, "%s\n", help_text); if (sym) get_symbol_str(help, sym, NULL);}
/** * menu_dump - dump all menu entries in a tree-like format */void menu_dump(void){ struct menu *menu = &rootmenu; unsigned long long bits = 0; int indent = 0;
while (menu) {
for (int i = indent - 1; i >= 0; i--) { if (bits & (1ULL << i)) { if (i > 0) printf("| "); else printf("|-- "); } else { if (i > 0) printf(" "); else printf("`-- "); } }
switch (menu->type) { case M_CHOICE: printf("choice \"%s\"\n", menu->prompt->text); break; case M_COMMENT: printf("comment \"%s\"\n", menu->prompt->text); break; case M_IF: printf("if\n"); break; case M_MENU: printf("menu \"%s\"", menu->prompt->text); if (!menu->sym) { printf("\n"); break; } printf(" + "); /* fallthrough */ case M_NORMAL: printf("symbol %s\n", menu->sym->name); break; } if (menu->list) { bits <<= 1; menu = menu->list; if (menu->next) bits |= 1; else bits &= ~1; indent++; continue; }
while (menu && !menu->next) { menu = menu->parent; bits >>= 1; indent--; }
if (menu) { menu = menu->next; if (menu->next) bits |= 1; else bits &= ~1; } }}