xref: /openbmc/linux/scripts/kconfig/confdata.c (revision 565d76cb) 
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 <sys/stat.h>
7 #include <ctype.h>
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <time.h>
14 #include <unistd.h>
15 
16 #define LKC_DIRECT_LINK
17 #include "lkc.h"
18 
19 static void conf_warning(const char *fmt, ...)
20 	__attribute__ ((format (printf, 1, 2)));
21 
22 static void conf_message(const char *fmt, ...)
23 	__attribute__ ((format (printf, 1, 2)));
24 
25 static const char *conf_filename;
26 static int conf_lineno, conf_warnings, conf_unsaved;
27 
28 const char conf_defname[] = "arch/$ARCH/defconfig";
29 
30 static void conf_warning(const char *fmt, ...)
31 {
32 	va_list ap;
33 	va_start(ap, fmt);
34 	fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
35 	vfprintf(stderr, fmt, ap);
36 	fprintf(stderr, "\n");
37 	va_end(ap);
38 	conf_warnings++;
39 }
40 
41 static void conf_default_message_callback(const char *fmt, va_list ap)
42 {
43 	printf("#\n# ");
44 	vprintf(fmt, ap);
45 	printf("\n#\n");
46 }
47 
48 static void (*conf_message_callback) (const char *fmt, va_list ap) =
49 	conf_default_message_callback;
50 void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))
51 {
52 	conf_message_callback = fn;
53 }
54 
55 static void conf_message(const char *fmt, ...)
56 {
57 	va_list ap;
58 
59 	va_start(ap, fmt);
60 	if (conf_message_callback)
61 		conf_message_callback(fmt, ap);
62 }
63 
64 const char *conf_get_configname(void)
65 {
66 	char *name = getenv("KCONFIG_CONFIG");
67 
68 	return name ? name : ".config";
69 }
70 
71 const char *conf_get_autoconfig_name(void)
72 {
73 	char *name = getenv("KCONFIG_AUTOCONFIG");
74 
75 	return name ? name : "include/config/auto.conf";
76 }
77 
78 static char *conf_expand_value(const char *in)
79 {
80 	struct symbol *sym;
81 	const char *src;
82 	static char res_value[SYMBOL_MAXLENGTH];
83 	char *dst, name[SYMBOL_MAXLENGTH];
84 
85 	res_value[0] = 0;
86 	dst = name;
87 	while ((src = strchr(in, '$'))) {
88 		strncat(res_value, in, src - in);
89 		src++;
90 		dst = name;
91 		while (isalnum(*src) || *src == '_')
92 			*dst++ = *src++;
93 		*dst = 0;
94 		sym = sym_lookup(name, 0);
95 		sym_calc_value(sym);
96 		strcat(res_value, sym_get_string_value(sym));
97 		in = src;
98 	}
99 	strcat(res_value, in);
100 
101 	return res_value;
102 }
103 
104 char *conf_get_default_confname(void)
105 {
106 	struct stat buf;
107 	static char fullname[PATH_MAX+1];
108 	char *env, *name;
109 
110 	name = conf_expand_value(conf_defname);
111 	env = getenv(SRCTREE);
112 	if (env) {
113 		sprintf(fullname, "%s/%s", env, name);
114 		if (!stat(fullname, &buf))
115 			return fullname;
116 	}
117 	return name;
118 }
119 
120 static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
121 {
122 	char *p2;
123 
124 	switch (sym->type) {
125 	case S_TRISTATE:
126 		if (p[0] == 'm') {
127 			sym->def[def].tri = mod;
128 			sym->flags |= def_flags;
129 			break;
130 		}
131 	case S_BOOLEAN:
132 		if (p[0] == 'y') {
133 			sym->def[def].tri = yes;
134 			sym->flags |= def_flags;
135 			break;
136 		}
137 		if (p[0] == 'n') {
138 			sym->def[def].tri = no;
139 			sym->flags |= def_flags;
140 			break;
141 		}
142 		conf_warning("symbol value '%s' invalid for %s", p, sym->name);
143 		break;
144 	case S_OTHER:
145 		if (*p != '"') {
146 			for (p2 = p; *p2 && !isspace(*p2); p2++)
147 				;
148 			sym->type = S_STRING;
149 			goto done;
150 		}
151 	case S_STRING:
152 		if (*p++ != '"')
153 			break;
154 		for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
155 			if (*p2 == '"') {
156 				*p2 = 0;
157 				break;
158 			}
159 			memmove(p2, p2 + 1, strlen(p2));
160 		}
161 		if (!p2) {
162 			conf_warning("invalid string found");
163 			return 1;
164 		}
165 	case S_INT:
166 	case S_HEX:
167 	done:
168 		if (sym_string_valid(sym, p)) {
169 			sym->def[def].val = strdup(p);
170 			sym->flags |= def_flags;
171 		} else {
172 			conf_warning("symbol value '%s' invalid for %s", p, sym->name);
173 			return 1;
174 		}
175 		break;
176 	default:
177 		;
178 	}
179 	return 0;
180 }
181 
182 int conf_read_simple(const char *name, int def)
183 {
184 	FILE *in = NULL;
185 	char line[1024];
186 	char *p, *p2;
187 	struct symbol *sym;
188 	int i, def_flags;
189 
190 	if (name) {
191 		in = zconf_fopen(name);
192 	} else {
193 		struct property *prop;
194 
195 		name = conf_get_configname();
196 		in = zconf_fopen(name);
197 		if (in)
198 			goto load;
199 		sym_add_change_count(1);
200 		if (!sym_defconfig_list) {
201 			if (modules_sym)
202 				sym_calc_value(modules_sym);
203 			return 1;
204 		}
205 
206 		for_all_defaults(sym_defconfig_list, prop) {
207 			if (expr_calc_value(prop->visible.expr) == no ||
208 			    prop->expr->type != E_SYMBOL)
209 				continue;
210 			name = conf_expand_value(prop->expr->left.sym->name);
211 			in = zconf_fopen(name);
212 			if (in) {
213 				conf_message(_("using defaults found in %s"),
214 					 name);
215 				goto load;
216 			}
217 		}
218 	}
219 	if (!in)
220 		return 1;
221 
222 load:
223 	conf_filename = name;
224 	conf_lineno = 0;
225 	conf_warnings = 0;
226 	conf_unsaved = 0;
227 
228 	def_flags = SYMBOL_DEF << def;
229 	for_all_symbols(i, sym) {
230 		sym->flags |= SYMBOL_CHANGED;
231 		sym->flags &= ~(def_flags|SYMBOL_VALID);
232 		if (sym_is_choice(sym))
233 			sym->flags |= def_flags;
234 		switch (sym->type) {
235 		case S_INT:
236 		case S_HEX:
237 		case S_STRING:
238 			if (sym->def[def].val)
239 				free(sym->def[def].val);
240 		default:
241 			sym->def[def].val = NULL;
242 			sym->def[def].tri = no;
243 		}
244 	}
245 
246 	while (fgets(line, sizeof(line), in)) {
247 		conf_lineno++;
248 		sym = NULL;
249 		if (line[0] == '#') {
250 			if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
251 				continue;
252 			p = strchr(line + 2 + strlen(CONFIG_), ' ');
253 			if (!p)
254 				continue;
255 			*p++ = 0;
256 			if (strncmp(p, "is not set", 10))
257 				continue;
258 			if (def == S_DEF_USER) {
259 				sym = sym_find(line + 2 + strlen(CONFIG_));
260 				if (!sym) {
261 					sym_add_change_count(1);
262 					goto setsym;
263 				}
264 			} else {
265 				sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
266 				if (sym->type == S_UNKNOWN)
267 					sym->type = S_BOOLEAN;
268 			}
269 			if (sym->flags & def_flags) {
270 				conf_warning("override: reassigning to symbol %s", sym->name);
271 			}
272 			switch (sym->type) {
273 			case S_BOOLEAN:
274 			case S_TRISTATE:
275 				sym->def[def].tri = no;
276 				sym->flags |= def_flags;
277 				break;
278 			default:
279 				;
280 			}
281 		} else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
282 			p = strchr(line + strlen(CONFIG_), '=');
283 			if (!p)
284 				continue;
285 			*p++ = 0;
286 			p2 = strchr(p, '\n');
287 			if (p2) {
288 				*p2-- = 0;
289 				if (*p2 == '\r')
290 					*p2 = 0;
291 			}
292 			if (def == S_DEF_USER) {
293 				sym = sym_find(line + strlen(CONFIG_));
294 				if (!sym) {
295 					sym_add_change_count(1);
296 					goto setsym;
297 				}
298 			} else {
299 				sym = sym_lookup(line + strlen(CONFIG_), 0);
300 				if (sym->type == S_UNKNOWN)
301 					sym->type = S_OTHER;
302 			}
303 			if (sym->flags & def_flags) {
304 				conf_warning("override: reassigning to symbol %s", sym->name);
305 			}
306 			if (conf_set_sym_val(sym, def, def_flags, p))
307 				continue;
308 		} else {
309 			if (line[0] != '\r' && line[0] != '\n')
310 				conf_warning("unexpected data");
311 			continue;
312 		}
313 setsym:
314 		if (sym && sym_is_choice_value(sym)) {
315 			struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
316 			switch (sym->def[def].tri) {
317 			case no:
318 				break;
319 			case mod:
320 				if (cs->def[def].tri == yes) {
321 					conf_warning("%s creates inconsistent choice state", sym->name);
322 					cs->flags &= ~def_flags;
323 				}
324 				break;
325 			case yes:
326 				if (cs->def[def].tri != no)
327 					conf_warning("override: %s changes choice state", sym->name);
328 				cs->def[def].val = sym;
329 				break;
330 			}
331 			cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
332 		}
333 	}
334 	fclose(in);
335 
336 	if (modules_sym)
337 		sym_calc_value(modules_sym);
338 	return 0;
339 }
340 
341 int conf_read(const char *name)
342 {
343 	struct symbol *sym, *choice_sym;
344 	struct property *prop;
345 	struct expr *e;
346 	int i, flags;
347 
348 	sym_set_change_count(0);
349 
350 	if (conf_read_simple(name, S_DEF_USER))
351 		return 1;
352 
353 	for_all_symbols(i, sym) {
354 		sym_calc_value(sym);
355 		if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
356 			goto sym_ok;
357 		if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
358 			/* check that calculated value agrees with saved value */
359 			switch (sym->type) {
360 			case S_BOOLEAN:
361 			case S_TRISTATE:
362 				if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
363 					break;
364 				if (!sym_is_choice(sym))
365 					goto sym_ok;
366 			default:
367 				if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
368 					goto sym_ok;
369 				break;
370 			}
371 		} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
372 			/* no previous value and not saved */
373 			goto sym_ok;
374 		conf_unsaved++;
375 		/* maybe print value in verbose mode... */
376 	sym_ok:
377 		if (!sym_is_choice(sym))
378 			continue;
379 		/* The choice symbol only has a set value (and thus is not new)
380 		 * if all its visible childs have values.
381 		 */
382 		prop = sym_get_choice_prop(sym);
383 		flags = sym->flags;
384 		expr_list_for_each_sym(prop->expr, e, choice_sym)
385 			if (choice_sym->visible != no)
386 				flags &= choice_sym->flags;
387 		sym->flags &= flags | ~SYMBOL_DEF_USER;
388 	}
389 
390 	for_all_symbols(i, sym) {
391 		if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
392 			/* Reset values of generates values, so they'll appear
393 			 * as new, if they should become visible, but that
394 			 * doesn't quite work if the Kconfig and the saved
395 			 * configuration disagree.
396 			 */
397 			if (sym->visible == no && !conf_unsaved)
398 				sym->flags &= ~SYMBOL_DEF_USER;
399 			switch (sym->type) {
400 			case S_STRING:
401 			case S_INT:
402 			case S_HEX:
403 				/* Reset a string value if it's out of range */
404 				if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))
405 					break;
406 				sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
407 				conf_unsaved++;
408 				break;
409 			default:
410 				break;
411 			}
412 		}
413 	}
414 
415 	sym_add_change_count(conf_warnings || conf_unsaved);
416 
417 	return 0;
418 }
419 
420 /* Write a S_STRING */
421 static void conf_write_string(bool headerfile, const char *name,
422                               const char *str, FILE *out)
423 {
424 	int l;
425 	if (headerfile)
426 		fprintf(out, "#define %s%s \"", CONFIG_, name);
427 	else
428 		fprintf(out, "%s%s=\"", CONFIG_, name);
429 
430 	while (1) {
431 		l = strcspn(str, "\"\\");
432 		if (l) {
433 			xfwrite(str, l, 1, out);
434 			str += l;
435 		}
436 		if (!*str)
437 			break;
438 		fprintf(out, "\\%c", *str++);
439 	}
440 	fputs("\"\n", out);
441 }
442 
443 static void conf_write_symbol(struct symbol *sym, FILE *out, bool write_no)
444 {
445 	const char *str;
446 
447 	switch (sym->type) {
448 	case S_BOOLEAN:
449 	case S_TRISTATE:
450 		switch (sym_get_tristate_value(sym)) {
451 		case no:
452 			if (write_no)
453 				fprintf(out, "# %s%s is not set\n",
454 				    CONFIG_, sym->name);
455 			break;
456 		case mod:
457 			fprintf(out, "%s%s=m\n", CONFIG_, sym->name);
458 			break;
459 		case yes:
460 			fprintf(out, "%s%s=y\n", CONFIG_, sym->name);
461 			break;
462 		}
463 		break;
464 	case S_STRING:
465 		conf_write_string(false, sym->name, sym_get_string_value(sym), out);
466 		break;
467 	case S_HEX:
468 	case S_INT:
469 		str = sym_get_string_value(sym);
470 		fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str);
471 		break;
472 	case S_OTHER:
473 	case S_UNKNOWN:
474 		break;
475 	}
476 }
477 
478 /*
479  * Write out a minimal config.
480  * All values that has default values are skipped as this is redundant.
481  */
482 int conf_write_defconfig(const char *filename)
483 {
484 	struct symbol *sym;
485 	struct menu *menu;
486 	FILE *out;
487 
488 	out = fopen(filename, "w");
489 	if (!out)
490 		return 1;
491 
492 	sym_clear_all_valid();
493 
494 	/* Traverse all menus to find all relevant symbols */
495 	menu = rootmenu.list;
496 
497 	while (menu != NULL)
498 	{
499 		sym = menu->sym;
500 		if (sym == NULL) {
501 			if (!menu_is_visible(menu))
502 				goto next_menu;
503 		} else if (!sym_is_choice(sym)) {
504 			sym_calc_value(sym);
505 			if (!(sym->flags & SYMBOL_WRITE))
506 				goto next_menu;
507 			sym->flags &= ~SYMBOL_WRITE;
508 			/* If we cannot change the symbol - skip */
509 			if (!sym_is_changable(sym))
510 				goto next_menu;
511 			/* If symbol equals to default value - skip */
512 			if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
513 				goto next_menu;
514 
515 			/*
516 			 * If symbol is a choice value and equals to the
517 			 * default for a choice - skip.
518 			 * But only if value is bool and equal to "y" and
519 			 * choice is not "optional".
520 			 * (If choice is "optional" then all values can be "n")
521 			 */
522 			if (sym_is_choice_value(sym)) {
523 				struct symbol *cs;
524 				struct symbol *ds;
525 
526 				cs = prop_get_symbol(sym_get_choice_prop(sym));
527 				ds = sym_choice_default(cs);
528 				if (!sym_is_optional(cs) && sym == ds) {
529 					if ((sym->type == S_BOOLEAN) &&
530 					    sym_get_tristate_value(sym) == yes)
531 						goto next_menu;
532 				}
533 			}
534 			conf_write_symbol(sym, out, true);
535 		}
536 next_menu:
537 		if (menu->list != NULL) {
538 			menu = menu->list;
539 		}
540 		else if (menu->next != NULL) {
541 			menu = menu->next;
542 		} else {
543 			while ((menu = menu->parent)) {
544 				if (menu->next != NULL) {
545 					menu = menu->next;
546 					break;
547 				}
548 			}
549 		}
550 	}
551 	fclose(out);
552 	return 0;
553 }
554 
555 int conf_write(const char *name)
556 {
557 	FILE *out;
558 	struct symbol *sym;
559 	struct menu *menu;
560 	const char *basename;
561 	const char *str;
562 	char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];
563 	time_t now;
564 	int use_timestamp = 1;
565 	char *env;
566 
567 	dirname[0] = 0;
568 	if (name && name[0]) {
569 		struct stat st;
570 		char *slash;
571 
572 		if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
573 			strcpy(dirname, name);
574 			strcat(dirname, "/");
575 			basename = conf_get_configname();
576 		} else if ((slash = strrchr(name, '/'))) {
577 			int size = slash - name + 1;
578 			memcpy(dirname, name, size);
579 			dirname[size] = 0;
580 			if (slash[1])
581 				basename = slash + 1;
582 			else
583 				basename = conf_get_configname();
584 		} else
585 			basename = name;
586 	} else
587 		basename = conf_get_configname();
588 
589 	sprintf(newname, "%s%s", dirname, basename);
590 	env = getenv("KCONFIG_OVERWRITECONFIG");
591 	if (!env || !*env) {
592 		sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
593 		out = fopen(tmpname, "w");
594 	} else {
595 		*tmpname = 0;
596 		out = fopen(newname, "w");
597 	}
598 	if (!out)
599 		return 1;
600 
601 	time(&now);
602 	env = getenv("KCONFIG_NOTIMESTAMP");
603 	if (env && *env)
604 		use_timestamp = 0;
605 
606 	fprintf(out, _("#\n"
607 		       "# Automatically generated make config: don't edit\n"
608 		       "# %s\n"
609 		       "%s%s"
610 		       "#\n"),
611 		     rootmenu.prompt->text,
612 		     use_timestamp ? "# " : "",
613 		     use_timestamp ? ctime(&now) : "");
614 
615 	if (!conf_get_changed())
616 		sym_clear_all_valid();
617 
618 	menu = rootmenu.list;
619 	while (menu) {
620 		sym = menu->sym;
621 		if (!sym) {
622 			if (!menu_is_visible(menu))
623 				goto next;
624 			str = menu_get_prompt(menu);
625 			fprintf(out, "\n"
626 				     "#\n"
627 				     "# %s\n"
628 				     "#\n", str);
629 		} else if (!(sym->flags & SYMBOL_CHOICE)) {
630 			sym_calc_value(sym);
631 			if (!(sym->flags & SYMBOL_WRITE))
632 				goto next;
633 			sym->flags &= ~SYMBOL_WRITE;
634 			/* Write config symbol to file */
635 			conf_write_symbol(sym, out, true);
636 		}
637 
638 next:
639 		if (menu->list) {
640 			menu = menu->list;
641 			continue;
642 		}
643 		if (menu->next)
644 			menu = menu->next;
645 		else while ((menu = menu->parent)) {
646 			if (menu->next) {
647 				menu = menu->next;
648 				break;
649 			}
650 		}
651 	}
652 	fclose(out);
653 
654 	if (*tmpname) {
655 		strcat(dirname, basename);
656 		strcat(dirname, ".old");
657 		rename(newname, dirname);
658 		if (rename(tmpname, newname))
659 			return 1;
660 	}
661 
662 	conf_message(_("configuration written to %s"), newname);
663 
664 	sym_set_change_count(0);
665 
666 	return 0;
667 }
668 
669 static int conf_split_config(void)
670 {
671 	const char *name;
672 	char path[PATH_MAX+1];
673 	char *s, *d, c;
674 	struct symbol *sym;
675 	struct stat sb;
676 	int res, i, fd;
677 
678 	name = conf_get_autoconfig_name();
679 	conf_read_simple(name, S_DEF_AUTO);
680 
681 	if (chdir("include/config"))
682 		return 1;
683 
684 	res = 0;
685 	for_all_symbols(i, sym) {
686 		sym_calc_value(sym);
687 		if ((sym->flags & SYMBOL_AUTO) || !sym->name)
688 			continue;
689 		if (sym->flags & SYMBOL_WRITE) {
690 			if (sym->flags & SYMBOL_DEF_AUTO) {
691 				/*
692 				 * symbol has old and new value,
693 				 * so compare them...
694 				 */
695 				switch (sym->type) {
696 				case S_BOOLEAN:
697 				case S_TRISTATE:
698 					if (sym_get_tristate_value(sym) ==
699 					    sym->def[S_DEF_AUTO].tri)
700 						continue;
701 					break;
702 				case S_STRING:
703 				case S_HEX:
704 				case S_INT:
705 					if (!strcmp(sym_get_string_value(sym),
706 						    sym->def[S_DEF_AUTO].val))
707 						continue;
708 					break;
709 				default:
710 					break;
711 				}
712 			} else {
713 				/*
714 				 * If there is no old value, only 'no' (unset)
715 				 * is allowed as new value.
716 				 */
717 				switch (sym->type) {
718 				case S_BOOLEAN:
719 				case S_TRISTATE:
720 					if (sym_get_tristate_value(sym) == no)
721 						continue;
722 					break;
723 				default:
724 					break;
725 				}
726 			}
727 		} else if (!(sym->flags & SYMBOL_DEF_AUTO))
728 			/* There is neither an old nor a new value. */
729 			continue;
730 		/* else
731 		 *	There is an old value, but no new value ('no' (unset)
732 		 *	isn't saved in auto.conf, so the old value is always
733 		 *	different from 'no').
734 		 */
735 
736 		/* Replace all '_' and append ".h" */
737 		s = sym->name;
738 		d = path;
739 		while ((c = *s++)) {
740 			c = tolower(c);
741 			*d++ = (c == '_') ? '/' : c;
742 		}
743 		strcpy(d, ".h");
744 
745 		/* Assume directory path already exists. */
746 		fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
747 		if (fd == -1) {
748 			if (errno != ENOENT) {
749 				res = 1;
750 				break;
751 			}
752 			/*
753 			 * Create directory components,
754 			 * unless they exist already.
755 			 */
756 			d = path;
757 			while ((d = strchr(d, '/'))) {
758 				*d = 0;
759 				if (stat(path, &sb) && mkdir(path, 0755)) {
760 					res = 1;
761 					goto out;
762 				}
763 				*d++ = '/';
764 			}
765 			/* Try it again. */
766 			fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
767 			if (fd == -1) {
768 				res = 1;
769 				break;
770 			}
771 		}
772 		close(fd);
773 	}
774 out:
775 	if (chdir("../.."))
776 		return 1;
777 
778 	return res;
779 }
780 
781 int conf_write_autoconf(void)
782 {
783 	struct symbol *sym;
784 	const char *str;
785 	const char *name;
786 	FILE *out, *tristate, *out_h;
787 	time_t now;
788 	int i;
789 
790 	sym_clear_all_valid();
791 
792 	file_write_dep("include/config/auto.conf.cmd");
793 
794 	if (conf_split_config())
795 		return 1;
796 
797 	out = fopen(".tmpconfig", "w");
798 	if (!out)
799 		return 1;
800 
801 	tristate = fopen(".tmpconfig_tristate", "w");
802 	if (!tristate) {
803 		fclose(out);
804 		return 1;
805 	}
806 
807 	out_h = fopen(".tmpconfig.h", "w");
808 	if (!out_h) {
809 		fclose(out);
810 		fclose(tristate);
811 		return 1;
812 	}
813 
814 	time(&now);
815 	fprintf(out, "#\n"
816 		     "# Automatically generated make config: don't edit\n"
817 		     "# %s\n"
818 		     "# %s"
819 		     "#\n",
820 		     rootmenu.prompt->text, ctime(&now));
821 	fprintf(tristate, "#\n"
822 			  "# Automatically generated - do not edit\n"
823 			  "\n");
824 	fprintf(out_h, "/*\n"
825 		       " * Automatically generated C config: don't edit\n"
826 		       " * %s\n"
827 		       " * %s"
828 		       " */\n",
829 		       rootmenu.prompt->text, ctime(&now));
830 
831 	for_all_symbols(i, sym) {
832 		sym_calc_value(sym);
833 		if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
834 			continue;
835 
836 		/* write symbol to config file */
837 		conf_write_symbol(sym, out, false);
838 
839 		/* update autoconf and tristate files */
840 		switch (sym->type) {
841 		case S_BOOLEAN:
842 		case S_TRISTATE:
843 			switch (sym_get_tristate_value(sym)) {
844 			case no:
845 				break;
846 			case mod:
847 				fprintf(tristate, "%s%s=M\n",
848 				    CONFIG_, sym->name);
849 				fprintf(out_h, "#define %s%s_MODULE 1\n",
850 				    CONFIG_, sym->name);
851 				break;
852 			case yes:
853 				if (sym->type == S_TRISTATE)
854 					fprintf(tristate,"%s%s=Y\n",
855 					    CONFIG_, sym->name);
856 				fprintf(out_h, "#define %s%s 1\n",
857 				    CONFIG_, sym->name);
858 				break;
859 			}
860 			break;
861 		case S_STRING:
862 			conf_write_string(true, sym->name, sym_get_string_value(sym), out_h);
863 			break;
864 		case S_HEX:
865 			str = sym_get_string_value(sym);
866 			if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
867 				fprintf(out_h, "#define %s%s 0x%s\n",
868 				    CONFIG_, sym->name, str);
869 				break;
870 			}
871 		case S_INT:
872 			str = sym_get_string_value(sym);
873 			fprintf(out_h, "#define %s%s %s\n",
874 			    CONFIG_, sym->name, str);
875 			break;
876 		default:
877 			break;
878 		}
879 	}
880 	fclose(out);
881 	fclose(tristate);
882 	fclose(out_h);
883 
884 	name = getenv("KCONFIG_AUTOHEADER");
885 	if (!name)
886 		name = "include/generated/autoconf.h";
887 	if (rename(".tmpconfig.h", name))
888 		return 1;
889 	name = getenv("KCONFIG_TRISTATE");
890 	if (!name)
891 		name = "include/config/tristate.conf";
892 	if (rename(".tmpconfig_tristate", name))
893 		return 1;
894 	name = conf_get_autoconfig_name();
895 	/*
896 	 * This must be the last step, kbuild has a dependency on auto.conf
897 	 * and this marks the successful completion of the previous steps.
898 	 */
899 	if (rename(".tmpconfig", name))
900 		return 1;
901 
902 	return 0;
903 }
904 
905 static int sym_change_count;
906 static void (*conf_changed_callback)(void);
907 
908 void sym_set_change_count(int count)
909 {
910 	int _sym_change_count = sym_change_count;
911 	sym_change_count = count;
912 	if (conf_changed_callback &&
913 	    (bool)_sym_change_count != (bool)count)
914 		conf_changed_callback();
915 }
916 
917 void sym_add_change_count(int count)
918 {
919 	sym_set_change_count(count + sym_change_count);
920 }
921 
922 bool conf_get_changed(void)
923 {
924 	return sym_change_count;
925 }
926 
927 void conf_set_changed_callback(void (*fn)(void))
928 {
929 	conf_changed_callback = fn;
930 }
931 
932 static void randomize_choice_values(struct symbol *csym)
933 {
934 	struct property *prop;
935 	struct symbol *sym;
936 	struct expr *e;
937 	int cnt, def;
938 
939 	/*
940 	 * If choice is mod then we may have more items selected
941 	 * and if no then no-one.
942 	 * In both cases stop.
943 	 */
944 	if (csym->curr.tri != yes)
945 		return;
946 
947 	prop = sym_get_choice_prop(csym);
948 
949 	/* count entries in choice block */
950 	cnt = 0;
951 	expr_list_for_each_sym(prop->expr, e, sym)
952 		cnt++;
953 
954 	/*
955 	 * find a random value and set it to yes,
956 	 * set the rest to no so we have only one set
957 	 */
958 	def = (rand() % cnt);
959 
960 	cnt = 0;
961 	expr_list_for_each_sym(prop->expr, e, sym) {
962 		if (def == cnt++) {
963 			sym->def[S_DEF_USER].tri = yes;
964 			csym->def[S_DEF_USER].val = sym;
965 		}
966 		else {
967 			sym->def[S_DEF_USER].tri = no;
968 		}
969 	}
970 	csym->flags |= SYMBOL_DEF_USER;
971 	/* clear VALID to get value calculated */
972 	csym->flags &= ~(SYMBOL_VALID);
973 }
974 
975 static void set_all_choice_values(struct symbol *csym)
976 {
977 	struct property *prop;
978 	struct symbol *sym;
979 	struct expr *e;
980 
981 	prop = sym_get_choice_prop(csym);
982 
983 	/*
984 	 * Set all non-assinged choice values to no
985 	 */
986 	expr_list_for_each_sym(prop->expr, e, sym) {
987 		if (!sym_has_value(sym))
988 			sym->def[S_DEF_USER].tri = no;
989 	}
990 	csym->flags |= SYMBOL_DEF_USER;
991 	/* clear VALID to get value calculated */
992 	csym->flags &= ~(SYMBOL_VALID);
993 }
994 
995 void conf_set_all_new_symbols(enum conf_def_mode mode)
996 {
997 	struct symbol *sym, *csym;
998 	int i, cnt;
999 
1000 	for_all_symbols(i, sym) {
1001 		if (sym_has_value(sym))
1002 			continue;
1003 		switch (sym_get_type(sym)) {
1004 		case S_BOOLEAN:
1005 		case S_TRISTATE:
1006 			switch (mode) {
1007 			case def_yes:
1008 				sym->def[S_DEF_USER].tri = yes;
1009 				break;
1010 			case def_mod:
1011 				sym->def[S_DEF_USER].tri = mod;
1012 				break;
1013 			case def_no:
1014 				sym->def[S_DEF_USER].tri = no;
1015 				break;
1016 			case def_random:
1017 				cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2;
1018 				sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt);
1019 				break;
1020 			default:
1021 				continue;
1022 			}
1023 			if (!(sym_is_choice(sym) && mode == def_random))
1024 				sym->flags |= SYMBOL_DEF_USER;
1025 			break;
1026 		default:
1027 			break;
1028 		}
1029 
1030 	}
1031 
1032 	sym_clear_all_valid();
1033 
1034 	/*
1035 	 * We have different type of choice blocks.
1036 	 * If curr.tri equals to mod then we can select several
1037 	 * choice symbols in one block.
1038 	 * In this case we do nothing.
1039 	 * If curr.tri equals yes then only one symbol can be
1040 	 * selected in a choice block and we set it to yes,
1041 	 * and the rest to no.
1042 	 */
1043 	for_all_symbols(i, csym) {
1044 		if (sym_has_value(csym) || !sym_is_choice(csym))
1045 			continue;
1046 
1047 		sym_calc_value(csym);
1048 		if (mode == def_random)
1049 			randomize_choice_values(csym);
1050 		else
1051 			set_all_choice_values(csym);
1052 	}
1053 }
1054