Merge branch 'kbuild/rc-fixes' into kbuild/kconfig
[~shefty/rdma-dev.git] / 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 <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 <signal.h>
19 #include <unistd.h>
20 #include <locale.h>
21
22 #include "lkc.h"
23 #include "lxdialog/dialog.h"
24
25 static const char mconf_readme[] = N_(
26 "Overview\n"
27 "--------\n"
28 "This interface let you select features and parameters for the build.\n"
29 "Features can either be built-in, modularized, or ignored. Parameters\n"
30 "must be entered in as decimal or hexadecimal numbers or text.\n"
31 "\n"
32 "Menu items beginning with following braces represent features that\n"
33 "  [ ] can be built in or removed\n"
34 "  < > can be built in, modularized or removed\n"
35 "  { } can be built in or modularized (selected by other feature)\n"
36 "  - - are selected by other feature,\n"
37 "while *, M or whitespace inside braces means to build in, build as\n"
38 "a module or to exclude the feature respectively.\n"
39 "\n"
40 "To change any of these features, highlight it with the cursor\n"
41 "keys and press <Y> to build it in, <M> to make it a module or\n"
42 "<N> to removed it.  You may also press the <Space Bar> to cycle\n"
43 "through the available options (ie. Y->N->M->Y).\n"
44 "\n"
45 "Some additional keyboard hints:\n"
46 "\n"
47 "Menus\n"
48 "----------\n"
49 "o  Use the Up/Down arrow keys (cursor keys) to highlight the item\n"
50 "   you wish to change or submenu wish to select and press <Enter>.\n"
51 "   Submenus are designated by \"--->\".\n"
52 "\n"
53 "   Shortcut: Press the option's highlighted letter (hotkey).\n"
54 "             Pressing a hotkey more than once will sequence\n"
55 "             through all visible items which use that hotkey.\n"
56 "\n"
57 "   You may also use the <PAGE UP> and <PAGE DOWN> keys to scroll\n"
58 "   unseen options into view.\n"
59 "\n"
60 "o  To exit a menu use the cursor keys to highlight the <Exit> button\n"
61 "   and press <ENTER>.\n"
62 "\n"
63 "   Shortcut: Press <ESC><ESC> or <E> or <X> if there is no hotkey\n"
64 "             using those letters.  You may press a single <ESC>, but\n"
65 "             there is a delayed response which you may find annoying.\n"
66 "\n"
67 "   Also, the <TAB> and cursor keys will cycle between <Select>,\n"
68 "   <Exit> and <Help>.\n"
69 "\n"
70 "o  To get help with an item, use the cursor keys to highlight <Help>\n"
71 "   and press <ENTER>.\n"
72 "\n"
73 "   Shortcut: Press <H> or <?>.\n"
74 "\n"
75 "o  To toggle the display of hidden options, press <Z>.\n"
76 "\n"
77 "\n"
78 "Radiolists  (Choice lists)\n"
79 "-----------\n"
80 "o  Use the cursor keys to select the option you wish to set and press\n"
81 "   <S> or the <SPACE BAR>.\n"
82 "\n"
83 "   Shortcut: Press the first letter of the option you wish to set then\n"
84 "             press <S> or <SPACE BAR>.\n"
85 "\n"
86 "o  To see available help for the item, use the cursor keys to highlight\n"
87 "   <Help> and Press <ENTER>.\n"
88 "\n"
89 "   Shortcut: Press <H> or <?>.\n"
90 "\n"
91 "   Also, the <TAB> and cursor keys will cycle between <Select> and\n"
92 "   <Help>\n"
93 "\n"
94 "\n"
95 "Data Entry\n"
96 "-----------\n"
97 "o  Enter the requested information and press <ENTER>\n"
98 "   If you are entering hexadecimal values, it is not necessary to\n"
99 "   add the '0x' prefix to the entry.\n"
100 "\n"
101 "o  For help, use the <TAB> or cursor keys to highlight the help option\n"
102 "   and press <ENTER>.  You can try <TAB><H> as well.\n"
103 "\n"
104 "\n"
105 "Text Box    (Help Window)\n"
106 "--------\n"
107 "o  Use the cursor keys to scroll up/down/left/right.  The VI editor\n"
108 "   keys h,j,k,l function here as do <u>, <d>, <SPACE BAR> and <B> for \n"
109 "   those who are familiar with less and lynx.\n"
110 "\n"
111 "o  Press <E>, <X>, <q>, <Enter> or <Esc><Esc> to exit.\n"
112 "\n"
113 "\n"
114 "Alternate Configuration Files\n"
115 "-----------------------------\n"
116 "Menuconfig supports the use of alternate configuration files for\n"
117 "those who, for various reasons, find it necessary to switch\n"
118 "between different configurations.\n"
119 "\n"
120 "At the end of the main menu you will find two options.  One is\n"
121 "for saving the current configuration to a file of your choosing.\n"
122 "The other option is for loading a previously saved alternate\n"
123 "configuration.\n"
124 "\n"
125 "Even if you don't use alternate configuration files, but you\n"
126 "find during a Menuconfig session that you have completely messed\n"
127 "up your settings, you may use the \"Load Alternate...\" option to\n"
128 "restore your previously saved settings from \".config\" without\n"
129 "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 a xterm definition which supports color.\n"
135 "Otherwise, Menuconfig will look rather bad.  Menuconfig will not\n"
136 "display correctly in a 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, rather\n"
152 "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  => a LCD friendly version of classic. (default)\n"
176 "\n"),
177 menu_instructions[] = N_(
178         "Arrow keys navigate the menu.  "
179         "<Enter> selects 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[] = N_(
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[] = N_(
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[] = N_(
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[] = N_(
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[] = N_(
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[] = N_(
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[] = N_(
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[] = N_(
218         "Enter a filename to which this configuration should be saved "
219         "as an alternate.  Leave blank to abort."),
220 save_config_help[] = N_(
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[] = N_(
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         "  Defined at drivers/pci/Kconfig:47\n"
242         "  Depends on: X86_LOCAL_APIC && X86_IO_APIC || IA64\n"
243         "  Location:\n"
244         "    -> Bus options (PCI, PCMCIA, EISA, ISA)\n"
245         "      -> PCI support (PCI [=y])\n"
246         "(1)     -> PCI access mode (<choice> [=y])\n"
247         "  Selects: LIBCRC32\n"
248         "  Selected by: BAR\n"
249         "-----------------------------------------------------------------\n"
250         "o The line 'Type:' shows the type of the configuration option for\n"
251         "  this symbol (boolean, 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 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] 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 tell what symbol will be automatically\n"
267         "  selected if this symbol is selected (y or m)\n"
268         "o The 'Selected by' line tell 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
285 static void conf(struct menu *menu, struct menu *active_menu);
286 static void conf_choice(struct menu *menu);
287 static void conf_string(struct menu *menu);
288 static void conf_load(void);
289 static void conf_save(void);
290 static int show_textbox_ext(const char *title, char *text, int r, int c,
291                             int *keys, int *vscroll, int *hscroll,
292                             update_text_fn update_text, void *data);
293 static void show_textbox(const char *title, const char *text, int r, int c);
294 static void show_helptext(const char *title, const char *text);
295 static void show_help(struct menu *menu);
296
297 static char filename[PATH_MAX+1];
298 static void set_config_filename(const char *config_filename)
299 {
300         static char menu_backtitle[PATH_MAX+128];
301         int size;
302
303         size = snprintf(menu_backtitle, sizeof(menu_backtitle),
304                         "%s - %s", config_filename, rootmenu.prompt->text);
305         if (size >= sizeof(menu_backtitle))
306                 menu_backtitle[sizeof(menu_backtitle)-1] = '\0';
307         set_dialog_backtitle(menu_backtitle);
308
309         size = snprintf(filename, sizeof(filename), "%s", config_filename);
310         if (size >= sizeof(filename))
311                 filename[sizeof(filename)-1] = '\0';
312 }
313
314
315 struct search_data {
316         struct list_head *head;
317         struct menu **targets;
318         int *keys;
319 };
320
321 static void update_text(char *buf, size_t start, size_t end, void *_data)
322 {
323         struct search_data *data = _data;
324         struct jump_key *pos;
325         int k = 0;
326
327         list_for_each_entry(pos, data->head, entries) {
328                 if (pos->offset >= start && pos->offset < end) {
329                         char header[4];
330
331                         if (k < JUMP_NB) {
332                                 int key = '0' + (pos->index % JUMP_NB) + 1;
333
334                                 sprintf(header, "(%c)", key);
335                                 data->keys[k] = key;
336                                 data->targets[k] = pos->target;
337                                 k++;
338                         } else {
339                                 sprintf(header, "   ");
340                         }
341
342                         memcpy(buf + pos->offset, header, sizeof(header) - 1);
343                 }
344         }
345         data->keys[k] = 0;
346 }
347
348 static void search_conf(void)
349 {
350         struct symbol **sym_arr;
351         struct gstr res;
352         struct gstr title;
353         char *dialog_input;
354         int dres, vscroll = 0, hscroll = 0;
355         bool again;
356
357         title = str_new();
358         str_printf( &title, _("Enter %s (sub)string to search for "
359                               "(with or without \"%s\")"), CONFIG_, CONFIG_);
360
361 again:
362         dialog_clear();
363         dres = dialog_inputbox(_("Search Configuration Parameter"),
364                               str_get(&title),
365                               10, 75, "");
366         switch (dres) {
367         case 0:
368                 break;
369         case 1:
370                 show_helptext(_("Search Configuration"), search_help);
371                 goto again;
372         default:
373                 str_free(&title);
374                 return;
375         }
376
377         /* strip the prefix if necessary */
378         dialog_input = dialog_input_result;
379         if (strncasecmp(dialog_input_result, CONFIG_, strlen(CONFIG_)) == 0)
380                 dialog_input += strlen(CONFIG_);
381
382         sym_arr = sym_re_search(dialog_input);
383         do {
384                 LIST_HEAD(head);
385                 struct menu *targets[JUMP_NB];
386                 int keys[JUMP_NB + 1], i;
387                 struct search_data data = {
388                         .head = &head,
389                         .targets = targets,
390                         .keys = keys,
391                 };
392
393                 res = get_relations_str(sym_arr, &head);
394                 dres = show_textbox_ext(_("Search Results"), (char *)
395                                         str_get(&res), 0, 0, keys, &vscroll,
396                                         &hscroll, &update_text, (void *)
397                                         &data);
398                 again = false;
399                 for (i = 0; i < JUMP_NB && keys[i]; i++)
400                         if (dres == keys[i]) {
401                                 conf(targets[i]->parent, targets[i]);
402                                 again = true;
403                         }
404                 str_free(&res);
405         } while (again);
406         free(sym_arr);
407         str_free(&title);
408 }
409
410 static void build_conf(struct menu *menu)
411 {
412         struct symbol *sym;
413         struct property *prop;
414         struct menu *child;
415         int type, tmp, doint = 2;
416         tristate val;
417         char ch;
418         bool visible;
419
420         /*
421          * note: menu_is_visible() has side effect that it will
422          * recalc the value of the symbol.
423          */
424         visible = menu_is_visible(menu);
425         if (show_all_options && !menu_has_prompt(menu))
426                 return;
427         else if (!show_all_options && !visible)
428                 return;
429
430         sym = menu->sym;
431         prop = menu->prompt;
432         if (!sym) {
433                 if (prop && menu != current_menu) {
434                         const char *prompt = menu_get_prompt(menu);
435                         switch (prop->type) {
436                         case P_MENU:
437                                 child_count++;
438                                 prompt = _(prompt);
439                                 if (single_menu_mode) {
440                                         item_make("%s%*c%s",
441                                                   menu->data ? "-->" : "++>",
442                                                   indent + 1, ' ', prompt);
443                                 } else
444                                         item_make("   %*c%s  --->", indent + 1, ' ', prompt);
445
446                                 item_set_tag('m');
447                                 item_set_data(menu);
448                                 if (single_menu_mode && menu->data)
449                                         goto conf_childs;
450                                 return;
451                         case P_COMMENT:
452                                 if (prompt) {
453                                         child_count++;
454                                         item_make("   %*c*** %s ***", indent + 1, ' ', _(prompt));
455                                         item_set_tag(':');
456                                         item_set_data(menu);
457                                 }
458                                 break;
459                         default:
460                                 if (prompt) {
461                                         child_count++;
462                                         item_make("---%*c%s", indent + 1, ' ', _(prompt));
463                                         item_set_tag(':');
464                                         item_set_data(menu);
465                                 }
466                         }
467                 } else
468                         doint = 0;
469                 goto conf_childs;
470         }
471
472         type = sym_get_type(sym);
473         if (sym_is_choice(sym)) {
474                 struct symbol *def_sym = sym_get_choice_value(sym);
475                 struct menu *def_menu = NULL;
476
477                 child_count++;
478                 for (child = menu->list; child; child = child->next) {
479                         if (menu_is_visible(child) && child->sym == def_sym)
480                                 def_menu = child;
481                 }
482
483                 val = sym_get_tristate_value(sym);
484                 if (sym_is_changable(sym)) {
485                         switch (type) {
486                         case S_BOOLEAN:
487                                 item_make("[%c]", val == no ? ' ' : '*');
488                                 break;
489                         case S_TRISTATE:
490                                 switch (val) {
491                                 case yes: ch = '*'; break;
492                                 case mod: ch = 'M'; break;
493                                 default:  ch = ' '; break;
494                                 }
495                                 item_make("<%c>", ch);
496                                 break;
497                         }
498                         item_set_tag('t');
499                         item_set_data(menu);
500                 } else {
501                         item_make("   ");
502                         item_set_tag(def_menu ? 't' : ':');
503                         item_set_data(menu);
504                 }
505
506                 item_add_str("%*c%s", indent + 1, ' ', _(menu_get_prompt(menu)));
507                 if (val == yes) {
508                         if (def_menu) {
509                                 item_add_str(" (%s)", _(menu_get_prompt(def_menu)));
510                                 item_add_str("  --->");
511                                 if (def_menu->list) {
512                                         indent += 2;
513                                         build_conf(def_menu);
514                                         indent -= 2;
515                                 }
516                         }
517                         return;
518                 }
519         } else {
520                 if (menu == current_menu) {
521                         item_make("---%*c%s", indent + 1, ' ', _(menu_get_prompt(menu)));
522                         item_set_tag(':');
523                         item_set_data(menu);
524                         goto conf_childs;
525                 }
526                 child_count++;
527                 val = sym_get_tristate_value(sym);
528                 if (sym_is_choice_value(sym) && val == yes) {
529                         item_make("   ");
530                         item_set_tag(':');
531                         item_set_data(menu);
532                 } else {
533                         switch (type) {
534                         case S_BOOLEAN:
535                                 if (sym_is_changable(sym))
536                                         item_make("[%c]", val == no ? ' ' : '*');
537                                 else
538                                         item_make("-%c-", val == no ? ' ' : '*');
539                                 item_set_tag('t');
540                                 item_set_data(menu);
541                                 break;
542                         case S_TRISTATE:
543                                 switch (val) {
544                                 case yes: ch = '*'; break;
545                                 case mod: ch = 'M'; break;
546                                 default:  ch = ' '; break;
547                                 }
548                                 if (sym_is_changable(sym)) {
549                                         if (sym->rev_dep.tri == mod)
550                                                 item_make("{%c}", ch);
551                                         else
552                                                 item_make("<%c>", ch);
553                                 } else
554                                         item_make("-%c-", ch);
555                                 item_set_tag('t');
556                                 item_set_data(menu);
557                                 break;
558                         default:
559                                 tmp = 2 + strlen(sym_get_string_value(sym)); /* () = 2 */
560                                 item_make("(%s)", sym_get_string_value(sym));
561                                 tmp = indent - tmp + 4;
562                                 if (tmp < 0)
563                                         tmp = 0;
564                                 item_add_str("%*c%s%s", tmp, ' ', _(menu_get_prompt(menu)),
565                                              (sym_has_value(sym) || !sym_is_changable(sym)) ?
566                                              "" : _(" (NEW)"));
567                                 item_set_tag('s');
568                                 item_set_data(menu);
569                                 goto conf_childs;
570                         }
571                 }
572                 item_add_str("%*c%s%s", indent + 1, ' ', _(menu_get_prompt(menu)),
573                           (sym_has_value(sym) || !sym_is_changable(sym)) ?
574                           "" : _(" (NEW)"));
575                 if (menu->prompt->type == P_MENU) {
576                         item_add_str("  --->");
577                         return;
578                 }
579         }
580
581 conf_childs:
582         indent += doint;
583         for (child = menu->list; child; child = child->next)
584                 build_conf(child);
585         indent -= doint;
586 }
587
588 static void conf(struct menu *menu, struct menu *active_menu)
589 {
590         struct menu *submenu;
591         const char *prompt = menu_get_prompt(menu);
592         struct symbol *sym;
593         int res;
594         int s_scroll = 0;
595
596         while (1) {
597                 item_reset();
598                 current_menu = menu;
599                 build_conf(menu);
600                 if (!child_count)
601                         break;
602                 dialog_clear();
603                 res = dialog_menu(prompt ? _(prompt) : _("Main Menu"),
604                                   _(menu_instructions),
605                                   active_menu, &s_scroll);
606                 if (res == 1 || res == KEY_ESC || res == -ERRDISPLAYTOOSMALL)
607                         break;
608                 if (!item_activate_selected())
609                         continue;
610                 if (!item_tag())
611                         continue;
612
613                 submenu = item_data();
614                 active_menu = item_data();
615                 if (submenu)
616                         sym = submenu->sym;
617                 else
618                         sym = NULL;
619
620                 switch (res) {
621                 case 0:
622                         switch (item_tag()) {
623                         case 'm':
624                                 if (single_menu_mode)
625                                         submenu->data = (void *) (long) !submenu->data;
626                                 else
627                                         conf(submenu, NULL);
628                                 break;
629                         case 't':
630                                 if (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)
631                                         conf_choice(submenu);
632                                 else if (submenu->prompt->type == P_MENU)
633                                         conf(submenu, NULL);
634                                 break;
635                         case 's':
636                                 conf_string(submenu);
637                                 break;
638                         }
639                         break;
640                 case 2:
641                         if (sym)
642                                 show_help(submenu);
643                         else
644                                 show_helptext(_("README"), _(mconf_readme));
645                         break;
646                 case 3:
647                         conf_save();
648                         break;
649                 case 4:
650                         conf_load();
651                         break;
652                 case 5:
653                         if (item_is_tag('t')) {
654                                 if (sym_set_tristate_value(sym, yes))
655                                         break;
656                                 if (sym_set_tristate_value(sym, mod))
657                                         show_textbox(NULL, setmod_text, 6, 74);
658                         }
659                         break;
660                 case 6:
661                         if (item_is_tag('t'))
662                                 sym_set_tristate_value(sym, no);
663                         break;
664                 case 7:
665                         if (item_is_tag('t'))
666                                 sym_set_tristate_value(sym, mod);
667                         break;
668                 case 8:
669                         if (item_is_tag('t'))
670                                 sym_toggle_tristate_value(sym);
671                         else if (item_is_tag('m'))
672                                 conf(submenu, NULL);
673                         break;
674                 case 9:
675                         search_conf();
676                         break;
677                 case 10:
678                         show_all_options = !show_all_options;
679                         break;
680                 }
681         }
682 }
683
684 static int show_textbox_ext(const char *title, char *text, int r, int c, int
685                             *keys, int *vscroll, int *hscroll, update_text_fn
686                             update_text, void *data)
687 {
688         dialog_clear();
689         return dialog_textbox(title, text, r, c, keys, vscroll, hscroll,
690                               update_text, data);
691 }
692
693 static void show_textbox(const char *title, const char *text, int r, int c)
694 {
695         show_textbox_ext(title, (char *) text, r, c, (int []) {0}, NULL, NULL,
696                          NULL, NULL);
697 }
698
699 static void show_helptext(const char *title, const char *text)
700 {
701         show_textbox(title, text, 0, 0);
702 }
703
704 static void conf_message_callback(const char *fmt, va_list ap)
705 {
706         char buf[PATH_MAX+1];
707
708         vsnprintf(buf, sizeof(buf), fmt, ap);
709         if (save_and_exit)
710                 printf("%s", buf);
711         else
712                 show_textbox(NULL, buf, 6, 60);
713 }
714
715 static void show_help(struct menu *menu)
716 {
717         struct gstr help = str_new();
718
719         help.max_width = getmaxx(stdscr) - 10;
720         menu_get_ext_help(menu, &help);
721
722         show_helptext(_(menu_get_prompt(menu)), str_get(&help));
723         str_free(&help);
724 }
725
726 static void conf_choice(struct menu *menu)
727 {
728         const char *prompt = _(menu_get_prompt(menu));
729         struct menu *child;
730         struct symbol *active;
731
732         active = sym_get_choice_value(menu->sym);
733         while (1) {
734                 int res;
735                 int selected;
736                 item_reset();
737
738                 current_menu = menu;
739                 for (child = menu->list; child; child = child->next) {
740                         if (!menu_is_visible(child))
741                                 continue;
742                         if (child->sym)
743                                 item_make("%s", _(menu_get_prompt(child)));
744                         else {
745                                 item_make("*** %s ***", _(menu_get_prompt(child)));
746                                 item_set_tag(':');
747                         }
748                         item_set_data(child);
749                         if (child->sym == active)
750                                 item_set_selected(1);
751                         if (child->sym == sym_get_choice_value(menu->sym))
752                                 item_set_tag('X');
753                 }
754                 dialog_clear();
755                 res = dialog_checklist(prompt ? _(prompt) : _("Main Menu"),
756                                         _(radiolist_instructions),
757                                          15, 70, 6);
758                 selected = item_activate_selected();
759                 switch (res) {
760                 case 0:
761                         if (selected) {
762                                 child = item_data();
763                                 if (!child->sym)
764                                         break;
765
766                                 sym_set_tristate_value(child->sym, yes);
767                         }
768                         return;
769                 case 1:
770                         if (selected) {
771                                 child = item_data();
772                                 show_help(child);
773                                 active = child->sym;
774                         } else
775                                 show_help(menu);
776                         break;
777                 case KEY_ESC:
778                         return;
779                 case -ERRDISPLAYTOOSMALL:
780                         return;
781                 }
782         }
783 }
784
785 static void conf_string(struct menu *menu)
786 {
787         const char *prompt = menu_get_prompt(menu);
788
789         while (1) {
790                 int res;
791                 const char *heading;
792
793                 switch (sym_get_type(menu->sym)) {
794                 case S_INT:
795                         heading = _(inputbox_instructions_int);
796                         break;
797                 case S_HEX:
798                         heading = _(inputbox_instructions_hex);
799                         break;
800                 case S_STRING:
801                         heading = _(inputbox_instructions_string);
802                         break;
803                 default:
804                         heading = _("Internal mconf error!");
805                 }
806                 dialog_clear();
807                 res = dialog_inputbox(prompt ? _(prompt) : _("Main Menu"),
808                                       heading, 10, 75,
809                                       sym_get_string_value(menu->sym));
810                 switch (res) {
811                 case 0:
812                         if (sym_set_string_value(menu->sym, dialog_input_result))
813                                 return;
814                         show_textbox(NULL, _("You have made an invalid entry."), 5, 43);
815                         break;
816                 case 1:
817                         show_help(menu);
818                         break;
819                 case KEY_ESC:
820                         return;
821                 }
822         }
823 }
824
825 static void conf_load(void)
826 {
827
828         while (1) {
829                 int res;
830                 dialog_clear();
831                 res = dialog_inputbox(NULL, load_config_text,
832                                       11, 55, filename);
833                 switch(res) {
834                 case 0:
835                         if (!dialog_input_result[0])
836                                 return;
837                         if (!conf_read(dialog_input_result)) {
838                                 set_config_filename(dialog_input_result);
839                                 sym_set_change_count(1);
840                                 return;
841                         }
842                         show_textbox(NULL, _("File does not exist!"), 5, 38);
843                         break;
844                 case 1:
845                         show_helptext(_("Load Alternate Configuration"), load_config_help);
846                         break;
847                 case KEY_ESC:
848                         return;
849                 }
850         }
851 }
852
853 static void conf_save(void)
854 {
855         while (1) {
856                 int res;
857                 dialog_clear();
858                 res = dialog_inputbox(NULL, save_config_text,
859                                       11, 55, filename);
860                 switch(res) {
861                 case 0:
862                         if (!dialog_input_result[0])
863                                 return;
864                         if (!conf_write(dialog_input_result)) {
865                                 set_config_filename(dialog_input_result);
866                                 return;
867                         }
868                         show_textbox(NULL, _("Can't create file!  Probably a nonexistent directory."), 5, 60);
869                         break;
870                 case 1:
871                         show_helptext(_("Save Alternate Configuration"), save_config_help);
872                         break;
873                 case KEY_ESC:
874                         return;
875                 }
876         }
877 }
878
879 static int handle_exit(void)
880 {
881         int res;
882
883         save_and_exit = 1;
884         dialog_clear();
885         if (conf_get_changed())
886                 res = dialog_yesno(NULL,
887                                    _("Do you wish to save your new configuration ?\n"
888                                      "<ESC><ESC> to continue."),
889                                    6, 60);
890         else
891                 res = -1;
892
893         end_dialog(saved_x, saved_y);
894
895         switch (res) {
896         case 0:
897                 if (conf_write(filename)) {
898                         fprintf(stderr, _("\n\n"
899                                           "Error while writing of the configuration.\n"
900                                           "Your configuration changes were NOT saved."
901                                           "\n\n"));
902                         return 1;
903                 }
904                 /* fall through */
905         case -1:
906                 printf(_("\n\n"
907                          "*** End of the configuration.\n"
908                          "*** Execute 'make' to start the build or try 'make help'."
909                          "\n\n"));
910                 res = 0;
911                 break;
912         default:
913                 fprintf(stderr, _("\n\n"
914                                   "Your configuration changes were NOT saved."
915                                   "\n\n"));
916                 if (res != KEY_ESC)
917                         res = 0;
918         }
919
920         return res;
921 }
922
923 static void sig_handler(int signo)
924 {
925         exit(handle_exit());
926 }
927
928 int main(int ac, char **av)
929 {
930         char *mode;
931         int res;
932
933         setlocale(LC_ALL, "");
934         bindtextdomain(PACKAGE, LOCALEDIR);
935         textdomain(PACKAGE);
936
937         signal(SIGINT, sig_handler);
938
939         conf_parse(av[1]);
940         conf_read(NULL);
941
942         mode = getenv("MENUCONFIG_MODE");
943         if (mode) {
944                 if (!strcasecmp(mode, "single_menu"))
945                         single_menu_mode = 1;
946         }
947
948         if (init_dialog(NULL)) {
949                 fprintf(stderr, N_("Your display is too small to run Menuconfig!\n"));
950                 fprintf(stderr, N_("It must be at least 19 lines by 80 columns.\n"));
951                 return 1;
952         }
953
954         set_config_filename(conf_get_configname());
955         conf_set_message_callback(conf_message_callback);
956         do {
957                 conf(&rootmenu, NULL);
958                 res = handle_exit();
959         } while (res == KEY_ESC);
960
961         return res;
962 }
963