kconfig/conf: reduce the scope of `defconfig_file'
[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 int main(int ac, char **av)
461 {
462         int opt;
463         const char *name, *defconfig_file = NULL /* gcc uninit */;
464         struct stat tmpstat;
465
466         setlocale(LC_ALL, "");
467         bindtextdomain(PACKAGE, LOCALEDIR);
468         textdomain(PACKAGE);
469
470         while ((opt = getopt_long(ac, av, "", long_opts, NULL)) != -1) {
471                 input_mode = (enum input_mode)opt;
472                 switch (opt) {
473                 case silentoldconfig:
474                         sync_kconfig = 1;
475                         break;
476                 case defconfig:
477                 case savedefconfig:
478                         defconfig_file = optarg;
479                         break;
480                 case randconfig:
481                 {
482                         struct timeval now;
483                         unsigned int seed;
484
485                         /*
486                          * Use microseconds derived seed,
487                          * compensate for systems where it may be zero
488                          */
489                         gettimeofday(&now, NULL);
490
491                         seed = (unsigned int)((now.tv_sec + 1) * (now.tv_usec + 1));
492                         srand(seed);
493                         break;
494                 }
495                 case '?':
496                         fprintf(stderr, _("See README for usage info\n"));
497                         exit(1);
498                         break;
499                 }
500         }
501         if (ac == optind) {
502                 printf(_("%s: Kconfig file missing\n"), av[0]);
503                 exit(1);
504         }
505         name = av[optind];
506         conf_parse(name);
507         //zconfdump(stdout);
508         if (sync_kconfig) {
509                 name = conf_get_configname();
510                 if (stat(name, &tmpstat)) {
511                         fprintf(stderr, _("***\n"
512                                 "*** Configuration file \"%s\" not found!\n"
513                                 "***\n"
514                                 "*** Please run some configurator (e.g. \"make oldconfig\" or\n"
515                                 "*** \"make menuconfig\" or \"make xconfig\").\n"
516                                 "***\n"), name);
517                         exit(1);
518                 }
519         }
520
521         switch (input_mode) {
522         case defconfig:
523                 if (!defconfig_file)
524                         defconfig_file = conf_get_default_confname();
525                 if (conf_read(defconfig_file)) {
526                         printf(_("***\n"
527                                 "*** Can't find default configuration \"%s\"!\n"
528                                 "***\n"), defconfig_file);
529                         exit(1);
530                 }
531                 break;
532         case savedefconfig:
533         case silentoldconfig:
534         case oldaskconfig:
535         case oldconfig:
536         case listnewconfig:
537         case oldnoconfig:
538                 conf_read(NULL);
539                 break;
540         case allnoconfig:
541         case allyesconfig:
542         case allmodconfig:
543         case alldefconfig:
544         case randconfig:
545                 name = getenv("KCONFIG_ALLCONFIG");
546                 if (name && !stat(name, &tmpstat)) {
547                         conf_read_simple(name, S_DEF_USER);
548                         break;
549                 }
550                 switch (input_mode) {
551                 case allnoconfig:       name = "allno.config"; break;
552                 case allyesconfig:      name = "allyes.config"; break;
553                 case allmodconfig:      name = "allmod.config"; break;
554                 case alldefconfig:      name = "alldef.config"; break;
555                 case randconfig:        name = "allrandom.config"; break;
556                 default: break;
557                 }
558                 if (!stat(name, &tmpstat))
559                         conf_read_simple(name, S_DEF_USER);
560                 else if (!stat("all.config", &tmpstat))
561                         conf_read_simple("all.config", S_DEF_USER);
562                 break;
563         default:
564                 break;
565         }
566
567         if (sync_kconfig) {
568                 if (conf_get_changed()) {
569                         name = getenv("KCONFIG_NOSILENTUPDATE");
570                         if (name && *name) {
571                                 fprintf(stderr,
572                                         _("\n*** The configuration requires explicit update.\n\n"));
573                                 return 1;
574                         }
575                 }
576                 valid_stdin = isatty(0) && isatty(1) && isatty(2);
577         }
578
579         switch (input_mode) {
580         case allnoconfig:
581                 conf_set_all_new_symbols(def_no);
582                 break;
583         case allyesconfig:
584                 conf_set_all_new_symbols(def_yes);
585                 break;
586         case allmodconfig:
587                 conf_set_all_new_symbols(def_mod);
588                 break;
589         case alldefconfig:
590                 conf_set_all_new_symbols(def_default);
591                 break;
592         case randconfig:
593                 conf_set_all_new_symbols(def_random);
594                 break;
595         case defconfig:
596                 conf_set_all_new_symbols(def_default);
597                 break;
598         case savedefconfig:
599                 break;
600         case oldaskconfig:
601                 rootEntry = &rootmenu;
602                 conf(&rootmenu);
603                 input_mode = silentoldconfig;
604                 /* fall through */
605         case oldconfig:
606         case listnewconfig:
607         case oldnoconfig:
608         case silentoldconfig:
609                 /* Update until a loop caused no more changes */
610                 do {
611                         conf_cnt = 0;
612                         check_conf(&rootmenu);
613                 } while (conf_cnt &&
614                          (input_mode != listnewconfig &&
615                           input_mode != oldnoconfig));
616                 break;
617         }
618
619         if (sync_kconfig) {
620                 /* silentoldconfig is used during the build so we shall update autoconf.
621                  * All other commands are only used to generate a config.
622                  */
623                 if (conf_get_changed() && conf_write(NULL)) {
624                         fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n"));
625                         exit(1);
626                 }
627                 if (conf_write_autoconf()) {
628                         fprintf(stderr, _("\n*** Error during update of the configuration.\n\n"));
629                         return 1;
630                 }
631         } else if (input_mode == savedefconfig) {
632                 if (conf_write_defconfig(defconfig_file)) {
633                         fprintf(stderr, _("n*** Error while saving defconfig to: %s\n\n"),
634                                 defconfig_file);
635                         return 1;
636                 }
637         } else if (input_mode != listnewconfig) {
638                 if (conf_write(NULL)) {
639                         fprintf(stderr, _("\n*** Error during writing of the configuration.\n\n"));
640                         exit(1);
641                 }
642         }
643         return 0;
644 }
645 /*
646  * Helper function to facilitate fgets() by Jean Sacren.
647  */
648 void xfgets(str, size, in)
649         char *str;
650         int size;
651         FILE *in;
652 {
653         if (fgets(str, size, in) == NULL)
654                 fprintf(stderr, "\nError in reading or end of file.\n");
655 }