scripts/kconfig/mconf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2002 Roman Zippel <[email protected]>
   4  *
   5  * Introduced single menu mode (show all sub-menus in one large tree).
   6  * 2002-11-06 Petr Baudis <[email protected]>
   7  *
   8  * i18n, 2005, Arnaldo Carvalho de Melo <[email protected]>
   9  */
  10
  11 #include <ctype.h>
  12 #include <errno.h>
  13 #include <fcntl.h>
  14 #include <limits.h>
  15 #include <stdarg.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <strings.h>
  19 #include <signal.h>
  20 #include <unistd.h>
  21
  22 #include "lkc.h"
  23 #include "lxdialog/dialog.h"
  24
  25 #define JUMP_NB                 9
  26
  27 static const char mconf_readme[] =
  28 "Overview\n"
  29 "--------\n"
  30 "This interface lets you select features and parameters for the build.\n"
  31 "Features can either be built-in, modularized, or ignored. Parameters\n"
  32 "must be entered in as decimal or hexadecimal numbers or text.\n"
  33 "\n"
  34 "Menu items beginning with following braces represent features that\n"
  35 "  [ ] can be built in or removed\n"
  36 "  < > can be built in, modularized or removed\n"
  37 "  { } can be built in or modularized (selected by other feature)\n"
  38 "  - - are selected by other feature,\n"
  39 "while *, M or whitespace inside braces means to build in, build as\n"
  40 "a module or to exclude the feature respectively.\n"
  41 "\n"
  42 "To change any of these features, highlight it with the cursor\n"
  43 "keys and press <Y> to build it in, <M> to make it a module or\n"
  44 "<N> to remove it.  You may also press the <Space Bar> to cycle\n"
  45 "through the available options (i.e. Y->N->M->Y).\n"
  46 "\n"
  47 "Some additional keyboard hints:\n"
  48 "\n"
  49 "Menus\n"
  50 "----------\n"
  51 "o  Use the Up/Down arrow keys (cursor keys) to highlight the item you\n"
  52 "   wish to change or the submenu you wish to select and press <Enter>.\n"
  53 "   Submenus are designated by \"--->\", empty ones by \"----\".\n"
  54 "\n"
  55 "   Shortcut: Press the option's highlighted letter (hotkey).\n"
  56 "             Pressing a hotkey more than once will sequence\n"
  57 "             through all visible items which use that hotkey.\n"
  58 "\n"
  59 "   You may also use the <PAGE UP> and <PAGE DOWN> keys to scroll\n"
  60 "   unseen options into view.\n"
  61 "\n"
  62 "o  To exit a menu use the cursor keys to highlight the <Exit> button\n"
  63 "   and press <ENTER>.\n"
  64 "\n"
  65 "   Shortcut: Press <ESC><ESC> or <E> or <X> if there is no hotkey\n"
  66 "             using those letters.  You may press a single <ESC>, but\n"
  67 "             there is a delayed response which you may find annoying.\n"
  68 "\n"
  69 "   Also, the <TAB> and cursor keys will cycle between <Select>,\n"
  70 "   <Exit>, <Help>, <Save>, and <Load>.\n"
  71 "\n"
  72 "o  To get help with an item, use the cursor keys to highlight <Help>\n"
  73 "   and press <ENTER>.\n"
  74 "\n"
  75 "   Shortcut: Press <H> or <?>.\n"
  76 "\n"
  77 "o  To toggle the display of hidden options, press <Z>.\n"
  78 "\n"
  79 "\n"
  80 "Radiolists  (Choice lists)\n"
  81 "-----------\n"
  82 "o  Use the cursor keys to select the option you wish to set and press\n"
  83 "   <S> or the <SPACE BAR>.\n"
  84 "\n"
  85 "   Shortcut: Press the first letter of the option you wish to set then\n"
  86 "             press <S> or <SPACE BAR>.\n"
  87 "\n"
  88 "o  To see available help for the item, use the cursor keys to highlight\n"
  89 "   <Help> and Press <ENTER>.\n"
  90 "\n"
  91 "   Shortcut: Press <H> or <?>.\n"
  92 "\n"
  93 "   Also, the <TAB> and cursor keys will cycle between <Select> and\n"
  94 "   <Help>\n"
  95 "\n"
  96 "\n"
  97 "Data Entry\n"
  98 "-----------\n"
  99 "o  Enter the requested information and press <ENTER>\n"
 100 "   If you are entering hexadecimal values, it is not necessary to\n"
 101 "   add the '0x' prefix to the entry.\n"
 102 "\n"
 103 "o  For help, use the <TAB> or cursor keys to highlight the help option\n"
 104 "   and press <ENTER>.  You can try <TAB><H> as well.\n"
 105 "\n"
 106 "\n"
 107 "Text Box    (Help Window)\n"
 108 "--------\n"
 109 "o  Use the cursor keys to scroll up/down/left/right.  The VI editor\n"
 110 "   keys h,j,k,l function here as do <u>, <d>, <SPACE BAR> and <B> for\n"
 111 "   those who are familiar with less and lynx.\n"
 112 "\n"
 113 "o  Press <E>, <X>, <q>, <Enter> or <Esc><Esc> to exit.\n"
 114 "\n"
 115 "\n"
 116 "Alternate Configuration Files\n"
 117 "-----------------------------\n"
 118 "Menuconfig supports the use of alternate configuration files for\n"
 119 "those who, for various reasons, find it necessary to switch\n"
 120 "between different configurations.\n"
 121 "\n"
 122 "The <Save> button will let you save the current configuration to\n"
 123 "a file of your choosing.  Use the <Load> button to load a previously\n"
 124 "saved alternate configuration.\n"
 125 "\n"
 126 "Even if you don't use alternate configuration files, but you find\n"
 127 "during a Menuconfig session that you have completely messed up your\n"
 128 "settings, you may use the <Load> button to restore your previously\n"
 129 "saved settings from \".config\" without restarting Menuconfig.\n"
 130 "\n"
 131 "Other information\n"
 132 "-----------------\n"
 133 "If you use Menuconfig in an XTERM window, make sure you have your\n"
 134 "$TERM variable set to point to an xterm definition which supports\n"
 135 "color.  Otherwise, Menuconfig will look rather bad.  Menuconfig will\n"
 136 "not display correctly in an RXVT window because rxvt displays only one\n"
 137 "intensity of color, bright.\n"
 138 "\n"
 139 "Menuconfig will display larger menus on screens or xterms which are\n"
 140 "set to display more than the standard 25 row by 80 column geometry.\n"
 141 "In order for this to work, the \"stty size\" command must be able to\n"
 142 "display the screen's current row and column geometry.  I STRONGLY\n"
 143 "RECOMMEND that you make sure you do NOT have the shell variables\n"
 144 "LINES and COLUMNS exported into your environment.  Some distributions\n"
 145 "export those variables via /etc/profile.  Some ncurses programs can\n"
 146 "become confused when those variables (LINES & COLUMNS) don't reflect\n"
 147 "the true screen size.\n"
 148 "\n"
 149 "Optional personality available\n"
 150 "------------------------------\n"
 151 "If you prefer to have all of the options listed in a single menu,\n"
 152 "rather than the default multimenu hierarchy, run the menuconfig with\n"
 153 "MENUCONFIG_MODE environment variable set to single_menu. Example:\n"
 154 "\n"
 155 "make MENUCONFIG_MODE=single_menu menuconfig\n"
 156 "\n"
 157 "<Enter> will then unroll the appropriate category, or enfold it if it\n"
 158 "is already unrolled.\n"
 159 "\n"
 160 "Note that this mode can eventually be a little more CPU expensive\n"
 161 "(especially with a larger number of unrolled categories) than the\n"
 162 "default mode.\n"
 163 "\n"
 164 "Different color themes available\n"
 165 "--------------------------------\n"
 166 "It is possible to select different color themes using the variable\n"
 167 "MENUCONFIG_COLOR. To select a theme use:\n"
 168 "\n"
 169 "make MENUCONFIG_COLOR=<theme> menuconfig\n"
 170 "\n"
 171 "Available themes are\n"
 172 " mono       => selects colors suitable for monochrome displays\n"
 173 " blackbg    => selects a color scheme with black background\n"
 174 " classic    => theme with blue background. The classic look\n"
 175 " bluetitle  => an LCD friendly version of classic. (default)\n"
 176 "\n",
 177 menu_instructions[] =
 178         "Arrow keys navigate the menu.  "
 179         "<Enter> selects submenus ---> (or empty submenus ----).  "
 180         "Highlighted letters are hotkeys.  "
 181         "Pressing <Y> includes, <N> excludes, <M> modularizes features.  "
 182         "Press <Esc><Esc> to exit, <?> for Help, </> for Search.  "
 183         "Legend: [*] built-in  [ ] excluded  <M> module  < > module capable",
 184 radiolist_instructions[] =
 185         "Use the arrow keys to navigate this window or "
 186         "press the hotkey of the item you wish to select "
 187         "followed by the <SPACE BAR>. "
 188         "Press <?> for additional information about this option.",
 189 inputbox_instructions_int[] =
 190         "Please enter a decimal value. "
 191         "Fractions will not be accepted.  "
 192         "Use the <TAB> key to move from the input field to the buttons below it.",
 193 inputbox_instructions_hex[] =
 194         "Please enter a hexadecimal value. "
 195         "Use the <TAB> key to move from the input field to the buttons below it.",
 196 inputbox_instructions_string[] =
 197         "Please enter a string value. "
 198         "Use the <TAB> key to move from the input field to the buttons below it.",
 199 setmod_text[] =
 200         "This feature depends on another which has been configured as a module.\n"
 201         "As a result, this feature will be built as a module.",
 202 load_config_text[] =
 203         "Enter the name of the configuration file you wish to load.  "
 204         "Accept the name shown to restore the configuration you "
 205         "last retrieved.  Leave blank to abort.",
 206 load_config_help[] =
 207         "\n"
 208         "For various reasons, one may wish to keep several different\n"
 209         "configurations available on a single machine.\n"
 210         "\n"
 211         "If you have saved a previous configuration in a file other than the\n"
 212         "default one, entering its name here will allow you to modify that\n"
 213         "configuration.\n"
 214         "\n"
 215         "If you are uncertain, then you have probably never used alternate\n"
 216         "configuration files. You should therefore leave this blank to abort.\n",
 217 save_config_text[] =
 218         "Enter a filename to which this configuration should be saved "
 219         "as an alternate.  Leave blank to abort.",
 220 save_config_help[] =
 221         "\n"
 222         "For various reasons, one may wish to keep different configurations\n"
 223         "available on a single machine.\n"
 224         "\n"
 225         "Entering a file name here will allow you to later retrieve, modify\n"
 226         "and use the current configuration as an alternate to whatever\n"
 227         "configuration options you have selected at that time.\n"
 228         "\n"
 229         "If you are uncertain what all this means then you should probably\n"
 230         "leave this blank.\n",
 231 search_help[] =
 232         "\n"
 233         "Search for symbols and display their relations.\n"
 234         "Regular expressions are allowed.\n"
 235         "Example: search for \"^FOO\"\n"
 236         "Result:\n"
 237         "-----------------------------------------------------------------\n"
 238         "Symbol: FOO [=m]\n"
 239         "Type  : tristate\n"
 240         "Prompt: Foo bus is used to drive the bar HW\n"
 241         "  Location:\n"
 242         "    -> Bus options (PCI, PCMCIA, EISA, ISA)\n"
 243         "      -> PCI support (PCI [=y])\n"
 244         "(1)     -> PCI access mode (<choice> [=y])\n"
 245         "  Defined at drivers/pci/Kconfig:47\n"
 246         "  Depends on: X86_LOCAL_APIC && X86_IO_APIC || IA64\n"
 247         "  Selects: LIBCRC32\n"
 248         "  Selected by: BAR [=n]\n"
 249         "-----------------------------------------------------------------\n"
 250         "o The line 'Type:' shows the type of the configuration option for\n"
 251         "  this symbol (bool, tristate, string, ...)\n"
 252         "o The line 'Prompt:' shows the text used in the menu structure for\n"
 253         "  this symbol\n"
 254         "o The 'Defined at' line tells at what file / line number the symbol\n"
 255         "  is defined\n"
 256         "o The 'Depends on:' line tells what symbols need to be defined for\n"
 257         "  this symbol to be visible in the menu (selectable)\n"
 258         "o The 'Location:' lines tells where in the menu structure this symbol\n"
 259         "  is located\n"
 260         "    A location followed by a [=y] indicates that this is a\n"
 261         "    selectable menu item - and the current value is displayed inside\n"
 262         "    brackets.\n"
 263         "    Press the key in the (#) prefix to jump directly to that\n"
 264         "    location. You will be returned to the current search results\n"
 265         "    after exiting this new menu.\n"
 266         "o The 'Selects:' line tells what symbols will be automatically\n"
 267         "  selected if this symbol is selected (y or m)\n"
 268         "o The 'Selected by' line tells what symbol has selected this symbol\n"
 269         "\n"
 270         "Only relevant lines are shown.\n"
 271         "\n\n"
 272         "Search examples:\n"
 273         "Examples: USB  => find all symbols containing USB\n"
 274         "          ^USB => find all symbols starting with USB\n"
 275         "          USB$ => find all symbols ending with USB\n"
 276         "\n";
 277
 278 static int indent;
 279 static struct menu *current_menu;
 280 static int child_count;
 281 static int single_menu_mode;
 282 static int show_all_options;
 283 static int save_and_exit;
 284 static int silent;
 285
 286 static void conf(struct menu *menu, struct menu *active_menu);
 287 static void conf_choice(struct menu *menu);
 288 static void conf_string(struct menu *menu);
 289 static void conf_load(void);
 290 static void conf_save(void);
 291 static int show_textbox_ext(const char *title, char *text, int r, int c,
 292                             int *keys, int *vscroll, int *hscroll,
 293                             update_text_fn update_text, void *data);
 294 static void show_textbox(const char *title, const char *text, int r, int c);
 295 static void show_helptext(const char *title, const char *text);
 296 static void show_help(struct menu *menu);
 297
 298 static char filename[PATH_MAX+1];
 299 static void set_config_filename(const char *config_filename)
 300 {
 301         static char menu_backtitle[PATH_MAX+128];
 302
 303         snprintf(menu_backtitle, sizeof(menu_backtitle), "%s - %s",
 304                  config_filename, rootmenu.prompt->text);
 305         set_dialog_backtitle(menu_backtitle);
 306
 307         snprintf(filename, sizeof(filename), "%s", config_filename);
 308 }
 309
 310 struct subtitle_part {
 311         struct list_head entries;
 312         const char *text;
 313 };
 314 static LIST_HEAD(trail);
 315
 316 static struct subtitle_list *subtitles;
 317 static void set_subtitle(void)
 318 {
 319         struct subtitle_part *sp;
 320         struct subtitle_list *pos, *tmp;
 321
 322         for (pos = subtitles; pos != NULL; pos = tmp) {
 323                 tmp = pos->next;
 324                 free(pos);
 325         }
 326
 327         subtitles = NULL;
 328         list_for_each_entry(sp, &trail, entries) {
 329                 if (sp->text) {
 330                         if (pos) {
 331                                 pos->next = xcalloc(1, sizeof(*pos));
 332                                 pos = pos->next;
 333                         } else {
 334                                 subtitles = pos = xcalloc(1, sizeof(*pos));
 335                         }
 336                         pos->text = sp->text;
 337                 }
 338         }
 339
 340         set_dialog_subtitles(subtitles);
 341 }
 342
 343 static void reset_subtitle(void)
 344 {
 345         struct subtitle_list *pos, *tmp;
 346
 347         for (pos = subtitles; pos != NULL; pos = tmp) {
 348                 tmp = pos->next;
 349                 free(pos);
 350         }
 351         subtitles = NULL;
 352         set_dialog_subtitles(subtitles);
 353 }
 354
 355 struct search_data {
 356         struct list_head *head;
 357         struct menu **targets;
 358         int *keys;
 359 };
 360
 361 static void update_text(char *buf, size_t start, size_t end, void *_data)
 362 {
 363         struct search_data *data = _data;
 364         struct jump_key *pos;
 365         int k = 0;
 366
 367         list_for_each_entry(pos, data->head, entries) {
 368                 if (pos->offset >= start && pos->offset < end) {
 369                         char header[4];
 370
 371                         if (k < JUMP_NB) {
 372                                 int key = '0' + (pos->index % JUMP_NB) + 1;
 373
 374                                 sprintf(header, "(%c)", key);
 375                                 data->keys[k] = key;
 376                                 data->targets[k] = pos->target;
 377                                 k++;
 378                         } else {
 379                                 sprintf(header, "   ");
 380                         }
 381
 382                         memcpy(buf + pos->offset, header, sizeof(header) - 1);
 383                 }
 384         }
 385         data->keys[k] = 0;
 386 }
 387
 388 static void search_conf(void)
 389 {
 390         struct symbol **sym_arr;
 391         struct gstr res;
 392         struct gstr title;
 393         char *dialog_input;
 394         int dres, vscroll = 0, hscroll = 0;
 395         bool again;
 396         struct gstr sttext;
 397         struct subtitle_part stpart;
 398
 399         title = str_new();
 400         str_printf( &title, "Enter (sub)string or regexp to search for "
 401                               "(with or without \"%s\")", CONFIG_);
 402
 403 again:
 404         dialog_clear();
 405         dres = dialog_inputbox("Search Configuration Parameter",
 406                               str_get(&title),
 407                               10, 75, "");
 408         switch (dres) {
 409         case 0:
 410                 break;
 411         case 1:
 412                 show_helptext("Search Configuration", search_help);
 413                 goto again;
 414         default:
 415                 str_free(&title);
 416                 return;
 417         }
 418
 419         /* strip the prefix if necessary */
 420         dialog_input = dialog_input_result;
 421         if (strncasecmp(dialog_input_result, CONFIG_, strlen(CONFIG_)) == 0)
 422                 dialog_input += strlen(CONFIG_);
 423
 424         sttext = str_new();
 425         str_printf(&sttext, "Search (%s)", dialog_input_result);
 426         stpart.text = str_get(&sttext);
 427         list_add_tail(&stpart.entries, &trail);
 428
 429         sym_arr = sym_re_search(dialog_input);
 430         do {
 431                 LIST_HEAD(head);
 432                 struct menu *targets[JUMP_NB];
 433                 int keys[JUMP_NB + 1], i;
 434                 struct search_data data = {
 435                         .head = &head,
 436                         .targets = targets,
 437                         .keys = keys,
 438                 };
 439                 struct jump_key *pos, *tmp;
 440
 441                 res = get_relations_str(sym_arr, &head);
 442                 set_subtitle();
 443                 dres = show_textbox_ext("Search Results", str_get(&res), 0, 0,
 444                                         keys, &vscroll, &hscroll, &update_text,
 445                                         &data);
 446                 again = false;
 447                 for (i = 0; i < JUMP_NB && keys[i]; i++)
 448                         if (dres == keys[i]) {
 449                                 conf(targets[i]->parent, targets[i]);
 450                                 again = true;
 451                         }
 452                 str_free(&res);
 453                 list_for_each_entry_safe(pos, tmp, &head, entries)
 454                         free(pos);
 455         } while (again);
 456         free(sym_arr);
 457         str_free(&title);
 458         list_del(trail.prev);
 459         str_free(&sttext);
 460 }
 461
 462 static void build_conf(struct menu *menu)
 463 {
 464         struct symbol *sym;
 465         struct property *prop;
 466         struct menu *child;
 467         int type, tmp, doint = 2;
 468         tristate val;
 469         char ch;
 470         bool visible;
 471
 472         /*
 473          * note: menu_is_visible() has side effect that it will
 474          * recalc the value of the symbol.
 475          */
 476         visible = menu_is_visible(menu);
 477         if (show_all_options && !menu_has_prompt(menu))
 478                 return;
 479         else if (!show_all_options && !visible)
 480                 return;
 481
 482         sym = menu->sym;
 483         prop = menu->prompt;
 484         if (!sym) {
 485                 if (prop && menu != current_menu) {
 486                         const char *prompt = menu_get_prompt(menu);
 487                         switch (prop->type) {
 488                         case P_MENU:
 489                                 child_count++;
 490                                 if (single_menu_mode) {
 491                                         item_make("%s%*c%s",
 492                                                   menu->data ? "-->" : "++>",
 493                                                   indent + 1, ' ', prompt);
 494                                 } else
 495                                         item_make("   %*c%s  %s",
 496                                                   indent + 1, ' ', prompt,
 497                                                   menu_is_empty(menu) ? "----" : "--->");
 498                                 item_set_tag('m');
 499                                 item_set_data(menu);
 500                                 if (single_menu_mode && menu->data)
 501                                         goto conf_childs;
 502                                 return;
 503                         case P_COMMENT:
 504                                 if (prompt) {
 505                                         child_count++;
 506                                         item_make("   %*c*** %s ***", indent + 1, ' ', prompt);
 507                                         item_set_tag(':');
 508                                         item_set_data(menu);
 509                                 }
 510                                 break;
 511                         default:
 512                                 if (prompt) {
 513                                         child_count++;
 514                                         item_make("---%*c%s", indent + 1, ' ', prompt);
 515                                         item_set_tag(':');
 516                                         item_set_data(menu);
 517                                 }
 518                         }
 519                 } else
 520                         doint = 0;
 521                 goto conf_childs;
 522         }
 523
 524         type = sym_get_type(sym);
 525         if (sym_is_choice(sym)) {
 526                 struct symbol *def_sym = sym_get_choice_value(sym);
 527                 struct menu *def_menu = NULL;
 528
 529                 child_count++;
 530                 for (child = menu->list; child; child = child->next) {
 531                         if (menu_is_visible(child) && child->sym == def_sym)
 532                                 def_menu = child;
 533                 }
 534
 535                 val = sym_get_tristate_value(sym);
 536                 if (sym_is_changeable(sym)) {
 537                         switch (type) {
 538                         case S_BOOLEAN:
 539                                 item_make("[%c]", val == no ? ' ' : '*');
 540                                 break;
 541                         case S_TRISTATE:
 542                                 switch (val) {
 543                                 case yes: ch = '*'; break;
 544                                 case mod: ch = 'M'; break;
 545                                 default:  ch = ' '; break;
 546                                 }
 547                                 item_make("<%c>", ch);
 548                                 break;
 549                         }
 550                         item_set_tag('t');
 551                         item_set_data(menu);
 552                 } else {
 553                         item_make("   ");
 554                         item_set_tag(def_menu ? 't' : ':');
 555                         item_set_data(menu);
 556                 }
 557
 558                 item_add_str("%*c%s", indent + 1, ' ', menu_get_prompt(menu));
 559                 if (val == yes) {
 560                         if (def_menu) {
 561                                 item_add_str(" (%s)", menu_get_prompt(def_menu));
 562                                 item_add_str("  --->");
 563                                 if (def_menu->list) {
 564                                         indent += 2;
 565                                         build_conf(def_menu);
 566                                         indent -= 2;
 567                                 }
 568                         }
 569                         return;
 570                 }
 571         } else {
 572                 if (menu == current_menu) {
 573                         item_make("---%*c%s", indent + 1, ' ', menu_get_prompt(menu));
 574                         item_set_tag(':');
 575                         item_set_data(menu);
 576                         goto conf_childs;
 577                 }
 578                 child_count++;
 579                 val = sym_get_tristate_value(sym);
 580                 if (sym_is_choice_value(sym) && val == yes) {
 581                         item_make("   ");
 582                         item_set_tag(':');
 583                         item_set_data(menu);
 584                 } else {
 585                         switch (type) {
 586                         case S_BOOLEAN:
 587                                 if (sym_is_changeable(sym))
 588                                         item_make("[%c]", val == no ? ' ' : '*');
 589                                 else
 590                                         item_make("-%c-", val == no ? ' ' : '*');
 591                                 item_set_tag('t');
 592                                 item_set_data(menu);
 593                                 break;
 594                         case S_TRISTATE:
 595                                 switch (val) {
 596                                 case yes: ch = '*'; break;
 597                                 case mod: ch = 'M'; break;
 598                                 default:  ch = ' '; break;
 599                                 }
 600                                 if (sym_is_changeable(sym)) {
 601                                         if (sym->rev_dep.tri == mod)
 602                                                 item_make("{%c}", ch);
 603                                         else
 604                                                 item_make("<%c>", ch);
 605                                 } else
 606                                         item_make("-%c-", ch);
 607                                 item_set_tag('t');
 608                                 item_set_data(menu);
 609                                 break;
 610                         default:
 611                                 tmp = 2 + strlen(sym_get_string_value(sym)); /* () = 2 */
 612                                 item_make("(%s)", sym_get_string_value(sym));
 613                                 tmp = indent - tmp + 4;
 614                                 if (tmp < 0)
 615                                         tmp = 0;
 616                                 item_add_str("%*c%s%s", tmp, ' ', menu_get_prompt(menu),
 617                                              (sym_has_value(sym) || !sym_is_changeable(sym)) ?
 618                                              "" : " (NEW)");
 619                                 item_set_tag('s');
 620                                 item_set_data(menu);
 621                                 goto conf_childs;
 622                         }
 623                 }
 624                 item_add_str("%*c%s%s", indent + 1, ' ', menu_get_prompt(menu),
 625                           (sym_has_value(sym) || !sym_is_changeable(sym)) ?
 626                           "" : " (NEW)");
 627                 if (menu->prompt->type == P_MENU) {
 628                         item_add_str("  %s", menu_is_empty(menu) ? "----" : "--->");
 629                         return;
 630                 }
 631         }
 632
 633 conf_childs:
 634         indent += doint;
 635         for (child = menu->list; child; child = child->next)
 636                 build_conf(child);
 637         indent -= doint;
 638 }
 639
 640 static void conf(struct menu *menu, struct menu *active_menu)
 641 {
 642         struct menu *submenu;
 643         const char *prompt = menu_get_prompt(menu);
 644         struct subtitle_part stpart;
 645         struct symbol *sym;
 646         int res;
 647         int s_scroll = 0;
 648
 649         if (menu != &rootmenu)
 650                 stpart.text = menu_get_prompt(menu);
 651         else
 652                 stpart.text = NULL;
 653         list_add_tail(&stpart.entries, &trail);
 654
 655         while (1) {
 656                 item_reset();
 657                 current_menu = menu;
 658                 build_conf(menu);
 659                 if (!child_count)
 660                         break;
 661                 set_subtitle();
 662                 dialog_clear();
 663                 res = dialog_menu(prompt ? prompt : "Main Menu",
 664                                   menu_instructions,
 665                                   active_menu, &s_scroll);
 666                 if (res == 1 || res == KEY_ESC || res == -ERRDISPLAYTOOSMALL)
 667                         break;
 668                 if (item_count() != 0) {
 669                         if (!item_activate_selected())
 670                                 continue;
 671                         if (!item_tag())
 672                                 continue;
 673                 }
 674                 submenu = item_data();
 675                 active_menu = item_data();
 676                 if (submenu)
 677                         sym = submenu->sym;
 678                 else
 679                         sym = NULL;
 680
 681                 switch (res) {
 682                 case 0:
 683                         switch (item_tag()) {
 684                         case 'm':
 685                                 if (single_menu_mode)
 686                                         submenu->data = (void *) (long) !submenu->data;
 687                                 else
 688                                         conf(submenu, NULL);
 689                                 break;
 690                         case 't':
 691                                 if (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)
 692                                         conf_choice(submenu);
 693                                 else if (submenu->prompt->type == P_MENU)
 694                                         conf(submenu, NULL);
 695                                 break;
 696                         case 's':
 697                                 conf_string(submenu);
 698                                 break;
 699                         }
 700                         break;
 701                 case 2:
 702                         if (sym)
 703                                 show_help(submenu);
 704                         else {
 705                                 reset_subtitle();
 706                                 show_helptext("README", mconf_readme);
 707                         }
 708                         break;
 709                 case 3:
 710                         reset_subtitle();
 711                         conf_save();
 712                         break;
 713                 case 4:
 714                         reset_subtitle();
 715                         conf_load();
 716                         break;
 717                 case 5:
 718                         if (item_is_tag('t')) {
 719                                 if (sym_set_tristate_value(sym, yes))
 720                                         break;
 721                                 if (sym_set_tristate_value(sym, mod))
 722                                         show_textbox(NULL, setmod_text, 6, 74);
 723                         }
 724                         break;
 725                 case 6:
 726                         if (item_is_tag('t'))
 727                                 sym_set_tristate_value(sym, no);
 728                         break;
 729                 case 7:
 730                         if (item_is_tag('t'))
 731                                 sym_set_tristate_value(sym, mod);
 732                         break;
 733                 case 8:
 734                         if (item_is_tag('t'))
 735                                 sym_toggle_tristate_value(sym);
 736                         else if (item_is_tag('m'))
 737                                 conf(submenu, NULL);
 738                         break;
 739                 case 9:
 740                         search_conf();
 741                         break;
 742                 case 10:
 743                         show_all_options = !show_all_options;
 744                         break;
 745                 }
 746         }
 747
 748         list_del(trail.prev);
 749 }
 750
 751 static int show_textbox_ext(const char *title, char *text, int r, int c, int
 752                             *keys, int *vscroll, int *hscroll, update_text_fn
 753                             update_text, void *data)
 754 {
 755         dialog_clear();
 756         return dialog_textbox(title, text, r, c, keys, vscroll, hscroll,
 757                               update_text, data);
 758 }
 759
 760 static void show_textbox(const char *title, const char *text, int r, int c)
 761 {
 762         show_textbox_ext(title, (char *) text, r, c, (int []) {0}, NULL, NULL,
 763                          NULL, NULL);
 764 }
 765
 766 static void show_helptext(const char *title, const char *text)
 767 {
 768         show_textbox(title, text, 0, 0);
 769 }
 770
 771 static void conf_message_callback(const char *s)
 772 {
 773         if (save_and_exit) {
 774                 if (!silent)
 775                         printf("%s", s);
 776         } else {
 777                 show_textbox(NULL, s, 6, 60);
 778         }
 779 }
 780
 781 static void show_help(struct menu *menu)
 782 {
 783         struct gstr help = str_new();
 784
 785         help.max_width = getmaxx(stdscr) - 10;
 786         menu_get_ext_help(menu, &help);
 787
 788         show_helptext(menu_get_prompt(menu), str_get(&help));
 789         str_free(&help);
 790 }
 791
 792 static void conf_choice(struct menu *menu)
 793 {
 794         const char *prompt = menu_get_prompt(menu);
 795         struct menu *child;
 796         struct symbol *active;
 797
 798         active = sym_get_choice_value(menu->sym);
 799         while (1) {
 800                 int res;
 801                 int selected;
 802                 item_reset();
 803
 804                 current_menu = menu;
 805                 for (child = menu->list; child; child = child->next) {
 806                         if (!menu_is_visible(child))
 807                                 continue;
 808                         if (child->sym)
 809                                 item_make("%s", menu_get_prompt(child));
 810                         else {
 811                                 item_make("*** %s ***", menu_get_prompt(child));
 812                                 item_set_tag(':');
 813                         }
 814                         item_set_data(child);
 815                         if (child->sym == active)
 816                                 item_set_selected(1);
 817                         if (child->sym == sym_get_choice_value(menu->sym))
 818                                 item_set_tag('X');
 819                 }
 820                 dialog_clear();
 821                 res = dialog_checklist(prompt ? prompt : "Main Menu",
 822                                         radiolist_instructions,
 823                                         MENUBOX_HEIGTH_MIN,
 824                                         MENUBOX_WIDTH_MIN,
 825                                         CHECKLIST_HEIGTH_MIN);
 826                 selected = item_activate_selected();
 827                 switch (res) {
 828                 case 0:
 829                         if (selected) {
 830                                 child = item_data();
 831                                 if (!child->sym)
 832                                         break;
 833
 834                                 sym_set_tristate_value(child->sym, yes);
 835                         }
 836                         return;
 837                 case 1:
 838                         if (selected) {
 839                                 child = item_data();
 840                                 show_help(child);
 841                                 active = child->sym;
 842                         } else
 843                                 show_help(menu);
 844                         break;
 845                 case KEY_ESC:
 846                         return;
 847                 case -ERRDISPLAYTOOSMALL:
 848                         return;
 849                 }
 850         }
 851 }
 852
 853 static void conf_string(struct menu *menu)
 854 {
 855         const char *prompt = menu_get_prompt(menu);
 856
 857         while (1) {
 858                 int res;
 859                 const char *heading;
 860
 861                 switch (sym_get_type(menu->sym)) {
 862                 case S_INT:
 863                         heading = inputbox_instructions_int;
 864                         break;
 865                 case S_HEX:
 866                         heading = inputbox_instructions_hex;
 867                         break;
 868                 case S_STRING:
 869                         heading = inputbox_instructions_string;
 870                         break;
 871                 default:
 872                         heading = "Internal mconf error!";
 873                 }
 874                 dialog_clear();
 875                 res = dialog_inputbox(prompt ? prompt : "Main Menu",
 876                                       heading, 10, 75,
 877                                       sym_get_string_value(menu->sym));
 878                 switch (res) {
 879                 case 0:
 880                         if (sym_set_string_value(menu->sym, dialog_input_result))
 881                                 return;
 882                         show_textbox(NULL, "You have made an invalid entry.", 5, 43);
 883                         break;
 884                 case 1:
 885                         show_help(menu);
 886                         break;
 887                 case KEY_ESC:
 888                         return;
 889                 }
 890         }
 891 }
 892
 893 static void conf_load(void)
 894 {
 895
 896         while (1) {
 897                 int res;
 898                 dialog_clear();
 899                 res = dialog_inputbox(NULL, load_config_text,
 900                                       11, 55, filename);
 901                 switch(res) {
 902                 case 0:
 903                         if (!dialog_input_result[0])
 904                                 return;
 905                         if (!conf_read(dialog_input_result)) {
 906                                 set_config_filename(dialog_input_result);
 907                                 conf_set_changed(true);
 908                                 return;
 909                         }
 910                         show_textbox(NULL, "File does not exist!", 5, 38);
 911                         break;
 912                 case 1:
 913                         show_helptext("Load Alternate Configuration", load_config_help);
 914                         break;
 915                 case KEY_ESC:
 916                         return;
 917                 }
 918         }
 919 }
 920
 921 static void conf_save(void)
 922 {
 923         while (1) {
 924                 int res;
 925                 dialog_clear();
 926                 res = dialog_inputbox(NULL, save_config_text,
 927                                       11, 55, filename);
 928                 switch(res) {
 929                 case 0:
 930                         if (!dialog_input_result[0])
 931                                 return;
 932                         if (!conf_write(dialog_input_result)) {
 933                                 set_config_filename(dialog_input_result);
 934                                 return;
 935                         }
 936                         show_textbox(NULL, "Can't create file!", 5, 60);
 937                         break;
 938                 case 1:
 939                         show_helptext("Save Alternate Configuration", save_config_help);
 940                         break;
 941                 case KEY_ESC:
 942                         return;
 943                 }
 944         }
 945 }
 946
 947 static int handle_exit(void)
 948 {
 949         int res;
 950
 951         save_and_exit = 1;
 952         reset_subtitle();
 953         dialog_clear();
 954         if (conf_get_changed())
 955                 res = dialog_yesno(NULL,
 956                                    "Do you wish to save your new configuration?\n"
 957                                      "(Press <ESC><ESC> to continue kernel configuration.)",
 958                                    6, 60);
 959         else
 960                 res = -1;
 961
 962         end_dialog(saved_x, saved_y);
 963
 964         switch (res) {
 965         case 0:
 966                 if (conf_write(filename)) {
 967                         fprintf(stderr, "\n\n"
 968                                           "Error while writing of the configuration.\n"
 969                                           "Your configuration changes were NOT saved."
 970                                           "\n\n");
 971                         return 1;
 972                 }
 973                 conf_write_autoconf(0);
 974                 /* fall through */
 975         case -1:
 976                 if (!silent)
 977                         printf("\n\n"
 978                                  "*** End of the configuration.\n"
 979                                  "*** Execute 'make' to start the build or try 'make help'."
 980                                  "\n\n");
 981                 res = 0;
 982                 break;
 983         default:
 984                 if (!silent)
 985                         fprintf(stderr, "\n\n"
 986                                           "Your configuration changes were NOT saved."
 987                                           "\n\n");
 988                 if (res != KEY_ESC)
 989                         res = 0;
 990         }
 991
 992         return res;
 993 }
 994
 995 static void sig_handler(int signo)
 996 {
 997         exit(handle_exit());
 998 }
 999
1000 int main(int ac, char **av)
1001 {
1002         char *mode;
1003         int res;
1004
1005         signal(SIGINT, sig_handler);
1006
1007         if (ac > 1 && strcmp(av[1], "-s") == 0) {
1008                 silent = 1;
1009                 /* Silence conf_read() until the real callback is set up */
1010                 conf_set_message_callback(NULL);
1011                 av++;
1012         }
1013         conf_parse(av[1]);
1014         conf_read(NULL);
1015
1016         mode = getenv("MENUCONFIG_MODE");
1017         if (mode) {
1018                 if (!strcasecmp(mode, "single_menu"))
1019                         single_menu_mode = 1;
1020         }
1021
1022         if (init_dialog(NULL)) {
1023                 fprintf(stderr, "Your display is too small to run Menuconfig!\n");
1024                 fprintf(stderr, "It must be at least 19 lines by 80 columns.\n");
1025                 return 1;
1026         }
1027
1028         set_config_filename(conf_get_configname());
1029         conf_set_message_callback(conf_message_callback);
1030         do {
1031                 conf(&rootmenu, NULL);
1032                 res = handle_exit();
1033         } while (res == KEY_ESC);
1034
1035         return res;
1036 }