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