kconfig/conf: add command line options' description
[linux-2.6.git] / scripts / kconfig / conf.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
6 #include <locale.h>
7 #include <ctype.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <time.h>
12 #include <unistd.h>
13 #include <getopt.h>
14 #include <sys/stat.h>
15 #include <sys/time.h>
16
17 #include "lkc.h"
18
19 static void conf(struct menu *menu);
20 static void check_conf(struct menu *menu);
21
22 enum input_mode {
23         oldaskconfig,
24         silentoldconfig,
25         oldconfig,
26         allnoconfig,
27         allyesconfig,
28         allmodconfig,
29         alldefconfig,
30         randconfig,
31         defconfig,
32         savedefconfig,
33         listnewconfig,
34         oldnoconfig,
35 } input_mode = oldaskconfig;
36
37 static int indent = 1;
38 static int valid_stdin = 1;
39 static int sync_kconfig;
40 static int conf_cnt;
41 static char line[128];
42 static struct menu *rootEntry;
43
44 static void print_help(struct menu *menu)
45 {
46         struct gstr help = str_new();
47
48         menu_get_ext_help(menu, &help);
49
50         printf("\n%s\n", str_get(&help));
51         str_free(&help);
52 }
53
54 static void strip(char *str)
55 {
56         char *p = str;
57         int l;
58
59         while ((isspace(*p)))
60                 p++;
61         l = strlen(p);
62         if (p != str)
63                 memmove(str, p, l + 1);
64         if (!l)
65                 return;
66         p = str + l - 1;
67         while ((isspace(*p)))
68                 *p-- = 0;
69 }
70
71 static void check_stdin(void)
72 {
73         if (!valid_stdin) {
74                 printf(_("aborted!\n\n"));
75                 printf(_("Console input/output is redirected. "));
76                 printf(_("Run 'make oldconfig' to update configuration.\n\n"));
77                 exit(1);
78         }
79 }
80
81 static int conf_askvalue(struct symbol *sym, const char *def)
82 {
83         enum symbol_type type = sym_get_type(sym);
84
85         if (!sym_has_value(sym))
86                 printf(_("(NEW) "));
87
88         line[0] = '\n';
89         line[1] = 0;
90
91         if (!sym_is_changable(sym)) {
92                 printf("%s\n", def);
93                 line[0] = '\n';
94                 line[1] = 0;
95                 return 0;
96         }
97
98         switch (input_mode) {
99         case oldconfig:
100         case silentoldconfig:
101                 if (sym_has_value(sym)) {
102                         printf("%s\n", def);
103                         return 0;
104                 }
105                 check_stdin();
106                 /* fall through */
107         case oldaskconfig:
108                 fflush(stdout);
109                 xfgets(line, 128, stdin);
110                 return 1;
111         default:
112                 break;
113         }
114
115         switch (type) {
116         case S_INT:
117         case S_HEX:
118         case S_STRING:
119                 printf("%s\n", def);
120                 return 1;
121         default:
122                 ;
123         }
124         printf("%s", line);
125         return 1;
126 }
127
128 static int conf_string(struct menu *menu)
129 {
130         struct symbol *sym = menu->sym;
131         const char *def;
132
133         while (1) {
134                 printf("%*s%s ", indent - 1, "", _(menu->prompt->text));
135                 printf("(%s) ", sym->name);
136                 def = sym_get_string_value(sym);
137                 if (sym_get_string_value(sym))
138                         printf("[%s] ", def);
139                 if (!conf_askvalue(sym, def))
140                         return 0;
141                 switch (line[0]) {
142                 case '\n':
143                         break;
144                 case '?':
145                         /* print help */
146                         if (line[1] == '\n') {
147                                 print_help(menu);
148                                 def = NULL;
149                                 break;
150                         }
151                         /* fall through */
152                 default:
153                         line[strlen(line)-1] = 0;
154                         def = line;
155                 }
156                 if (def && sym_set_string_value(sym, def))
157                         return 0;
158         }
159 }
160
161 static int conf_sym(struct menu *menu)
162 {
163         struct symbol *sym = menu->sym;
164         tristate oldval, newval;
165
166         while (1) {
167                 printf("%*s%s ", indent - 1, "", _(menu->prompt->text));
168                 if (sym->name)
169                         printf("(%s) ", sym->name);
170                 putchar('[');
171                 oldval = sym_get_tristate_value(sym);
172                 switch (oldval) {
173                 case no:
174                         putchar('N');
175                         break;
176                 case mod:
177                         putchar('M');
178                         break;
179                 case yes:
180                         putchar('Y');
181                         break;
182                 }
183                 if (oldval != no && sym_tristate_within_range(sym, no))
184                         printf("/n");
185                 if (oldval != mod && sym_tristate_within_range(sym, mod))
186                         printf("/m");
187                 if (oldval != yes && sym_tristate_within_range(sym, yes))
188                         printf("/y");
189                 if (menu_has_help(menu))
190                         printf("/?");
191                 printf("] ");
192                 if (!conf_askvalue(sym, sym_get_string_value(sym)))
193                         return 0;
194                 strip(line);
195
196                 switch (line[0]) {
197                 case 'n':
198                 case 'N':
199                         newval = no;
200                         if (!line[1] || !strcmp(&line[1], "o"))
201                                 break;
202                         continue;
203                 case 'm':
204                 case 'M':
205                         newval = mod;
206                         if (!line[1])
207                                 break;
208                         continue;
209                 case 'y':
210                 case 'Y':
211                         newval = yes;
212                         if (!line[1] || !strcmp(&line[1], "es"))
213                                 break;
214                         continue;
215                 case 0:
216                         newval = oldval;
217                         break;
218                 case '?':
219                         goto help;
220                 default:
221                         continue;
222                 }
223                 if (sym_set_tristate_value(sym, newval))
224                         return 0;
225 help:
226                 print_help(menu);
227         }
228 }
229
230 static int conf_choice(struct menu *menu)
231 {
232         struct symbol *sym, *def_sym;
233         struct menu *child;
234         bool is_new;
235
236         sym = menu->sym;
237         is_new = !sym_has_value(sym);
238         if (sym_is_changable(sym)) {
239                 conf_sym(menu);
240                 sym_calc_value(sym);
241                 switch (sym_get_tristate_value(sym)) {
242                 case no:
243                         return 1;
244                 case mod:
245                         return 0;
246                 case yes:
247                         break;
248                 }
249         } else {
250                 switch (sym_get_tristate_value(sym)) {
251                 case no:
252                         return 1;
253                 case mod:
254                         printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu)));
255                         return 0;
256                 case yes:
257                         break;
258                 }
259         }
260
261         while (1) {
262                 int cnt, def;
263
264                 printf("%*s%s\n", indent - 1, "", _(menu_get_prompt(menu)));
265                 def_sym = sym_get_choice_value(sym);
266                 cnt = def = 0;
267                 line[0] = 0;
268                 for (child = menu->list; child; child = child->next) {
269                         if (!menu_is_visible(child))
270                                 continue;
271                         if (!child->sym) {
272                                 printf("%*c %s\n", indent, '*', _(menu_get_prompt(child)));
273                                 continue;
274                         }
275                         cnt++;
276                         if (child->sym == def_sym) {
277                                 def = cnt;
278                                 printf("%*c", indent, '>');
279                         } else
280                                 printf("%*c", indent, ' ');
281                         printf(" %d. %s", cnt, _(menu_get_prompt(child)));
282                         if (child->sym->name)
283                                 printf(" (%s)", child->sym->name);
284                         if (!sym_has_value(child->sym))
285                                 printf(_(" (NEW)"));
286                         printf("\n");
287                 }
288                 printf(_("%*schoice"), indent - 1, "");
289                 if (cnt == 1) {
290                         printf("[1]: 1\n");
291                         goto conf_childs;
292                 }
293                 printf("[1-%d", cnt);
294                 if (menu_has_help(menu))
295                         printf("?");
296                 printf("]: ");
297                 switch (input_mode) {
298                 case oldconfig:
299                 case silentoldconfig:
300                         if (!is_new) {
301                                 cnt = def;
302                                 printf("%d\n", cnt);
303                                 break;
304                         }
305                         check_stdin();
306                         /* fall through */
307                 case oldaskconfig:
308                         fflush(stdout);
309                         xfgets(line, 128, stdin);
310                         strip(line);
311                         if (line[0] == '?') {
312                                 print_help(menu);
313                                 continue;
314                         }
315                         if (!line[0])
316                                 cnt = def;
317                         else if (isdigit(line[0]))
318                                 cnt = atoi(line);
319                         else
320                                 continue;
321                         break;
322                 default:
323                         break;
324                 }
325
326         conf_childs:
327                 for (child = menu->list; child; child = child->next) {
328                         if (!child->sym || !menu_is_visible(child))
329                                 continue;
330                         if (!--cnt)
331                                 break;
332                 }
333                 if (!child)
334                         continue;
335                 if (line[0] && line[strlen(line) - 1] == '?') {
336                         print_help(child);
337                         continue;
338                 }
339                 sym_set_choice_value(sym, child->sym);
340                 for (child = child->list; child; child = child->next) {
341                         indent += 2;
342                         conf(child);
343                         indent -= 2;
344                 }
345                 return 1;
346         }
347 }
348
349 static void conf(struct menu *menu)
350 {
351         struct symbol *sym;
352         struct property *prop;
353         struct menu *child;
354
355         if (!menu_is_visible(menu))
356                 return;
357
358         sym = menu->sym;
359         prop = menu->prompt;
360         if (prop) {
361                 const char *prompt;
362
363                 switch (prop->type) {
364                 case P_MENU:
365                         if ((input_mode == silentoldconfig ||
366                              input_mode == listnewconfig ||
367                              input_mode == oldnoconfig) &&
368                             rootEntry != menu) {
369                                 check_conf(menu);
370                                 return;
371                         }
372                         /* fall through */
373                 case P_COMMENT:
374                         prompt = menu_get_prompt(menu);
375                         if (prompt)
376                                 printf("%*c\n%*c %s\n%*c\n",
377                                         indent, '*',
378                                         indent, '*', _(prompt),
379                                         indent, '*');
380                 default:
381                         ;
382                 }
383         }
384
385         if (!sym)
386                 goto conf_childs;
387
388         if (sym_is_choice(sym)) {
389                 conf_choice(menu);
390                 if (sym->curr.tri != mod)
391                         return;
392                 goto conf_childs;
393         }
394
395         switch (sym->type) {
396         case S_INT:
397         case S_HEX:
398         case S_STRING:
399                 conf_string(menu);
400                 break;
401         default:
402                 conf_sym(menu);
403                 break;
404         }
405
406 conf_childs:
407         if (sym)
408                 indent += 2;
409         for (child = menu->list; child; child = child->next)
410                 conf(child);
411         if (sym)
412                 indent -= 2;
413 }
414
415 static void check_conf(struct menu *menu)
416 {
417         struct symbol *sym;
418         struct menu *child;
419
420         if (!menu_is_visible(menu))
421                 return;
422
423         sym = menu->sym;
424         if (sym && !sym_has_value(sym)) {
425                 if (sym_is_changable(sym) ||
426                     (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)) {
427                         if (input_mode == listnewconfig) {
428                                 if (sym->name && !sym_is_choice_value(sym)) {
429                                         printf("%s%s\n", CONFIG_, sym->name);
430                                 }
431                         } else if (input_mode != oldnoconfig) {
432                                 if (!conf_cnt++)
433                                         printf(_("*\n* Restart config...\n*\n"));
434                                 rootEntry = menu_get_parent_menu(menu);
435                                 conf(rootEntry);
436                         }
437                 }
438         }
439
440         for (child = menu->list; child; child = child->next)
441                 check_conf(child);
442 }
443
444 static struct option long_opts[] = {
445         {"oldaskconfig",    no_argument,       NULL, oldaskconfig},
446         {"oldconfig",       no_argument,       NULL, oldconfig},
447         {"silentoldconfig", no_argument,       NULL, silentoldconfig},
448         {"defconfig",       optional_argument, NULL, defconfig},
449         {"savedefconfig",   required_argument, NULL, savedefconfig},
450         {"allnoconfig",     no_argument,       NULL, allnoconfig},
451         {"allyesconfig",    no_argument,       NULL, allyesconfig},
452         {"allmodconfig",    no_argument,       NULL, allmodconfig},
453         {"alldefconfig",    no_argument,       NULL, alldefconfig},
454         {"randconfig",      no_argument,       NULL, randconfig},
455         {"listnewconfig",   no_argument,       NULL, listnewconfig},
456         {"oldnoconfig",     no_argument,       NULL, oldnoconfig},
457         {NULL, 0, NULL, 0}
458 };
459
460 static void conf_usage(const char *progname)
461 {
462
463         printf("Usage: %s [option] <kconfig-file>\n", progname);
464         printf("[option] is _one_ of the following:\n");
465         printf("  --listnewconfig         List new options\n");
466         printf("  --oldaskconfig          Start a new configuration using a line-oriented program\n");
467         printf("  --oldconfig             Update a configuration using a provided .config as base\n");
468         printf("  --silentoldconfig       Same as oldconfig, but quietly, additionally update deps\n");
469         printf("  --oldnoconfig           Same as silentoldconfig but set new symbols to no\n");
470         printf("  --defconfig <file>      New config with default defined in <file>\n");
471         printf("  --savedefconfig <file>  Save the minimal current configuration to <file>\n");
472         printf("  --allnoconfig           New config where all options are answered with no\n");
473         printf("  --allyesconfig          New config where all options are answered with yes\n");
474         printf("  --allmodconfig          New config where all options are answered with mod\n");
475         printf("  --alldefconfig          New config with all symbols set to default\n");
476         printf("  --randconfig            New config with random answer to all options\n");
477 }
478
479 int main(int ac, char **av)
480 {
481         const char *progname = av[0];
482         int opt;
483         const char *name, *defconfig_file = NULL /* gcc uninit */;
484         struct stat tmpstat;
485
486         setlocale(LC_ALL, "");
487         bindtextdomain(PACKAGE, LOCALEDIR);
488         textdomain(PACKAGE);
489
490         while ((opt = getopt_long(ac, av, "", long_opts, NULL)) != -1) {
491                 input_mode = (enum input_mode)opt;
492                 switch (opt) {
493                 case silentoldconfig:
494                         sync_kconfig = 1;
495                         break;
496                 case defconfig:
497                 case savedefconfig:
498                         defconfig_file = optarg;
499                         break;
500                 case randconfig:
501                 {
502                         struct timeval now;
503                         unsigned int seed;
504
505                         /*
506                          * Use microseconds derived seed,
507                          * compensate for systems where it may be zero
508                          */
509                         gettimeofday(&now, NULL);
510
511                         seed = (unsigned int)((now.tv_sec + 1) * (now.tv_usec + 1));
512                         srand(seed);
513                         break;
514                 }
515                 case oldaskconfig:
516                 case oldconfig:
517                 case allnoconfig:
518                 case allyesconfig:
519                 case allmodconfig:
520                 case alldefconfig:
521                 case listnewconfig:
522                 case oldnoconfig:
523                         break;
524                 case '?':
525                         conf_usage(progname);
526                         exit(1);
527                         break;
528                 }
529         }
530         if (ac == optind) {
531                 printf(_("%s: Kconfig file missing\n"), av[0]);
532                 conf_usage(progname);
533                 exit(1);
534         }
535         name = av[optind];
536         conf_parse(name);
537         //zconfdump(stdout);
538         if (sync_kconfig) {
539                 name = conf_get_configname();
540                 if (stat(name, &tmpstat)) {
541                         fprintf(stderr, _("***\n"
542                                 "*** Configuration file \"%s\" not found!\n"
543                                 "***\n"
544                                 "*** Please run some configurator (e.g. \"make oldconfig\" or\n"
545                                 "*** \"make menuconfig\" or \"make xconfig\").\n"
546                                 "***\n"), name);
547                         exit(1);
548                 }
549         }
550
551         switch (input_mode) {
552         case defconfig:
553                 if (!defconfig_file)
554                         defconfig_file = conf_get_default_confname();
555                 if (conf_read(defconfig_file)) {
556                         printf(_("***\n"
557                                 "*** Can't find default configuration \"%s\"!\n"
558                                 "***\n"), defconfig_file);
559                         exit(1);
560                 }
561                 break;
562         case savedefconfig:
563         case silentoldconfig:
564         case oldaskconfig:
565         case oldconfig:
566         case listnewconfig:
567         case oldnoconfig:
568                 conf_read(NULL);
569                 break;
570         case allnoconfig:
571         case allyesconfig:
572         case allmodconfig:
573         case alldefconfig:
574         case randconfig:
575                 name = getenv("KCONFIG_ALLCONFIG");
576                 if (name && !stat(name, &tmpstat)) {
577                         conf_read_simple(name, S_DEF_USER);
578                         break;
579                 }
580                 switch (input_mode) {
581                 case allnoconfig:       name = "allno.config"; break;
582                 case allyesconfig:      name = "allyes.config"; break;
583                 case allmodconfig:      name = "allmod.config"; break;
584                 case alldefconfig:      name = "alldef.config"; break;
585                 case randconfig:        name = "allrandom.config"; break;
586                 default: break;
587                 }
588                 if (!stat(name, &tmpstat))
589                         conf_read_simple(name, S_DEF_USER);
590                 else if (!stat("all.config", &tmpstat))
591                         conf_read_simple("all.config", S_DEF_USER);
592                 break;
593         default:
594                 break;
595         }
596
597         if (sync_kconfig) {
598                 if (conf_get_changed()) {
599                         name = getenv("KCONFIG_NOSILENTUPDATE");
600                         if (name && *name) {
601                                 fprintf(stderr,
602                                         _("\n*** The configuration requires explicit update.\n\n"));
603                                 return 1;
604                         }
605                 }
606                 valid_stdin = isatty(0) && isatty(1) && isatty(2);
607         }
608
609         switch (input_mode) {
610         case allnoconfig:
611                 conf_set_all_new_symbols(def_no);
612                 break;
613         case allyesconfig:
614                 conf_set_all_new_symbols(def_yes);
615                 break;
616         case allmodconfig:
617                 conf_set_all_new_symbols(def_mod);
618                 break;
619         case alldefconfig:
620                 conf_set_all_new_symbols(def_default);
621                 break;
622         case randconfig:
623                 conf_set_all_new_symbols(def_random);
624                 break;
625         case defconfig:
626                 conf_set_all_new_symbols(def_default);
627                 break;
628         case savedefconfig:
629                 break;
630         case oldaskconfig:
631                 rootEntry = &rootmenu;
632                 conf(&rootmenu);
633                 input_mode = silentoldconfig;
634                 /* fall through */
635         case oldconfig:
636         case listnewconfig:
637         case oldnoconfig:
638         case silentoldconfig:
639                 /* Update until a loop caused no more changes */
640                 do {
641                         conf_cnt = 0;
642                         check_conf(&rootmenu);
643                 } while (conf_cnt &&
644                          (input_mode != listnewconfig &&
645                           input_mode != oldnoconfig));
646                 break;
647         }
648
649         if (sync_kconfig) {
650                 /* silentoldconfig is used during the build so we shall update autoconf.
651                  * All other commands are only used to generate a config.
652                  */
653                 if (conf_get_changed() && conf_write(NULL)) {
654                         fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n"));
655                         exit(1);
656                 }
657                 if (conf_write_autoconf()) {
658                         fprintf(stderr, _("\n*** Error during update of the configuration.\n\n"));
659                         return 1;
660                 }
661         } else if (input_mode == savedefconfig) {
662                 if (conf_write_defconfig(defconfig_file)) {
663                         fprintf(stderr, _("n*** Error while saving defconfig to: %s\n\n"),
664                                 defconfig_file);
665                         return 1;
666                 }
667         } else if (input_mode != listnewconfig) {
668                 if (conf_write(NULL)) {
669                         fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n"));
670                         exit(1);
671                 }
672         }
673         return 0;
674 }
675 /*
676  * Helper function to facilitate fgets() by Jean Sacren.
677  */
678 void xfgets(str, size, in)
679         char *str;
680         int size;
681         FILE *in;
682 {
683         if (fgets(str, size, in) == NULL)
684                 fprintf(stderr, "\nError in reading or end of file.\n");
685 }