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