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