scripts/kconfig/mconf.c

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