| 1 | // SPDX-License-Identifier: GPL-2.0 |
| 2 | /* |
| 3 | * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org> |
| 4 | */ |
| 5 | |
| 6 | #include <ctype.h> |
| 7 | #include <stdarg.h> |
| 8 | #include <stdlib.h> |
| 9 | #include <string.h> |
| 10 | |
| 11 | #include <list.h> |
| 12 | #include <xalloc.h> |
| 13 | #include "lkc.h" |
| 14 | #include "internal.h" |
| 15 | |
| 16 | static const char nohelp_text[] = "There is no help available for this option."; |
| 17 | |
| 18 | struct menu rootmenu; |
| 19 | static struct menu **last_entry_ptr; |
| 20 | |
| 21 | /** |
| 22 | * menu_next - return the next menu entry with depth-first traversal |
| 23 | * @menu: pointer to the current menu |
| 24 | * @root: root of the sub-tree to traverse. If NULL is given, the traveral |
| 25 | * continues until it reaches the end of the entire menu tree. |
| 26 | * return: the menu to visit next, or NULL when it reaches the end. |
| 27 | */ |
| 28 | struct menu *menu_next(struct menu *menu, struct menu *root) |
| 29 | { |
| 30 | if (menu->list) |
| 31 | return menu->list; |
| 32 | |
| 33 | while (menu != root && !menu->next) |
| 34 | menu = menu->parent; |
| 35 | |
| 36 | if (menu == root) |
| 37 | return NULL; |
| 38 | |
| 39 | return menu->next; |
| 40 | } |
| 41 | |
| 42 | void menu_warn(const struct menu *menu, const char *fmt, ...) |
| 43 | { |
| 44 | va_list ap; |
| 45 | va_start(ap, fmt); |
| 46 | fprintf(stderr, "%s:%d:warning: ", menu->filename, menu->lineno); |
| 47 | vfprintf(stderr, fmt, ap); |
| 48 | fprintf(stderr, "\n"); |
| 49 | va_end(ap); |
| 50 | } |
| 51 | |
| 52 | static void prop_warn(const struct property *prop, const char *fmt, ...) |
| 53 | { |
| 54 | va_list ap; |
| 55 | va_start(ap, fmt); |
| 56 | fprintf(stderr, "%s:%d:warning: ", prop->filename, prop->lineno); |
| 57 | vfprintf(stderr, fmt, ap); |
| 58 | fprintf(stderr, "\n"); |
| 59 | va_end(ap); |
| 60 | } |
| 61 | |
| 62 | void _menu_init(void) |
| 63 | { |
| 64 | current_entry = current_menu = &rootmenu; |
| 65 | last_entry_ptr = &rootmenu.list; |
| 66 | } |
| 67 | |
| 68 | void menu_add_entry(struct symbol *sym) |
| 69 | { |
| 70 | struct menu *menu; |
| 71 | |
| 72 | menu = xmalloc(sizeof(*menu)); |
| 73 | memset(menu, 0, sizeof(*menu)); |
| 74 | menu->sym = sym; |
| 75 | menu->parent = current_menu; |
| 76 | menu->filename = cur_filename; |
| 77 | menu->lineno = cur_lineno; |
| 78 | |
| 79 | *last_entry_ptr = menu; |
| 80 | last_entry_ptr = &menu->next; |
| 81 | current_entry = menu; |
| 82 | if (sym) |
| 83 | list_add_tail(&menu->link, &sym->menus); |
| 84 | } |
| 85 | |
| 86 | struct menu *menu_add_menu(void) |
| 87 | { |
| 88 | last_entry_ptr = ¤t_entry->list; |
| 89 | current_menu = current_entry; |
| 90 | return current_menu; |
| 91 | } |
| 92 | |
| 93 | void menu_end_menu(void) |
| 94 | { |
| 95 | last_entry_ptr = ¤t_menu->next; |
| 96 | current_menu = current_menu->parent; |
| 97 | } |
| 98 | |
| 99 | /* |
| 100 | * Rewrites 'm' to 'm' && MODULES, so that it evaluates to 'n' when running |
| 101 | * without modules |
| 102 | */ |
| 103 | static struct expr *rewrite_m(struct expr *e) |
| 104 | { |
| 105 | if (!e) |
| 106 | return e; |
| 107 | |
| 108 | switch (e->type) { |
| 109 | case E_NOT: |
| 110 | e = expr_alloc_one(E_NOT, rewrite_m(e->left.expr)); |
| 111 | break; |
| 112 | case E_OR: |
| 113 | case E_AND: |
| 114 | e = expr_alloc_two(e->type, |
| 115 | rewrite_m(e->left.expr), |
| 116 | rewrite_m(e->right.expr)); |
| 117 | break; |
| 118 | case E_SYMBOL: |
| 119 | /* change 'm' into 'm' && MODULES */ |
| 120 | if (e->left.sym == &symbol_mod) |
| 121 | return expr_alloc_and(e, expr_alloc_symbol(modules_sym)); |
| 122 | break; |
| 123 | default: |
| 124 | break; |
| 125 | } |
| 126 | return e; |
| 127 | } |
| 128 | |
| 129 | void menu_add_dep(struct expr *dep) |
| 130 | { |
| 131 | current_entry->dep = expr_alloc_and(current_entry->dep, dep); |
| 132 | } |
| 133 | |
| 134 | void menu_set_type(int type) |
| 135 | { |
| 136 | struct symbol *sym = current_entry->sym; |
| 137 | |
| 138 | if (sym->type == type) |
| 139 | return; |
| 140 | if (sym->type == S_UNKNOWN) { |
| 141 | sym->type = type; |
| 142 | return; |
| 143 | } |
| 144 | menu_warn(current_entry, |
| 145 | "ignoring type redefinition of '%s' from '%s' to '%s'", |
| 146 | sym->name ? sym->name : "<choice>", |
| 147 | sym_type_name(sym->type), sym_type_name(type)); |
| 148 | } |
| 149 | |
| 150 | static struct property *menu_add_prop(enum prop_type type, struct expr *expr, |
| 151 | struct expr *dep) |
| 152 | { |
| 153 | struct property *prop; |
| 154 | |
| 155 | prop = xmalloc(sizeof(*prop)); |
| 156 | memset(prop, 0, sizeof(*prop)); |
| 157 | prop->type = type; |
| 158 | prop->filename = cur_filename; |
| 159 | prop->lineno = cur_lineno; |
| 160 | prop->menu = current_entry; |
| 161 | prop->expr = expr; |
| 162 | prop->visible.expr = dep; |
| 163 | |
| 164 | /* append property to the prop list of symbol */ |
| 165 | if (current_entry->sym) { |
| 166 | struct property **propp; |
| 167 | |
| 168 | for (propp = ¤t_entry->sym->prop; |
| 169 | *propp; |
| 170 | propp = &(*propp)->next) |
| 171 | ; |
| 172 | *propp = prop; |
| 173 | } |
| 174 | |
| 175 | return prop; |
| 176 | } |
| 177 | |
| 178 | struct property *menu_add_prompt(enum prop_type type, const char *prompt, |
| 179 | struct expr *dep) |
| 180 | { |
| 181 | struct property *prop = menu_add_prop(type, NULL, dep); |
| 182 | |
| 183 | if (isspace(*prompt)) { |
| 184 | prop_warn(prop, "leading whitespace ignored"); |
| 185 | while (isspace(*prompt)) |
| 186 | prompt++; |
| 187 | } |
| 188 | if (current_entry->prompt) |
| 189 | prop_warn(prop, "prompt redefined"); |
| 190 | |
| 191 | /* Apply all upper menus' visibilities to actual prompts. */ |
| 192 | if (type == P_PROMPT) { |
| 193 | struct menu *menu = current_entry; |
| 194 | |
| 195 | while ((menu = menu->parent) != NULL) { |
| 196 | |
| 197 | if (!menu->visibility) |
| 198 | continue; |
| 199 | prop->visible.expr = expr_alloc_and(prop->visible.expr, |
| 200 | menu->visibility); |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | current_entry->prompt = prop; |
| 205 | prop->text = prompt; |
| 206 | |
| 207 | return prop; |
| 208 | } |
| 209 | |
| 210 | void menu_add_visibility(struct expr *expr) |
| 211 | { |
| 212 | current_entry->visibility = expr_alloc_and(current_entry->visibility, |
| 213 | expr); |
| 214 | } |
| 215 | |
| 216 | void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep) |
| 217 | { |
| 218 | menu_add_prop(type, expr, dep); |
| 219 | } |
| 220 | |
| 221 | void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep) |
| 222 | { |
| 223 | menu_add_prop(type, expr_alloc_symbol(sym), dep); |
| 224 | } |
| 225 | |
| 226 | static int menu_validate_number(struct symbol *sym, struct symbol *sym2) |
| 227 | { |
| 228 | return sym2->type == S_INT || sym2->type == S_HEX || |
| 229 | (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name)); |
| 230 | } |
| 231 | |
| 232 | static void sym_check_prop(struct symbol *sym) |
| 233 | { |
| 234 | struct property *prop; |
| 235 | struct symbol *sym2; |
| 236 | char *use; |
| 237 | |
| 238 | for (prop = sym->prop; prop; prop = prop->next) { |
| 239 | switch (prop->type) { |
| 240 | case P_DEFAULT: |
| 241 | if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) && |
| 242 | prop->expr->type != E_SYMBOL) |
| 243 | prop_warn(prop, |
| 244 | "default for config symbol '%s'" |
| 245 | " must be a single symbol", sym->name); |
| 246 | if (prop->expr->type != E_SYMBOL) |
| 247 | break; |
| 248 | sym2 = prop_get_symbol(prop); |
| 249 | if (sym->type == S_HEX || sym->type == S_INT) { |
| 250 | if (!menu_validate_number(sym, sym2)) |
| 251 | prop_warn(prop, |
| 252 | "'%s': number is invalid", |
| 253 | sym->name); |
| 254 | } |
| 255 | if (sym_is_choice(sym)) { |
| 256 | struct menu *choice = sym_get_choice_menu(sym2); |
| 257 | |
| 258 | if (!choice || choice->sym != sym) |
| 259 | prop_warn(prop, |
| 260 | "choice default symbol '%s' is not contained in the choice", |
| 261 | sym2->name); |
| 262 | } |
| 263 | break; |
| 264 | case P_SELECT: |
| 265 | case P_IMPLY: |
| 266 | use = prop->type == P_SELECT ? "select" : "imply"; |
| 267 | sym2 = prop_get_symbol(prop); |
| 268 | if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE) |
| 269 | prop_warn(prop, |
| 270 | "config symbol '%s' uses %s, but is " |
| 271 | "not bool or tristate", sym->name, use); |
| 272 | else if (sym2->type != S_UNKNOWN && |
| 273 | sym2->type != S_BOOLEAN && |
| 274 | sym2->type != S_TRISTATE) |
| 275 | prop_warn(prop, |
| 276 | "'%s' has wrong type. '%s' only " |
| 277 | "accept arguments of bool and " |
| 278 | "tristate type", sym2->name, use); |
| 279 | break; |
| 280 | case P_RANGE: |
| 281 | if (sym->type != S_INT && sym->type != S_HEX) |
| 282 | prop_warn(prop, "range is only allowed " |
| 283 | "for int or hex symbols"); |
| 284 | if (!menu_validate_number(sym, prop->expr->left.sym) || |
| 285 | !menu_validate_number(sym, prop->expr->right.sym)) |
| 286 | prop_warn(prop, "range is invalid"); |
| 287 | break; |
| 288 | default: |
| 289 | ; |
| 290 | } |
| 291 | } |
| 292 | } |
| 293 | |
| 294 | static void _menu_finalize(struct menu *parent, bool inside_choice) |
| 295 | { |
| 296 | struct menu *menu, *last_menu; |
| 297 | struct symbol *sym; |
| 298 | struct property *prop; |
| 299 | struct expr *basedep, *dep, *dep2; |
| 300 | |
| 301 | sym = parent->sym; |
| 302 | if (parent->list) { |
| 303 | /* |
| 304 | * This menu node has children. We (recursively) process them |
| 305 | * and propagate parent dependencies before moving on. |
| 306 | */ |
| 307 | |
| 308 | /* For each child menu node... */ |
| 309 | for (menu = parent->list; menu; menu = menu->next) { |
| 310 | /* |
| 311 | * Propagate parent dependencies to the child menu |
| 312 | * node, also rewriting and simplifying expressions |
| 313 | */ |
| 314 | basedep = rewrite_m(menu->dep); |
| 315 | basedep = expr_transform(basedep); |
| 316 | basedep = expr_alloc_and(parent->dep, basedep); |
| 317 | basedep = expr_eliminate_dups(basedep); |
| 318 | menu->dep = basedep; |
| 319 | |
| 320 | if (menu->sym) |
| 321 | /* |
| 322 | * Note: For symbols, all prompts are included |
| 323 | * too in the symbol's own property list |
| 324 | */ |
| 325 | prop = menu->sym->prop; |
| 326 | else |
| 327 | /* |
| 328 | * For non-symbol menu nodes, we just need to |
| 329 | * handle the prompt |
| 330 | */ |
| 331 | prop = menu->prompt; |
| 332 | |
| 333 | /* For each property... */ |
| 334 | for (; prop; prop = prop->next) { |
| 335 | if (prop->menu != menu) |
| 336 | /* |
| 337 | * Two possibilities: |
| 338 | * |
| 339 | * 1. The property lacks dependencies |
| 340 | * and so isn't location-specific, |
| 341 | * e.g. an 'option' |
| 342 | * |
| 343 | * 2. The property belongs to a symbol |
| 344 | * defined in multiple locations and |
| 345 | * is from some other location. It |
| 346 | * will be handled there in that |
| 347 | * case. |
| 348 | * |
| 349 | * Skip the property. |
| 350 | */ |
| 351 | continue; |
| 352 | |
| 353 | /* |
| 354 | * Propagate parent dependencies to the |
| 355 | * property's condition, rewriting and |
| 356 | * simplifying expressions at the same time |
| 357 | */ |
| 358 | dep = rewrite_m(prop->visible.expr); |
| 359 | dep = expr_transform(dep); |
| 360 | dep = expr_alloc_and(basedep, dep); |
| 361 | dep = expr_eliminate_dups(dep); |
| 362 | prop->visible.expr = dep; |
| 363 | |
| 364 | /* |
| 365 | * Handle selects and implies, which modify the |
| 366 | * dependencies of the selected/implied symbol |
| 367 | */ |
| 368 | if (prop->type == P_SELECT) { |
| 369 | struct symbol *es = prop_get_symbol(prop); |
| 370 | es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr, |
| 371 | expr_alloc_and(expr_alloc_symbol(menu->sym), dep)); |
| 372 | } else if (prop->type == P_IMPLY) { |
| 373 | struct symbol *es = prop_get_symbol(prop); |
| 374 | es->implied.expr = expr_alloc_or(es->implied.expr, |
| 375 | expr_alloc_and(expr_alloc_symbol(menu->sym), dep)); |
| 376 | } |
| 377 | } |
| 378 | } |
| 379 | |
| 380 | /* |
| 381 | * Recursively process children in the same fashion before |
| 382 | * moving on |
| 383 | */ |
| 384 | for (menu = parent->list; menu; menu = menu->next) |
| 385 | _menu_finalize(menu, sym && sym_is_choice(sym)); |
| 386 | } else if (!inside_choice && sym) { |
| 387 | /* |
| 388 | * Automatic submenu creation. If sym is a symbol and A, B, C, |
| 389 | * ... are consecutive items (symbols, menus, ifs, etc.) that |
| 390 | * all depend on sym, then the following menu structure is |
| 391 | * created: |
| 392 | * |
| 393 | * sym |
| 394 | * +-A |
| 395 | * +-B |
| 396 | * +-C |
| 397 | * ... |
| 398 | * |
| 399 | * This also works recursively, giving the following structure |
| 400 | * if A is a symbol and B depends on A: |
| 401 | * |
| 402 | * sym |
| 403 | * +-A |
| 404 | * | +-B |
| 405 | * +-C |
| 406 | * ... |
| 407 | */ |
| 408 | |
| 409 | basedep = parent->prompt ? parent->prompt->visible.expr : NULL; |
| 410 | basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no); |
| 411 | basedep = expr_eliminate_dups(expr_transform(basedep)); |
| 412 | |
| 413 | /* Examine consecutive elements after sym */ |
| 414 | last_menu = NULL; |
| 415 | for (menu = parent->next; menu; menu = menu->next) { |
| 416 | dep = menu->prompt ? menu->prompt->visible.expr : menu->dep; |
| 417 | if (!expr_contains_symbol(dep, sym)) |
| 418 | /* No dependency, quit */ |
| 419 | break; |
| 420 | if (expr_depends_symbol(dep, sym)) |
| 421 | /* Absolute dependency, put in submenu */ |
| 422 | goto next; |
| 423 | |
| 424 | /* |
| 425 | * Also consider it a dependency on sym if our |
| 426 | * dependencies contain sym and are a "superset" of |
| 427 | * sym's dependencies, e.g. '(sym || Q) && R' when sym |
| 428 | * depends on R. |
| 429 | * |
| 430 | * Note that 'R' might be from an enclosing menu or if, |
| 431 | * making this a more common case than it might seem. |
| 432 | */ |
| 433 | dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no); |
| 434 | dep = expr_eliminate_dups(expr_transform(dep)); |
| 435 | dep2 = basedep; |
| 436 | expr_eliminate_eq(&dep, &dep2); |
| 437 | if (!expr_is_yes(dep2)) { |
| 438 | /* Not superset, quit */ |
| 439 | break; |
| 440 | } |
| 441 | /* Superset, put in submenu */ |
| 442 | next: |
| 443 | _menu_finalize(menu, false); |
| 444 | menu->parent = parent; |
| 445 | last_menu = menu; |
| 446 | } |
| 447 | if (last_menu) { |
| 448 | parent->list = parent->next; |
| 449 | parent->next = last_menu->next; |
| 450 | last_menu->next = NULL; |
| 451 | } |
| 452 | |
| 453 | sym->dir_dep.expr = expr_alloc_or(sym->dir_dep.expr, parent->dep); |
| 454 | } |
| 455 | for (menu = parent->list; menu; menu = menu->next) { |
| 456 | /* |
| 457 | * This code serves two purposes: |
| 458 | * |
| 459 | * (1) Flattening 'if' blocks, which do not specify a submenu |
| 460 | * and only add dependencies. |
| 461 | * |
| 462 | * (Automatic submenu creation might still create a submenu |
| 463 | * from an 'if' before this code runs.) |
| 464 | * |
| 465 | * (2) "Undoing" any automatic submenus created earlier below |
| 466 | * promptless symbols. |
| 467 | * |
| 468 | * Before: |
| 469 | * |
| 470 | * A |
| 471 | * if ... (or promptless symbol) |
| 472 | * +-B |
| 473 | * +-C |
| 474 | * D |
| 475 | * |
| 476 | * After: |
| 477 | * |
| 478 | * A |
| 479 | * if ... (or promptless symbol) |
| 480 | * B |
| 481 | * C |
| 482 | * D |
| 483 | */ |
| 484 | if (menu->list && (!menu->prompt || !menu->prompt->text)) { |
| 485 | for (last_menu = menu->list; ; last_menu = last_menu->next) { |
| 486 | last_menu->parent = parent; |
| 487 | if (!last_menu->next) |
| 488 | break; |
| 489 | } |
| 490 | last_menu->next = menu->next; |
| 491 | menu->next = menu->list; |
| 492 | menu->list = NULL; |
| 493 | } |
| 494 | } |
| 495 | |
| 496 | if (sym && !(sym->flags & SYMBOL_WARNED)) { |
| 497 | if (sym->type == S_UNKNOWN) |
| 498 | menu_warn(parent, "config symbol defined without type"); |
| 499 | |
| 500 | /* Check properties connected to this symbol */ |
| 501 | sym_check_prop(sym); |
| 502 | sym->flags |= SYMBOL_WARNED; |
| 503 | } |
| 504 | } |
| 505 | |
| 506 | void menu_finalize(void) |
| 507 | { |
| 508 | _menu_finalize(&rootmenu, false); |
| 509 | } |
| 510 | |
| 511 | bool menu_has_prompt(const struct menu *menu) |
| 512 | { |
| 513 | if (!menu->prompt) |
| 514 | return false; |
| 515 | return true; |
| 516 | } |
| 517 | |
| 518 | /* |
| 519 | * Determine if a menu is empty. |
| 520 | * A menu is considered empty if it contains no or only |
| 521 | * invisible entries. |
| 522 | */ |
| 523 | bool menu_is_empty(struct menu *menu) |
| 524 | { |
| 525 | struct menu *child; |
| 526 | |
| 527 | for (child = menu->list; child; child = child->next) { |
| 528 | if (menu_is_visible(child)) |
| 529 | return(false); |
| 530 | } |
| 531 | return(true); |
| 532 | } |
| 533 | |
| 534 | bool menu_is_visible(struct menu *menu) |
| 535 | { |
| 536 | struct symbol *sym; |
| 537 | tristate visible; |
| 538 | |
| 539 | if (!menu->prompt) |
| 540 | return false; |
| 541 | |
| 542 | if (menu->visibility) { |
| 543 | if (expr_calc_value(menu->visibility) == no) |
| 544 | return false; |
| 545 | } |
| 546 | |
| 547 | sym = menu->sym; |
| 548 | if (sym) { |
| 549 | sym_calc_value(sym); |
| 550 | visible = menu->prompt->visible.tri; |
| 551 | } else |
| 552 | visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr); |
| 553 | |
| 554 | return visible != no; |
| 555 | } |
| 556 | |
| 557 | const char *menu_get_prompt(const struct menu *menu) |
| 558 | { |
| 559 | if (menu->prompt) |
| 560 | return menu->prompt->text; |
| 561 | else if (menu->sym) |
| 562 | return menu->sym->name; |
| 563 | return NULL; |
| 564 | } |
| 565 | |
| 566 | struct menu *menu_get_parent_menu(struct menu *menu) |
| 567 | { |
| 568 | enum prop_type type; |
| 569 | |
| 570 | for (; menu != &rootmenu; menu = menu->parent) { |
| 571 | type = menu->prompt ? menu->prompt->type : 0; |
| 572 | if (type == P_MENU) |
| 573 | break; |
| 574 | } |
| 575 | return menu; |
| 576 | } |
| 577 | |
| 578 | static void get_def_str(struct gstr *r, const struct menu *menu) |
| 579 | { |
| 580 | str_printf(r, "Defined at %s:%d\n", |
| 581 | menu->filename, menu->lineno); |
| 582 | } |
| 583 | |
| 584 | static void get_dep_str(struct gstr *r, const struct expr *expr, |
| 585 | const char *prefix) |
| 586 | { |
| 587 | if (!expr_is_yes(expr)) { |
| 588 | str_append(r, prefix); |
| 589 | expr_gstr_print(expr, r); |
| 590 | str_append(r, "\n"); |
| 591 | } |
| 592 | } |
| 593 | |
| 594 | int __attribute__((weak)) get_jump_key_char(void) |
| 595 | { |
| 596 | return -1; |
| 597 | } |
| 598 | |
| 599 | static void get_prompt_str(struct gstr *r, struct property *prop, |
| 600 | struct list_head *head) |
| 601 | { |
| 602 | int i, j; |
| 603 | struct menu *submenu[8], *menu, *location = NULL; |
| 604 | struct jump_key *jump = NULL; |
| 605 | |
| 606 | str_printf(r, " Prompt: %s\n", prop->text); |
| 607 | |
| 608 | get_dep_str(r, prop->menu->dep, " Depends on: "); |
| 609 | /* |
| 610 | * Most prompts in Linux have visibility that exactly matches their |
| 611 | * dependencies. For these, we print only the dependencies to improve |
| 612 | * readability. However, prompts with inline "if" expressions and |
| 613 | * prompts with a parent that has a "visible if" expression have |
| 614 | * differing dependencies and visibility. In these rare cases, we |
| 615 | * print both. |
| 616 | */ |
| 617 | if (!expr_eq(prop->menu->dep, prop->visible.expr)) |
| 618 | get_dep_str(r, prop->visible.expr, " Visible if: "); |
| 619 | |
| 620 | menu = prop->menu; |
| 621 | for (i = 0; menu != &rootmenu && i < 8; menu = menu->parent) { |
| 622 | submenu[i++] = menu; |
| 623 | if (location == NULL && menu_is_visible(menu)) |
| 624 | location = menu; |
| 625 | } |
| 626 | if (head && location) { |
| 627 | jump = xmalloc(sizeof(struct jump_key)); |
| 628 | jump->target = location; |
| 629 | list_add_tail(&jump->entries, head); |
| 630 | } |
| 631 | |
| 632 | str_printf(r, " Location:\n"); |
| 633 | for (j = 0; --i >= 0; j++) { |
| 634 | int jk = -1; |
| 635 | int indent = 2 * j + 4; |
| 636 | |
| 637 | menu = submenu[i]; |
| 638 | if (jump && menu == location) { |
| 639 | jump->offset = strlen(r->s); |
| 640 | jk = get_jump_key_char(); |
| 641 | } |
| 642 | |
| 643 | if (jk >= 0) { |
| 644 | str_printf(r, "(%c)", jk); |
| 645 | indent -= 3; |
| 646 | } |
| 647 | |
| 648 | str_printf(r, "%*c-> %s", indent, ' ', menu_get_prompt(menu)); |
| 649 | if (menu->sym) { |
| 650 | str_printf(r, " (%s [=%s])", menu->sym->name ? |
| 651 | menu->sym->name : "<choice>", |
| 652 | sym_get_string_value(menu->sym)); |
| 653 | } |
| 654 | str_append(r, "\n"); |
| 655 | } |
| 656 | } |
| 657 | |
| 658 | static void get_symbol_props_str(struct gstr *r, struct symbol *sym, |
| 659 | enum prop_type tok, const char *prefix) |
| 660 | { |
| 661 | bool hit = false; |
| 662 | struct property *prop; |
| 663 | |
| 664 | for_all_properties(sym, prop, tok) { |
| 665 | if (!hit) { |
| 666 | str_append(r, prefix); |
| 667 | hit = true; |
| 668 | } else |
| 669 | str_printf(r, " && "); |
| 670 | expr_gstr_print(prop->expr, r); |
| 671 | } |
| 672 | if (hit) |
| 673 | str_append(r, "\n"); |
| 674 | } |
| 675 | |
| 676 | /* |
| 677 | * head is optional and may be NULL |
| 678 | */ |
| 679 | static void get_symbol_str(struct gstr *r, struct symbol *sym, |
| 680 | struct list_head *head) |
| 681 | { |
| 682 | struct property *prop; |
| 683 | struct menu *menu; |
| 684 | |
| 685 | if (sym && sym->name) { |
| 686 | str_printf(r, "Symbol: %s [=%s]\n", sym->name, |
| 687 | sym_get_string_value(sym)); |
| 688 | str_printf(r, "Type : %s\n", sym_type_name(sym->type)); |
| 689 | if (sym->type == S_INT || sym->type == S_HEX) { |
| 690 | prop = sym_get_range_prop(sym); |
| 691 | if (prop) { |
| 692 | str_printf(r, "Range : "); |
| 693 | expr_gstr_print(prop->expr, r); |
| 694 | str_append(r, "\n"); |
| 695 | } |
| 696 | } |
| 697 | } |
| 698 | |
| 699 | /* Print the definitions with prompts before the ones without */ |
| 700 | list_for_each_entry(menu, &sym->menus, link) { |
| 701 | if (menu->prompt) { |
| 702 | get_def_str(r, menu); |
| 703 | get_prompt_str(r, menu->prompt, head); |
| 704 | } |
| 705 | } |
| 706 | |
| 707 | list_for_each_entry(menu, &sym->menus, link) { |
| 708 | if (!menu->prompt) { |
| 709 | get_def_str(r, menu); |
| 710 | get_dep_str(r, menu->dep, " Depends on: "); |
| 711 | } |
| 712 | } |
| 713 | |
| 714 | get_symbol_props_str(r, sym, P_SELECT, "Selects: "); |
| 715 | if (sym->rev_dep.expr) { |
| 716 | expr_gstr_print_revdep(sym->rev_dep.expr, r, yes, "Selected by [y]:\n"); |
| 717 | expr_gstr_print_revdep(sym->rev_dep.expr, r, mod, "Selected by [m]:\n"); |
| 718 | expr_gstr_print_revdep(sym->rev_dep.expr, r, no, "Selected by [n]:\n"); |
| 719 | } |
| 720 | |
| 721 | get_symbol_props_str(r, sym, P_IMPLY, "Implies: "); |
| 722 | if (sym->implied.expr) { |
| 723 | expr_gstr_print_revdep(sym->implied.expr, r, yes, "Implied by [y]:\n"); |
| 724 | expr_gstr_print_revdep(sym->implied.expr, r, mod, "Implied by [m]:\n"); |
| 725 | expr_gstr_print_revdep(sym->implied.expr, r, no, "Implied by [n]:\n"); |
| 726 | } |
| 727 | |
| 728 | str_append(r, "\n\n"); |
| 729 | } |
| 730 | |
| 731 | struct gstr get_relations_str(struct symbol **sym_arr, struct list_head *head) |
| 732 | { |
| 733 | struct symbol *sym; |
| 734 | struct gstr res = str_new(); |
| 735 | int i; |
| 736 | |
| 737 | for (i = 0; sym_arr && (sym = sym_arr[i]); i++) |
| 738 | get_symbol_str(&res, sym, head); |
| 739 | if (!i) |
| 740 | str_append(&res, "No matches found.\n"); |
| 741 | return res; |
| 742 | } |
| 743 | |
| 744 | |
| 745 | void menu_get_ext_help(struct menu *menu, struct gstr *help) |
| 746 | { |
| 747 | struct symbol *sym = menu->sym; |
| 748 | const char *help_text = nohelp_text; |
| 749 | |
| 750 | if (menu->help) { |
| 751 | if (sym->name) |
| 752 | str_printf(help, "%s%s:\n\n", CONFIG_, sym->name); |
| 753 | help_text = menu->help; |
| 754 | } |
| 755 | str_printf(help, "%s\n", help_text); |
| 756 | if (sym) |
| 757 | get_symbol_str(help, sym, NULL); |
| 758 | } |