kconfig/confdata.c
author "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
Thu Jan 29 18:53:32 2009 +0000 (2009-01-29)
changeset 1174 7710d81d15e7
parent 94 f32c4f663805
child 1228 5a32746fa3e9
permissions -rw-r--r--
Use the path discovered by ./configure in scripts/addToolVersion.sh
It now requires that "./configure && make" be run beforehand.

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