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
19static void conf_warning(const char *fmt, ...)
20	__attribute__ ((format (printf, 1, 2)));
21
22static void conf_message(const char *fmt, ...)
23	__attribute__ ((format (printf, 1, 2)));
24
25static const char *conf_filename;
26static int conf_lineno, conf_warnings, conf_unsaved;
27
28const char conf_defname[] = "arch/$ARCH/defconfig";
29
30static 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
41static 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
48static void (*conf_message_callback) (const char *fmt, va_list ap) =
49	conf_default_message_callback;
50void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))
51{
52	conf_message_callback = fn;
53}
54
55static 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
64const char *conf_get_configname(void)
65{
66	char *name = getenv("KCONFIG_CONFIG");
67
68	return name ? name : ".config";
69}
70
71const char *conf_get_autoconfig_name(void)
72{
73	char *name = getenv("KCONFIG_AUTOCONFIG");
74
75	return name ? name : "include/config/auto.conf";
76}
77
78static 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
104char *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
120static 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
182int 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
222load:
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		}
313setsym:
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
341int 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 */
421static 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
443static 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 */
482int 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		}
536next_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
555int 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	char *env;
564
565	dirname[0] = 0;
566	if (name && name[0]) {
567		struct stat st;
568		char *slash;
569
570		if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
571			strcpy(dirname, name);
572			strcat(dirname, "/");
573			basename = conf_get_configname();
574		} else if ((slash = strrchr(name, '/'))) {
575			int size = slash - name + 1;
576			memcpy(dirname, name, size);
577			dirname[size] = 0;
578			if (slash[1])
579				basename = slash + 1;
580			else
581				basename = conf_get_configname();
582		} else
583			basename = name;
584	} else
585		basename = conf_get_configname();
586
587	sprintf(newname, "%s%s", dirname, basename);
588	env = getenv("KCONFIG_OVERWRITECONFIG");
589	if (!env || !*env) {
590		sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
591		out = fopen(tmpname, "w");
592	} else {
593		*tmpname = 0;
594		out = fopen(newname, "w");
595	}
596	if (!out)
597		return 1;
598
599	fprintf(out, _("#\n"
600		       "# Automatically generated make config: don't edit\n"
601		       "# %s\n"
602		       "#\n"),
603		     rootmenu.prompt->text);
604
605	if (!conf_get_changed())
606		sym_clear_all_valid();
607
608	menu = rootmenu.list;
609	while (menu) {
610		sym = menu->sym;
611		if (!sym) {
612			if (!menu_is_visible(menu))
613				goto next;
614			str = menu_get_prompt(menu);
615			fprintf(out, "\n"
616				     "#\n"
617				     "# %s\n"
618				     "#\n", str);
619		} else if (!(sym->flags & SYMBOL_CHOICE)) {
620			sym_calc_value(sym);
621			if (!(sym->flags & SYMBOL_WRITE))
622				goto next;
623			sym->flags &= ~SYMBOL_WRITE;
624			/* Write config symbol to file */
625			conf_write_symbol(sym, out, true);
626		}
627
628next:
629		if (menu->list) {
630			menu = menu->list;
631			continue;
632		}
633		if (menu->next)
634			menu = menu->next;
635		else while ((menu = menu->parent)) {
636			if (menu->next) {
637				menu = menu->next;
638				break;
639			}
640		}
641	}
642	fclose(out);
643
644	if (*tmpname) {
645		strcat(dirname, basename);
646		strcat(dirname, ".old");
647		rename(newname, dirname);
648		if (rename(tmpname, newname))
649			return 1;
650	}
651
652	conf_message(_("configuration written to %s"), newname);
653
654	sym_set_change_count(0);
655
656	return 0;
657}
658
659static int conf_split_config(void)
660{
661	const char *name;
662	char path[PATH_MAX+1];
663	char *s, *d, c;
664	struct symbol *sym;
665	struct stat sb;
666	int res, i, fd;
667
668	name = conf_get_autoconfig_name();
669	conf_read_simple(name, S_DEF_AUTO);
670
671	if (chdir("include/config"))
672		return 1;
673
674	res = 0;
675	for_all_symbols(i, sym) {
676		sym_calc_value(sym);
677		if ((sym->flags & SYMBOL_AUTO) || !sym->name)
678			continue;
679		if (sym->flags & SYMBOL_WRITE) {
680			if (sym->flags & SYMBOL_DEF_AUTO) {
681				/*
682				 * symbol has old and new value,
683				 * so compare them...
684				 */
685				switch (sym->type) {
686				case S_BOOLEAN:
687				case S_TRISTATE:
688					if (sym_get_tristate_value(sym) ==
689					    sym->def[S_DEF_AUTO].tri)
690						continue;
691					break;
692				case S_STRING:
693				case S_HEX:
694				case S_INT:
695					if (!strcmp(sym_get_string_value(sym),
696						    sym->def[S_DEF_AUTO].val))
697						continue;
698					break;
699				default:
700					break;
701				}
702			} else {
703				/*
704				 * If there is no old value, only 'no' (unset)
705				 * is allowed as new value.
706				 */
707				switch (sym->type) {
708				case S_BOOLEAN:
709				case S_TRISTATE:
710					if (sym_get_tristate_value(sym) == no)
711						continue;
712					break;
713				default:
714					break;
715				}
716			}
717		} else if (!(sym->flags & SYMBOL_DEF_AUTO))
718			/* There is neither an old nor a new value. */
719			continue;
720		/* else
721		 *	There is an old value, but no new value ('no' (unset)
722		 *	isn't saved in auto.conf, so the old value is always
723		 *	different from 'no').
724		 */
725
726		/* Replace all '_' and append ".h" */
727		s = sym->name;
728		d = path;
729		while ((c = *s++)) {
730			c = tolower(c);
731			*d++ = (c == '_') ? '/' : c;
732		}
733		strcpy(d, ".h");
734
735		/* Assume directory path already exists. */
736		fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
737		if (fd == -1) {
738			if (errno != ENOENT) {
739				res = 1;
740				break;
741			}
742			/*
743			 * Create directory components,
744			 * unless they exist already.
745			 */
746			d = path;
747			while ((d = strchr(d, '/'))) {
748				*d = 0;
749				if (stat(path, &sb) && mkdir(path, 0755)) {
750					res = 1;
751					goto out;
752				}
753				*d++ = '/';
754			}
755			/* Try it again. */
756			fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
757			if (fd == -1) {
758				res = 1;
759				break;
760			}
761		}
762		close(fd);
763	}
764out:
765	if (chdir("../.."))
766		return 1;
767
768	return res;
769}
770
771int conf_write_autoconf(void)
772{
773	struct symbol *sym;
774	const char *str;
775	const char *name;
776	FILE *out, *tristate, *out_h;
777	int i;
778
779	sym_clear_all_valid();
780
781	file_write_dep("include/config/auto.conf.cmd");
782
783	if (conf_split_config())
784		return 1;
785
786	out = fopen(".tmpconfig", "w");
787	if (!out)
788		return 1;
789
790	tristate = fopen(".tmpconfig_tristate", "w");
791	if (!tristate) {
792		fclose(out);
793		return 1;
794	}
795
796	out_h = fopen(".tmpconfig.h", "w");
797	if (!out_h) {
798		fclose(out);
799		fclose(tristate);
800		return 1;
801	}
802
803	fprintf(out, "#\n"
804		     "# Automatically generated make config: don't edit\n"
805		     "# %s\n"
806		     "#\n",
807		     rootmenu.prompt->text);
808	fprintf(tristate, "#\n"
809			  "# Automatically generated - do not edit\n"
810			  "\n");
811	fprintf(out_h, "/*\n"
812		       " * Automatically generated C config: don't edit\n"
813		       " * %s\n"
814		       " */\n",
815		       rootmenu.prompt->text);
816
817	for_all_symbols(i, sym) {
818		sym_calc_value(sym);
819		if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
820			continue;
821
822		/* write symbol to config file */
823		conf_write_symbol(sym, out, false);
824
825		/* update autoconf and tristate files */
826		switch (sym->type) {
827		case S_BOOLEAN:
828		case S_TRISTATE:
829			switch (sym_get_tristate_value(sym)) {
830			case no:
831				break;
832			case mod:
833				fprintf(tristate, "%s%s=M\n",
834				    CONFIG_, sym->name);
835				fprintf(out_h, "#define %s%s_MODULE 1\n",
836				    CONFIG_, sym->name);
837				break;
838			case yes:
839				if (sym->type == S_TRISTATE)
840					fprintf(tristate,"%s%s=Y\n",
841					    CONFIG_, sym->name);
842				fprintf(out_h, "#define %s%s 1\n",
843				    CONFIG_, sym->name);
844				break;
845			}
846			break;
847		case S_STRING:
848			conf_write_string(true, sym->name, sym_get_string_value(sym), out_h);
849			break;
850		case S_HEX:
851			str = sym_get_string_value(sym);
852			if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
853				fprintf(out_h, "#define %s%s 0x%s\n",
854				    CONFIG_, sym->name, str);
855				break;
856			}
857		case S_INT:
858			str = sym_get_string_value(sym);
859			fprintf(out_h, "#define %s%s %s\n",
860			    CONFIG_, sym->name, str);
861			break;
862		default:
863			break;
864		}
865	}
866	fclose(out);
867	fclose(tristate);
868	fclose(out_h);
869
870	name = getenv("KCONFIG_AUTOHEADER");
871	if (!name)
872		name = "include/generated/autoconf.h";
873	if (rename(".tmpconfig.h", name))
874		return 1;
875	name = getenv("KCONFIG_TRISTATE");
876	if (!name)
877		name = "include/config/tristate.conf";
878	if (rename(".tmpconfig_tristate", name))
879		return 1;
880	name = conf_get_autoconfig_name();
881	/*
882	 * This must be the last step, kbuild has a dependency on auto.conf
883	 * and this marks the successful completion of the previous steps.
884	 */
885	if (rename(".tmpconfig", name))
886		return 1;
887
888	return 0;
889}
890
891static int sym_change_count;
892static void (*conf_changed_callback)(void);
893
894void sym_set_change_count(int count)
895{
896	int _sym_change_count = sym_change_count;
897	sym_change_count = count;
898	if (conf_changed_callback &&
899	    (bool)_sym_change_count != (bool)count)
900		conf_changed_callback();
901}
902
903void sym_add_change_count(int count)
904{
905	sym_set_change_count(count + sym_change_count);
906}
907
908bool conf_get_changed(void)
909{
910	return sym_change_count;
911}
912
913void conf_set_changed_callback(void (*fn)(void))
914{
915	conf_changed_callback = fn;
916}
917
918static void randomize_choice_values(struct symbol *csym)
919{
920	struct property *prop;
921	struct symbol *sym;
922	struct expr *e;
923	int cnt, def;
924
925	/*
926	 * If choice is mod then we may have more items selected
927	 * and if no then no-one.
928	 * In both cases stop.
929	 */
930	if (csym->curr.tri != yes)
931		return;
932
933	prop = sym_get_choice_prop(csym);
934
935	/* count entries in choice block */
936	cnt = 0;
937	expr_list_for_each_sym(prop->expr, e, sym)
938		cnt++;
939
940	/*
941	 * find a random value and set it to yes,
942	 * set the rest to no so we have only one set
943	 */
944	def = (rand() % cnt);
945
946	cnt = 0;
947	expr_list_for_each_sym(prop->expr, e, sym) {
948		if (def == cnt++) {
949			sym->def[S_DEF_USER].tri = yes;
950			csym->def[S_DEF_USER].val = sym;
951		}
952		else {
953			sym->def[S_DEF_USER].tri = no;
954		}
955	}
956	csym->flags |= SYMBOL_DEF_USER;
957	/* clear VALID to get value calculated */
958	csym->flags &= ~(SYMBOL_VALID);
959}
960
961static void set_all_choice_values(struct symbol *csym)
962{
963	struct property *prop;
964	struct symbol *sym;
965	struct expr *e;
966
967	prop = sym_get_choice_prop(csym);
968
969	/*
970	 * Set all non-assinged choice values to no
971	 */
972	expr_list_for_each_sym(prop->expr, e, sym) {
973		if (!sym_has_value(sym))
974			sym->def[S_DEF_USER].tri = no;
975	}
976	csym->flags |= SYMBOL_DEF_USER;
977	/* clear VALID to get value calculated */
978	csym->flags &= ~(SYMBOL_VALID);
979}
980
981void conf_set_all_new_symbols(enum conf_def_mode mode)
982{
983	struct symbol *sym, *csym;
984	int i, cnt;
985
986	for_all_symbols(i, sym) {
987		if (sym_has_value(sym))
988			continue;
989		switch (sym_get_type(sym)) {
990		case S_BOOLEAN:
991		case S_TRISTATE:
992			switch (mode) {
993			case def_yes:
994				sym->def[S_DEF_USER].tri = yes;
995				break;
996			case def_mod:
997				sym->def[S_DEF_USER].tri = mod;
998				break;
999			case def_no:
1000				sym->def[S_DEF_USER].tri = no;
1001				break;
1002			case def_random:
1003				cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2;
1004				sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt);
1005				break;
1006			default:
1007				continue;
1008			}
1009			if (!(sym_is_choice(sym) && mode == def_random))
1010				sym->flags |= SYMBOL_DEF_USER;
1011			break;
1012		default:
1013			break;
1014		}
1015
1016	}
1017
1018	sym_clear_all_valid();
1019
1020	/*
1021	 * We have different type of choice blocks.
1022	 * If curr.tri equals to mod then we can select several
1023	 * choice symbols in one block.
1024	 * In this case we do nothing.
1025	 * If curr.tri equals yes then only one symbol can be
1026	 * selected in a choice block and we set it to yes,
1027	 * and the rest to no.
1028	 */
1029	for_all_symbols(i, csym) {
1030		if (sym_has_value(csym) || !sym_is_choice(csym))
1031			continue;
1032
1033		sym_calc_value(csym);
1034		if (mode == def_random)
1035			randomize_choice_values(csym);
1036		else
1037			set_all_choice_values(csym);
1038	}
1039}
1040