crosstool-ng: kconfig/confdata.c@c57458bb354d

     1 /*

     2  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>

     3  * Released under the terms of the GNU GPL v2.0.

     4  */

     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>

    15 #define LKC_DIRECT_LINK

    16 #include "lkc.h"

    18 static void conf_warning(const char *fmt, ...)

    19 	__attribute__ ((format (printf, 1, 2)));

    21 static const char *conf_filename;

    22 static int conf_lineno, conf_warnings, conf_unsaved;

    24 const char conf_defname[] = "arch/$ARCH/defconfig";

    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 }

    37 const char *conf_get_configname(void)

    38 {

    39 	char *name = getenv("KCONFIG_CONFIG");

    41 	return name ? name : ".config";

    42 }

    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];

    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);

    67 	return res_value;

    68 }

    70 char *conf_get_default_confname(void)

    71 {

    72 	struct stat buf;

    73 	static char fullname[PATH_MAX+1];

    74 	char *env, *name;

    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 }

    86 static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)

    87 {

    88 	char *p2;

    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 }

   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;

   156 	if (name) {

   157 		in = zconf_fopen(name);

   158 	} else {

   159 		struct property *prop;

   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;

   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;

   186 load:

   187 	conf_filename = name;

   188 	conf_lineno = 0;

   189 	conf_warnings = 0;

   190 	conf_unsaved = 0;

   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 	}

   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);

   308 	if (modules_sym)

   309 		sym_calc_value(modules_sym);

   310 	return 0;

   311 }

   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;

   320 	sym_set_change_count(0);

   322 	if (conf_read_simple(name, S_DEF_USER))

   323 		return 1;

   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 	}

   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 	}

   387 	sym_add_change_count(conf_warnings || conf_unsaved);

   389 	return 0;

   390 }

   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;

   405 	dirname[0] = 0;

   406 	if (name && name[0]) {

   407 		struct stat st;

   408 		char *slash;

   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();

   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;

   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;

   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) : "");

   455 	if (!conf_get_changed())

   456 		sym_clear_all_valid();

   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 		}

   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);

   539 	if (*tmpname) {

   540 		strcat(dirname, basename);

   541 		strcat(dirname, ".old");

   542 		rename(newname, dirname);

   543 		if (rename(tmpname, newname))

   544 			return 1;

   545 	}

   547 	sym_set_change_count(0);

   549 	return 0;

   550 }

   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;

   560 	name = getenv("KCONFIG_AUTOCONFIG");

   561 	if (!name)

   562 		name = "include/config/auto.conf";

   563 	conf_read_simple(name, S_DEF_AUTO);

   565 	if (chdir("include/config"))

   566 		return 1;

   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 		 */

   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");

   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;

   662 	return res;

   663 }

   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;

   674 	sym_clear_all_valid();

   676 	file_write_dep("include/config/auto.conf.cmd");

   678 	if (conf_split_config())

   679 		return 1;

   681 	out = fopen(".tmpconfig", "w");

   682 	if (!out)

   683 		return 1;

   685 	out_h = fopen(".tmpconfig.h", "w");

   686 	if (!out_h) {

   687 		fclose(out);

   688 		return 1;

   689 	}

   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));

   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);

   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;

   782 	return 0;

   783 }

   785 static int sym_change_count;

   786 static void (*conf_changed_callback)(void);

   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 }

   797 void sym_add_change_count(int count)

   798 {

   799 	sym_set_change_count(count + sym_change_count);

   800 }

   802 bool conf_get_changed(void)

   803 {

   804 	return sym_change_count;

   805 }

   807 void conf_set_changed_callback(void (*fn)(void))

   808 {

   809 	conf_changed_callback = fn;

   810 }

   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;

   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 		}

   849 	}

   851 	sym_clear_all_valid();

   853 	if (mode != def_random)

   854 		return;

   856 	for_all_symbols(i, csym) {

   857 		if (sym_has_value(csym) || !sym_is_choice(csym))

   858 			continue;

   860 		sym_calc_value(csym);

   861 		prop = sym_get_choice_prop(csym);

   862 		def = -1;

   863 		while (1) {

   864 			cnt = 0;

   865 			expr_list_for_each_sym(prop->expr, e, sym) {

   866 				if (sym->visible == no)

   867 					continue;

   868 				if (def == cnt++) {

   869 					csym->def[S_DEF_USER].val = sym;

   870 					break;

   871 				}

   872 			}

   873 			if (def >= 0 || cnt < 2)

   874 				break;

   875 			def = (rand() % cnt) + 1;

   876 		}

   877 		csym->flags |= SYMBOL_DEF_USER;

   878 	}

   879 }

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Sun Jan 17 23:06:02 2010 +0100 (2010-01-17)
changeset 1740	c57458bb354d
parent 943	1cca90ce0481
child 2448	a103abae1560
permissions	-rw-r--r--