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