xref: /openbmc/linux/scripts/kconfig/conf.c (revision 867e6d38) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
4  */
5 
6 #include <ctype.h>
7 #include <limits.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/time.h>
15 #include <errno.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 	syncconfig,
25 	oldconfig,
26 	allnoconfig,
27 	allyesconfig,
28 	allmodconfig,
29 	alldefconfig,
30 	randconfig,
31 	defconfig,
32 	savedefconfig,
33 	listnewconfig,
34 	helpnewconfig,
35 	olddefconfig,
36 	yes2modconfig,
37 	mod2yesconfig,
38 };
39 static enum input_mode input_mode = oldaskconfig;
40 static int input_mode_opt;
41 static int indent = 1;
42 static int tty_stdio;
43 static int sync_kconfig;
44 static int conf_cnt;
45 static char line[PATH_MAX];
46 static struct menu *rootEntry;
47 
48 static void print_help(struct menu *menu)
49 {
50 	struct gstr help = str_new();
51 
52 	menu_get_ext_help(menu, &help);
53 
54 	printf("\n%s\n", str_get(&help));
55 	str_free(&help);
56 }
57 
58 static void strip(char *str)
59 {
60 	char *p = str;
61 	int l;
62 
63 	while ((isspace(*p)))
64 		p++;
65 	l = strlen(p);
66 	if (p != str)
67 		memmove(str, p, l + 1);
68 	if (!l)
69 		return;
70 	p = str + l - 1;
71 	while ((isspace(*p)))
72 		*p-- = 0;
73 }
74 
75 /* Helper function to facilitate fgets() by Jean Sacren. */
76 static void xfgets(char *str, int size, FILE *in)
77 {
78 	if (!fgets(str, size, in))
79 		fprintf(stderr, "\nError in reading or end of file.\n");
80 
81 	if (!tty_stdio)
82 		printf("%s", str);
83 }
84 
85 static void set_randconfig_seed(void)
86 {
87 	unsigned int seed;
88 	char *env;
89 	bool seed_set = false;
90 
91 	env = getenv("KCONFIG_SEED");
92 	if (env && *env) {
93 		char *endp;
94 
95 		seed = strtol(env, &endp, 0);
96 		if (*endp == '\0')
97 			seed_set = true;
98 	}
99 
100 	if (!seed_set) {
101 		struct timeval now;
102 
103 		/*
104 		 * Use microseconds derived seed, compensate for systems where it may
105 		 * be zero.
106 		 */
107 		gettimeofday(&now, NULL);
108 		seed = (now.tv_sec + 1) * (now.tv_usec + 1);
109 	}
110 
111 	printf("KCONFIG_SEED=0x%X\n", seed);
112 	srand(seed);
113 }
114 
115 static bool randomize_choice_values(struct symbol *csym)
116 {
117 	struct property *prop;
118 	struct symbol *sym;
119 	struct expr *e;
120 	int cnt, def;
121 
122 	/*
123 	 * If choice is mod then we may have more items selected
124 	 * and if no then no-one.
125 	 * In both cases stop.
126 	 */
127 	if (csym->curr.tri != yes)
128 		return false;
129 
130 	prop = sym_get_choice_prop(csym);
131 
132 	/* count entries in choice block */
133 	cnt = 0;
134 	expr_list_for_each_sym(prop->expr, e, sym)
135 		cnt++;
136 
137 	/*
138 	 * find a random value and set it to yes,
139 	 * set the rest to no so we have only one set
140 	 */
141 	def = rand() % cnt;
142 
143 	cnt = 0;
144 	expr_list_for_each_sym(prop->expr, e, sym) {
145 		if (def == cnt++) {
146 			sym->def[S_DEF_USER].tri = yes;
147 			csym->def[S_DEF_USER].val = sym;
148 		} else {
149 			sym->def[S_DEF_USER].tri = no;
150 		}
151 		sym->flags |= SYMBOL_DEF_USER;
152 		/* clear VALID to get value calculated */
153 		sym->flags &= ~SYMBOL_VALID;
154 	}
155 	csym->flags |= SYMBOL_DEF_USER;
156 	/* clear VALID to get value calculated */
157 	csym->flags &= ~SYMBOL_VALID;
158 
159 	return true;
160 }
161 
162 enum conf_def_mode {
163 	def_default,
164 	def_yes,
165 	def_mod,
166 	def_y2m,
167 	def_m2y,
168 	def_no,
169 	def_random
170 };
171 
172 static bool conf_set_all_new_symbols(enum conf_def_mode mode)
173 {
174 	struct symbol *sym, *csym;
175 	int i, cnt;
176 	/*
177 	 * can't go as the default in switch-case below, otherwise gcc whines
178 	 * about -Wmaybe-uninitialized
179 	 */
180 	int pby = 50; /* probability of bool     = y */
181 	int pty = 33; /* probability of tristate = y */
182 	int ptm = 33; /* probability of tristate = m */
183 	bool has_changed = false;
184 
185 	if (mode == def_random) {
186 		int n, p[3];
187 		char *env = getenv("KCONFIG_PROBABILITY");
188 
189 		n = 0;
190 		while (env && *env) {
191 			char *endp;
192 			int tmp = strtol(env, &endp, 10);
193 
194 			if (tmp >= 0 && tmp <= 100) {
195 				p[n++] = tmp;
196 			} else {
197 				errno = ERANGE;
198 				perror("KCONFIG_PROBABILITY");
199 				exit(1);
200 			}
201 			env = (*endp == ':') ? endp + 1 : endp;
202 			if (n >= 3)
203 				break;
204 		}
205 		switch (n) {
206 		case 1:
207 			pby = p[0];
208 			ptm = pby / 2;
209 			pty = pby - ptm;
210 			break;
211 		case 2:
212 			pty = p[0];
213 			ptm = p[1];
214 			pby = pty + ptm;
215 			break;
216 		case 3:
217 			pby = p[0];
218 			pty = p[1];
219 			ptm = p[2];
220 			break;
221 		}
222 
223 		if (pty + ptm > 100) {
224 			errno = ERANGE;
225 			perror("KCONFIG_PROBABILITY");
226 			exit(1);
227 		}
228 	}
229 
230 	for_all_symbols(i, sym) {
231 		if (sym_has_value(sym) || sym->flags & SYMBOL_VALID)
232 			continue;
233 		switch (sym_get_type(sym)) {
234 		case S_BOOLEAN:
235 		case S_TRISTATE:
236 			has_changed = true;
237 			switch (mode) {
238 			case def_yes:
239 				sym->def[S_DEF_USER].tri = yes;
240 				break;
241 			case def_mod:
242 				sym->def[S_DEF_USER].tri = mod;
243 				break;
244 			case def_no:
245 				sym->def[S_DEF_USER].tri = no;
246 				break;
247 			case def_random:
248 				sym->def[S_DEF_USER].tri = no;
249 				cnt = rand() % 100;
250 				if (sym->type == S_TRISTATE) {
251 					if (cnt < pty)
252 						sym->def[S_DEF_USER].tri = yes;
253 					else if (cnt < pty + ptm)
254 						sym->def[S_DEF_USER].tri = mod;
255 				} else if (cnt < pby)
256 					sym->def[S_DEF_USER].tri = yes;
257 				break;
258 			default:
259 				continue;
260 			}
261 			if (!(sym_is_choice(sym) && mode == def_random))
262 				sym->flags |= SYMBOL_DEF_USER;
263 			break;
264 		default:
265 			break;
266 		}
267 
268 	}
269 
270 	sym_clear_all_valid();
271 
272 	/*
273 	 * We have different type of choice blocks.
274 	 * If curr.tri equals to mod then we can select several
275 	 * choice symbols in one block.
276 	 * In this case we do nothing.
277 	 * If curr.tri equals yes then only one symbol can be
278 	 * selected in a choice block and we set it to yes,
279 	 * and the rest to no.
280 	 */
281 	if (mode != def_random) {
282 		for_all_symbols(i, csym) {
283 			if ((sym_is_choice(csym) && !sym_has_value(csym)) ||
284 			    sym_is_choice_value(csym))
285 				csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES;
286 		}
287 	}
288 
289 	for_all_symbols(i, csym) {
290 		if (sym_has_value(csym) || !sym_is_choice(csym))
291 			continue;
292 
293 		sym_calc_value(csym);
294 		if (mode == def_random)
295 			has_changed |= randomize_choice_values(csym);
296 		else {
297 			set_all_choice_values(csym);
298 			has_changed = true;
299 		}
300 	}
301 
302 	return has_changed;
303 }
304 
305 static void conf_rewrite_mod_or_yes(enum conf_def_mode mode)
306 {
307 	struct symbol *sym;
308 	int i;
309 	tristate old_val = (mode == def_y2m) ? yes : mod;
310 	tristate new_val = (mode == def_y2m) ? mod : yes;
311 
312 	for_all_symbols(i, sym) {
313 		if (sym_get_type(sym) == S_TRISTATE &&
314 		    sym->def[S_DEF_USER].tri == old_val)
315 			sym->def[S_DEF_USER].tri = new_val;
316 	}
317 	sym_clear_all_valid();
318 }
319 
320 static int conf_askvalue(struct symbol *sym, const char *def)
321 {
322 	if (!sym_has_value(sym))
323 		printf("(NEW) ");
324 
325 	line[0] = '\n';
326 	line[1] = 0;
327 
328 	if (!sym_is_changeable(sym)) {
329 		printf("%s\n", def);
330 		line[0] = '\n';
331 		line[1] = 0;
332 		return 0;
333 	}
334 
335 	switch (input_mode) {
336 	case oldconfig:
337 	case syncconfig:
338 		if (sym_has_value(sym)) {
339 			printf("%s\n", def);
340 			return 0;
341 		}
342 		/* fall through */
343 	default:
344 		fflush(stdout);
345 		xfgets(line, sizeof(line), stdin);
346 		break;
347 	}
348 
349 	return 1;
350 }
351 
352 static int conf_string(struct menu *menu)
353 {
354 	struct symbol *sym = menu->sym;
355 	const char *def;
356 
357 	while (1) {
358 		printf("%*s%s ", indent - 1, "", menu->prompt->text);
359 		printf("(%s) ", sym->name);
360 		def = sym_get_string_value(sym);
361 		if (def)
362 			printf("[%s] ", def);
363 		if (!conf_askvalue(sym, def))
364 			return 0;
365 		switch (line[0]) {
366 		case '\n':
367 			break;
368 		case '?':
369 			/* print help */
370 			if (line[1] == '\n') {
371 				print_help(menu);
372 				def = NULL;
373 				break;
374 			}
375 			/* fall through */
376 		default:
377 			line[strlen(line)-1] = 0;
378 			def = line;
379 		}
380 		if (def && sym_set_string_value(sym, def))
381 			return 0;
382 	}
383 }
384 
385 static int conf_sym(struct menu *menu)
386 {
387 	struct symbol *sym = menu->sym;
388 	tristate oldval, newval;
389 
390 	while (1) {
391 		printf("%*s%s ", indent - 1, "", menu->prompt->text);
392 		if (sym->name)
393 			printf("(%s) ", sym->name);
394 		putchar('[');
395 		oldval = sym_get_tristate_value(sym);
396 		switch (oldval) {
397 		case no:
398 			putchar('N');
399 			break;
400 		case mod:
401 			putchar('M');
402 			break;
403 		case yes:
404 			putchar('Y');
405 			break;
406 		}
407 		if (oldval != no && sym_tristate_within_range(sym, no))
408 			printf("/n");
409 		if (oldval != mod && sym_tristate_within_range(sym, mod))
410 			printf("/m");
411 		if (oldval != yes && sym_tristate_within_range(sym, yes))
412 			printf("/y");
413 		printf("/?] ");
414 		if (!conf_askvalue(sym, sym_get_string_value(sym)))
415 			return 0;
416 		strip(line);
417 
418 		switch (line[0]) {
419 		case 'n':
420 		case 'N':
421 			newval = no;
422 			if (!line[1] || !strcmp(&line[1], "o"))
423 				break;
424 			continue;
425 		case 'm':
426 		case 'M':
427 			newval = mod;
428 			if (!line[1])
429 				break;
430 			continue;
431 		case 'y':
432 		case 'Y':
433 			newval = yes;
434 			if (!line[1] || !strcmp(&line[1], "es"))
435 				break;
436 			continue;
437 		case 0:
438 			newval = oldval;
439 			break;
440 		case '?':
441 			goto help;
442 		default:
443 			continue;
444 		}
445 		if (sym_set_tristate_value(sym, newval))
446 			return 0;
447 help:
448 		print_help(menu);
449 	}
450 }
451 
452 static int conf_choice(struct menu *menu)
453 {
454 	struct symbol *sym, *def_sym;
455 	struct menu *child;
456 	bool is_new;
457 
458 	sym = menu->sym;
459 	is_new = !sym_has_value(sym);
460 	if (sym_is_changeable(sym)) {
461 		conf_sym(menu);
462 		sym_calc_value(sym);
463 		switch (sym_get_tristate_value(sym)) {
464 		case no:
465 			return 1;
466 		case mod:
467 			return 0;
468 		case yes:
469 			break;
470 		}
471 	} else {
472 		switch (sym_get_tristate_value(sym)) {
473 		case no:
474 			return 1;
475 		case mod:
476 			printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
477 			return 0;
478 		case yes:
479 			break;
480 		}
481 	}
482 
483 	while (1) {
484 		int cnt, def;
485 
486 		printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
487 		def_sym = sym_get_choice_value(sym);
488 		cnt = def = 0;
489 		line[0] = 0;
490 		for (child = menu->list; child; child = child->next) {
491 			if (!menu_is_visible(child))
492 				continue;
493 			if (!child->sym) {
494 				printf("%*c %s\n", indent, '*', menu_get_prompt(child));
495 				continue;
496 			}
497 			cnt++;
498 			if (child->sym == def_sym) {
499 				def = cnt;
500 				printf("%*c", indent, '>');
501 			} else
502 				printf("%*c", indent, ' ');
503 			printf(" %d. %s", cnt, menu_get_prompt(child));
504 			if (child->sym->name)
505 				printf(" (%s)", child->sym->name);
506 			if (!sym_has_value(child->sym))
507 				printf(" (NEW)");
508 			printf("\n");
509 		}
510 		printf("%*schoice", indent - 1, "");
511 		if (cnt == 1) {
512 			printf("[1]: 1\n");
513 			goto conf_childs;
514 		}
515 		printf("[1-%d?]: ", cnt);
516 		switch (input_mode) {
517 		case oldconfig:
518 		case syncconfig:
519 			if (!is_new) {
520 				cnt = def;
521 				printf("%d\n", cnt);
522 				break;
523 			}
524 			/* fall through */
525 		case oldaskconfig:
526 			fflush(stdout);
527 			xfgets(line, sizeof(line), stdin);
528 			strip(line);
529 			if (line[0] == '?') {
530 				print_help(menu);
531 				continue;
532 			}
533 			if (!line[0])
534 				cnt = def;
535 			else if (isdigit(line[0]))
536 				cnt = atoi(line);
537 			else
538 				continue;
539 			break;
540 		default:
541 			break;
542 		}
543 
544 	conf_childs:
545 		for (child = menu->list; child; child = child->next) {
546 			if (!child->sym || !menu_is_visible(child))
547 				continue;
548 			if (!--cnt)
549 				break;
550 		}
551 		if (!child)
552 			continue;
553 		if (line[0] && line[strlen(line) - 1] == '?') {
554 			print_help(child);
555 			continue;
556 		}
557 		sym_set_choice_value(sym, child->sym);
558 		for (child = child->list; child; child = child->next) {
559 			indent += 2;
560 			conf(child);
561 			indent -= 2;
562 		}
563 		return 1;
564 	}
565 }
566 
567 static void conf(struct menu *menu)
568 {
569 	struct symbol *sym;
570 	struct property *prop;
571 	struct menu *child;
572 
573 	if (!menu_is_visible(menu))
574 		return;
575 
576 	sym = menu->sym;
577 	prop = menu->prompt;
578 	if (prop) {
579 		const char *prompt;
580 
581 		switch (prop->type) {
582 		case P_MENU:
583 			/*
584 			 * Except in oldaskconfig mode, we show only menus that
585 			 * contain new symbols.
586 			 */
587 			if (input_mode != oldaskconfig && rootEntry != menu) {
588 				check_conf(menu);
589 				return;
590 			}
591 			/* fall through */
592 		case P_COMMENT:
593 			prompt = menu_get_prompt(menu);
594 			if (prompt)
595 				printf("%*c\n%*c %s\n%*c\n",
596 					indent, '*',
597 					indent, '*', prompt,
598 					indent, '*');
599 		default:
600 			;
601 		}
602 	}
603 
604 	if (!sym)
605 		goto conf_childs;
606 
607 	if (sym_is_choice(sym)) {
608 		conf_choice(menu);
609 		if (sym->curr.tri != mod)
610 			return;
611 		goto conf_childs;
612 	}
613 
614 	switch (sym->type) {
615 	case S_INT:
616 	case S_HEX:
617 	case S_STRING:
618 		conf_string(menu);
619 		break;
620 	default:
621 		conf_sym(menu);
622 		break;
623 	}
624 
625 conf_childs:
626 	if (sym)
627 		indent += 2;
628 	for (child = menu->list; child; child = child->next)
629 		conf(child);
630 	if (sym)
631 		indent -= 2;
632 }
633 
634 static void check_conf(struct menu *menu)
635 {
636 	struct symbol *sym;
637 	struct menu *child;
638 
639 	if (!menu_is_visible(menu))
640 		return;
641 
642 	sym = menu->sym;
643 	if (sym && !sym_has_value(sym) &&
644 	    (sym_is_changeable(sym) ||
645 	     (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes))) {
646 
647 		switch (input_mode) {
648 		case listnewconfig:
649 			if (sym->name) {
650 				const char *str;
651 
652 				if (sym->type == S_STRING) {
653 					str = sym_get_string_value(sym);
654 					str = sym_escape_string_value(str);
655 					printf("%s%s=%s\n", CONFIG_, sym->name, str);
656 					free((void *)str);
657 				} else {
658 					str = sym_get_string_value(sym);
659 					printf("%s%s=%s\n", CONFIG_, sym->name, str);
660 				}
661 			}
662 			break;
663 		case helpnewconfig:
664 			printf("-----\n");
665 			print_help(menu);
666 			printf("-----\n");
667 			break;
668 		default:
669 			if (!conf_cnt++)
670 				printf("*\n* Restart config...\n*\n");
671 			rootEntry = menu_get_parent_menu(menu);
672 			conf(rootEntry);
673 			break;
674 		}
675 	}
676 
677 	for (child = menu->list; child; child = child->next)
678 		check_conf(child);
679 }
680 
681 static struct option long_opts[] = {
682 	{"help",          no_argument,       NULL,            'h'},
683 	{"silent",        no_argument,       NULL,            's'},
684 	{"oldaskconfig",  no_argument,       &input_mode_opt, oldaskconfig},
685 	{"oldconfig",     no_argument,       &input_mode_opt, oldconfig},
686 	{"syncconfig",    no_argument,       &input_mode_opt, syncconfig},
687 	{"defconfig",     required_argument, &input_mode_opt, defconfig},
688 	{"savedefconfig", required_argument, &input_mode_opt, savedefconfig},
689 	{"allnoconfig",   no_argument,       &input_mode_opt, allnoconfig},
690 	{"allyesconfig",  no_argument,       &input_mode_opt, allyesconfig},
691 	{"allmodconfig",  no_argument,       &input_mode_opt, allmodconfig},
692 	{"alldefconfig",  no_argument,       &input_mode_opt, alldefconfig},
693 	{"randconfig",    no_argument,       &input_mode_opt, randconfig},
694 	{"listnewconfig", no_argument,       &input_mode_opt, listnewconfig},
695 	{"helpnewconfig", no_argument,       &input_mode_opt, helpnewconfig},
696 	{"olddefconfig",  no_argument,       &input_mode_opt, olddefconfig},
697 	{"yes2modconfig", no_argument,       &input_mode_opt, yes2modconfig},
698 	{"mod2yesconfig", no_argument,       &input_mode_opt, mod2yesconfig},
699 	{NULL, 0, NULL, 0}
700 };
701 
702 static void conf_usage(const char *progname)
703 {
704 	printf("Usage: %s [options] <kconfig-file>\n", progname);
705 	printf("\n");
706 	printf("Generic options:\n");
707 	printf("  -h, --help              Print this message and exit.\n");
708 	printf("  -s, --silent            Do not print log.\n");
709 	printf("\n");
710 	printf("Mode options:\n");
711 	printf("  --listnewconfig         List new options\n");
712 	printf("  --helpnewconfig         List new options and help text\n");
713 	printf("  --oldaskconfig          Start a new configuration using a line-oriented program\n");
714 	printf("  --oldconfig             Update a configuration using a provided .config as base\n");
715 	printf("  --syncconfig            Similar to oldconfig but generates configuration in\n"
716 	       "                          include/{generated/,config/}\n");
717 	printf("  --olddefconfig          Same as oldconfig but sets new symbols to their default value\n");
718 	printf("  --defconfig <file>      New config with default defined in <file>\n");
719 	printf("  --savedefconfig <file>  Save the minimal current configuration to <file>\n");
720 	printf("  --allnoconfig           New config where all options are answered with no\n");
721 	printf("  --allyesconfig          New config where all options are answered with yes\n");
722 	printf("  --allmodconfig          New config where all options are answered with mod\n");
723 	printf("  --alldefconfig          New config with all symbols set to default\n");
724 	printf("  --randconfig            New config with random answer to all options\n");
725 	printf("  --yes2modconfig         Change answers from yes to mod if possible\n");
726 	printf("  --mod2yesconfig         Change answers from mod to yes if possible\n");
727 	printf("  (If none of the above is given, --oldaskconfig is the default)\n");
728 }
729 
730 int main(int ac, char **av)
731 {
732 	const char *progname = av[0];
733 	int opt;
734 	const char *name, *defconfig_file = NULL /* gcc uninit */;
735 	int no_conf_write = 0;
736 
737 	tty_stdio = isatty(0) && isatty(1);
738 
739 	while ((opt = getopt_long(ac, av, "hs", long_opts, NULL)) != -1) {
740 		switch (opt) {
741 		case 'h':
742 			conf_usage(progname);
743 			exit(1);
744 			break;
745 		case 's':
746 			conf_set_message_callback(NULL);
747 			break;
748 		case 0:
749 			input_mode = input_mode_opt;
750 			switch (input_mode) {
751 			case syncconfig:
752 				/*
753 				 * syncconfig is invoked during the build stage.
754 				 * Suppress distracting
755 				 *   "configuration written to ..."
756 				 */
757 				conf_set_message_callback(NULL);
758 				sync_kconfig = 1;
759 				break;
760 			case defconfig:
761 			case savedefconfig:
762 				defconfig_file = optarg;
763 				break;
764 			case randconfig:
765 				set_randconfig_seed();
766 				break;
767 			default:
768 				break;
769 			}
770 		default:
771 			break;
772 		}
773 	}
774 	if (ac == optind) {
775 		fprintf(stderr, "%s: Kconfig file missing\n", av[0]);
776 		conf_usage(progname);
777 		exit(1);
778 	}
779 	conf_parse(av[optind]);
780 	//zconfdump(stdout);
781 
782 	switch (input_mode) {
783 	case defconfig:
784 		if (conf_read(defconfig_file)) {
785 			fprintf(stderr,
786 				"***\n"
787 				  "*** Can't find default configuration \"%s\"!\n"
788 				  "***\n",
789 				defconfig_file);
790 			exit(1);
791 		}
792 		break;
793 	case savedefconfig:
794 	case syncconfig:
795 	case oldaskconfig:
796 	case oldconfig:
797 	case listnewconfig:
798 	case helpnewconfig:
799 	case olddefconfig:
800 	case yes2modconfig:
801 	case mod2yesconfig:
802 		conf_read(NULL);
803 		break;
804 	case allnoconfig:
805 	case allyesconfig:
806 	case allmodconfig:
807 	case alldefconfig:
808 	case randconfig:
809 		name = getenv("KCONFIG_ALLCONFIG");
810 		if (!name)
811 			break;
812 		if ((strcmp(name, "") != 0) && (strcmp(name, "1") != 0)) {
813 			if (conf_read_simple(name, S_DEF_USER)) {
814 				fprintf(stderr,
815 					"*** Can't read seed configuration \"%s\"!\n",
816 					name);
817 				exit(1);
818 			}
819 			break;
820 		}
821 		switch (input_mode) {
822 		case allnoconfig:	name = "allno.config"; break;
823 		case allyesconfig:	name = "allyes.config"; break;
824 		case allmodconfig:	name = "allmod.config"; break;
825 		case alldefconfig:	name = "alldef.config"; break;
826 		case randconfig:	name = "allrandom.config"; break;
827 		default: break;
828 		}
829 		if (conf_read_simple(name, S_DEF_USER) &&
830 		    conf_read_simple("all.config", S_DEF_USER)) {
831 			fprintf(stderr,
832 				"*** KCONFIG_ALLCONFIG set, but no \"%s\" or \"all.config\" file found\n",
833 				name);
834 			exit(1);
835 		}
836 		break;
837 	default:
838 		break;
839 	}
840 
841 	if (sync_kconfig) {
842 		name = getenv("KCONFIG_NOSILENTUPDATE");
843 		if (name && *name) {
844 			if (conf_get_changed()) {
845 				fprintf(stderr,
846 					"\n*** The configuration requires explicit update.\n\n");
847 				return 1;
848 			}
849 			no_conf_write = 1;
850 		}
851 	}
852 
853 	switch (input_mode) {
854 	case allnoconfig:
855 		conf_set_all_new_symbols(def_no);
856 		break;
857 	case allyesconfig:
858 		conf_set_all_new_symbols(def_yes);
859 		break;
860 	case allmodconfig:
861 		conf_set_all_new_symbols(def_mod);
862 		break;
863 	case alldefconfig:
864 		conf_set_all_new_symbols(def_default);
865 		break;
866 	case randconfig:
867 		/* Really nothing to do in this loop */
868 		while (conf_set_all_new_symbols(def_random)) ;
869 		break;
870 	case defconfig:
871 		conf_set_all_new_symbols(def_default);
872 		break;
873 	case savedefconfig:
874 		break;
875 	case yes2modconfig:
876 		conf_rewrite_mod_or_yes(def_y2m);
877 		break;
878 	case mod2yesconfig:
879 		conf_rewrite_mod_or_yes(def_m2y);
880 		break;
881 	case oldaskconfig:
882 		rootEntry = &rootmenu;
883 		conf(&rootmenu);
884 		input_mode = oldconfig;
885 		/* fall through */
886 	case oldconfig:
887 	case listnewconfig:
888 	case helpnewconfig:
889 	case syncconfig:
890 		/* Update until a loop caused no more changes */
891 		do {
892 			conf_cnt = 0;
893 			check_conf(&rootmenu);
894 		} while (conf_cnt);
895 		break;
896 	case olddefconfig:
897 	default:
898 		break;
899 	}
900 
901 	if (input_mode == savedefconfig) {
902 		if (conf_write_defconfig(defconfig_file)) {
903 			fprintf(stderr, "n*** Error while saving defconfig to: %s\n\n",
904 				defconfig_file);
905 			return 1;
906 		}
907 	} else if (input_mode != listnewconfig && input_mode != helpnewconfig) {
908 		if (!no_conf_write && conf_write(NULL)) {
909 			fprintf(stderr, "\n*** Error during writing of the configuration.\n\n");
910 			exit(1);
911 		}
912 
913 		/*
914 		 * Create auto.conf if it does not exist.
915 		 * This prevents GNU Make 4.1 or older from emitting
916 		 * "include/config/auto.conf: No such file or directory"
917 		 * in the top-level Makefile
918 		 *
919 		 * syncconfig always creates or updates auto.conf because it is
920 		 * used during the build.
921 		 */
922 		if (conf_write_autoconf(sync_kconfig) && sync_kconfig) {
923 			fprintf(stderr,
924 				"\n*** Error during sync of the configuration.\n\n");
925 			return 1;
926 		}
927 	}
928 	return 0;
929 }
930