crosstool-ng: kconfig/confdata.c@6b2c4692f132

     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 <errno.h>

     9 #include <fcntl.h>

    10 #include <stdio.h>

    11 #include <stdlib.h>

    12 #include <string.h>

    13 #include <time.h>

    14 #include <unistd.h>

    16 #define LKC_DIRECT_LINK

    17 #include "lkc.h"

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

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

    22 static void conf_message(const char *fmt, ...)

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

    25 static const char *conf_filename;

    26 static int conf_lineno, conf_warnings, conf_unsaved;

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

    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 }

    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 }

    48 static void (*conf_message_callback) (const char *fmt, va_list ap) =

    49 	conf_default_message_callback;

    50 void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))

    51 {

    52 	conf_message_callback = fn;

    53 }

    55 static void conf_message(const char *fmt, ...)

    56 {

    57 	va_list ap;

    59 	va_start(ap, fmt);

    60 	if (conf_message_callback)

    61 		conf_message_callback(fmt, ap);

    62 }

    64 const char *conf_get_configname(void)

    65 {

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

    68 	return name ? name : ".config";

    69 }

    71 const char *conf_get_autoconfig_name(void)

    72 {

    73 	char *name = getenv("KCONFIG_AUTOCONFIG");

    75 	return name ? name : "include/config/auto.conf";

    76 }

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

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

   101 	return res_value;

   102 }

   104 char *conf_get_default_confname(void)

   105 {

   106 	struct stat buf;

   107 	static char fullname[PATH_MAX+1];

   108 	char *env, *name;

   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 }

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

   121 {

   122 	char *p2;

   124 	switch (sym->type) {

   125 	case S_TRISTATE:

   126 		if (p[0] == 'm') {

   127 			sym->def[def].tri = mod;

   128 			sym->flags |= def_flags;

   129 			break;

   130 		}

   131 	case S_BOOLEAN:

   132 		if (p[0] == 'y') {

   133 			sym->def[def].tri = yes;

   134 			sym->flags |= def_flags;

   135 			break;

   136 		}

   137 		if (p[0] == 'n') {

   138 			sym->def[def].tri = no;

   139 			sym->flags |= def_flags;

   140 			break;

   141 		}

   142 		conf_warning("symbol value '%s' invalid for %s", p, sym->name);

   143 		break;

   144 	case S_OTHER:

   145 		if (*p != '"') {

   146 			for (p2 = p; *p2 && !isspace(*p2); p2++)

   147 				;

   148 			sym->type = S_STRING;

   149 			goto done;

   150 		}

   151 	case S_STRING:

   152 		if (*p++ != '"')

   153 			break;

   154 		for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {

   155 			if (*p2 == '"') {

   156 				*p2 = 0;

   157 				break;

   158 			}

   159 			memmove(p2, p2 + 1, strlen(p2));

   160 		}

   161 		if (!p2) {

   162 			conf_warning("invalid string found");

   163 			return 1;

   164 		}

   165 	case S_INT:

   166 	case S_HEX:

   167 	done:

   168 		if (sym_string_valid(sym, p)) {

   169 			sym->def[def].val = strdup(p);

   170 			sym->flags |= def_flags;

   171 		} else {

   172 			conf_warning("symbol value '%s' invalid for %s", p, sym->name);

   173 			return 1;

   174 		}

   175 		break;

   176 	default:

   177 		;

   178 	}

   179 	return 0;

   180 }

   182 int conf_read_simple(const char *name, int def)

   183 {

   184 	FILE *in = NULL;

   185 	char line[1024];

   186 	char *p, *p2;

   187 	struct symbol *sym;

   188 	int i, def_flags;

   190 	if (name) {

   191 		in = zconf_fopen(name);

   192 	} else {

   193 		struct property *prop;

   195 		name = conf_get_configname();

   196 		in = zconf_fopen(name);

   197 		if (in)

   198 			goto load;

   199 		sym_add_change_count(1);

   200 		if (!sym_defconfig_list) {

   201 			if (modules_sym)

   202 				sym_calc_value(modules_sym);

   203 			return 1;

   204 		}

   206 		for_all_defaults(sym_defconfig_list, prop) {

   207 			if (expr_calc_value(prop->visible.expr) == no ||

   208 			    prop->expr->type != E_SYMBOL)

   209 				continue;

   210 			name = conf_expand_value(prop->expr->left.sym->name);

   211 			in = zconf_fopen(name);

   212 			if (in) {

   213 				conf_message(_("using defaults found in %s"),

   214 					 name);

   215 				goto load;

   216 			}

   217 		}

   218 	}

   219 	if (!in)

   220 		return 1;

   222 load:

   223 	conf_filename = name;

   224 	conf_lineno = 0;

   225 	conf_warnings = 0;

   226 	conf_unsaved = 0;

   228 	def_flags = SYMBOL_DEF << def;

   229 	for_all_symbols(i, sym) {

   230 		sym->flags |= SYMBOL_CHANGED;

   231 		sym->flags &= ~(def_flags|SYMBOL_VALID);

   232 		if (sym_is_choice(sym))

   233 			sym->flags |= def_flags;

   234 		switch (sym->type) {

   235 		case S_INT:

   236 		case S_HEX:

   237 		case S_STRING:

   238 			if (sym->def[def].val)

   239 				free(sym->def[def].val);

   240 		default:

   241 			sym->def[def].val = NULL;

   242 			sym->def[def].tri = no;

   243 		}

   244 	}

   246 	while (fgets(line, sizeof(line), in)) {

   247 		conf_lineno++;

   248 		sym = NULL;

   249 		if (line[0] == '#') {

   250 			if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))

   251 				continue;

   252 			p = strchr(line + 2 + strlen(CONFIG_), ' ');

   253 			if (!p)

   254 				continue;

   255 			*p++ = 0;

   256 			if (strncmp(p, "is not set", 10))

   257 				continue;

   258 			if (def == S_DEF_USER) {

   259 				sym = sym_find(line + 2 + strlen(CONFIG_));

   260 				if (!sym) {

   261 					sym_add_change_count(1);

   262 					goto setsym;

   263 				}

   264 			} else {

   265 				sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);

   266 				if (sym->type == S_UNKNOWN)

   267 					sym->type = S_BOOLEAN;

   268 			}

   269 			if (sym->flags & def_flags) {

   270 				conf_warning("override: reassigning to symbol %s", sym->name);

   271 			}

   272 			switch (sym->type) {

   273 			case S_BOOLEAN:

   274 			case S_TRISTATE:

   275 				sym->def[def].tri = no;

   276 				sym->flags |= def_flags;

   277 				break;

   278 			default:

   279 				;

   280 			}

   281 		} else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {

   282 			p = strchr(line + strlen(CONFIG_), '=');

   283 			if (!p)

   284 				continue;

   285 			*p++ = 0;

   286 			p2 = strchr(p, '\n');

   287 			if (p2) {

   288 				*p2-- = 0;

   289 				if (*p2 == '\r')

   290 					*p2 = 0;

   291 			}

   292 			if (def == S_DEF_USER) {

   293 				sym = sym_find(line + strlen(CONFIG_));

   294 				if (!sym) {

   295 					sym_add_change_count(1);

   296 					goto setsym;

   297 				}

   298 			} else {

   299 				sym = sym_lookup(line + strlen(CONFIG_), 0);

   300 				if (sym->type == S_UNKNOWN)

   301 					sym->type = S_OTHER;

   302 			}

   303 			if (sym->flags & def_flags) {

   304 				conf_warning("override: reassigning to symbol %s", sym->name);

   305 			}

   306 			if (conf_set_sym_val(sym, def, def_flags, p))

   307 				continue;

   308 		} else {

   309 			if (line[0] != '\r' && line[0] != '\n')

   310 				conf_warning("unexpected data");

   311 			continue;

   312 		}

   313 setsym:

   314 		if (sym && sym_is_choice_value(sym)) {

   315 			struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));

   316 			switch (sym->def[def].tri) {

   317 			case no:

   318 				break;

   319 			case mod:

   320 				if (cs->def[def].tri == yes) {

   321 					conf_warning("%s creates inconsistent choice state", sym->name);

   322 					cs->flags &= ~def_flags;

   323 				}

   324 				break;

   325 			case yes:

   326 				if (cs->def[def].tri != no)

   327 					conf_warning("override: %s changes choice state", sym->name);

   328 				cs->def[def].val = sym;

   329 				break;

   330 			}

   331 			cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);

   332 		}

   333 	}

   334 	fclose(in);

   336 	if (modules_sym)

   337 		sym_calc_value(modules_sym);

   338 	return 0;

   339 }

   341 int conf_read(const char *name)

   342 {

   343 	struct symbol *sym, *choice_sym;

   344 	struct property *prop;

   345 	struct expr *e;

   346 	int i, flags;

   348 	sym_set_change_count(0);

   350 	if (conf_read_simple(name, S_DEF_USER))

   351 		return 1;

   353 	for_all_symbols(i, sym) {

   354 		sym_calc_value(sym);

   355 		if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))

   356 			goto sym_ok;

   357 		if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {

   358 			/* check that calculated value agrees with saved value */

   359 			switch (sym->type) {

   360 			case S_BOOLEAN:

   361 			case S_TRISTATE:

   362 				if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))

   363 					break;

   364 				if (!sym_is_choice(sym))

   365 					goto sym_ok;

   366 			default:

   367 				if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))

   368 					goto sym_ok;

   369 				break;

   370 			}

   371 		} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))

   372 			/* no previous value and not saved */

   373 			goto sym_ok;

   374 		conf_unsaved++;

   375 		/* maybe print value in verbose mode... */

   376 	sym_ok:

   377 		if (!sym_is_choice(sym))

   378 			continue;

   379 		/* The choice symbol only has a set value (and thus is not new)

   380 		 * if all its visible childs have values.

   381 		 */

   382 		prop = sym_get_choice_prop(sym);

   383 		flags = sym->flags;

   384 		expr_list_for_each_sym(prop->expr, e, choice_sym)

   385 			if (choice_sym->visible != no)

   386 				flags &= choice_sym->flags;

   387 		sym->flags &= flags | ~SYMBOL_DEF_USER;

   388 	}

   390 	for_all_symbols(i, sym) {

   391 		if (sym_has_value(sym) && !sym_is_choice_value(sym)) {

   392 			/* Reset values of generates values, so they'll appear

   393 			 * as new, if they should become visible, but that

   394 			 * doesn't quite work if the Kconfig and the saved

   395 			 * configuration disagree.

   396 			 */

   397 			if (sym->visible == no && !conf_unsaved)

   398 				sym->flags &= ~SYMBOL_DEF_USER;

   399 			switch (sym->type) {

   400 			case S_STRING:

   401 			case S_INT:

   402 			case S_HEX:

   403 				/* Reset a string value if it's out of range */

   404 				if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))

   405 					break;

   406 				sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);

   407 				conf_unsaved++;

   408 				break;

   409 			default:

   410 				break;

   411 			}

   412 		}

   413 	}

   415 	sym_add_change_count(conf_warnings || conf_unsaved);

   417 	return 0;

   418 }

   420 /* Write a S_STRING */

   421 static void conf_write_string(bool headerfile, const char *name,

   422                               const char *str, FILE *out)

   423 {

   424 	int l;

   425 	if (headerfile)

   426 		fprintf(out, "#define %s%s \"", CONFIG_, name);

   427 	else

   428 		fprintf(out, "%s%s=\"", CONFIG_, name);

   430 	while (1) {

   431 		l = strcspn(str, "\"\\");

   432 		if (l) {

   433 			xfwrite(str, l, 1, out);

   434 			str += l;

   435 		}

   436 		if (!*str)

   437 			break;

   438 		fprintf(out, "\\%c", *str++);

   439 	}

   440 	fputs("\"\n", out);

   441 }

   443 static void conf_write_symbol(struct symbol *sym, FILE *out, bool write_no)

   444 {

   445 	const char *str;

   447 	switch (sym->type) {

   448 	case S_BOOLEAN:

   449 	case S_TRISTATE:

   450 		switch (sym_get_tristate_value(sym)) {

   451 		case no:

   452 			if (write_no)

   453 				fprintf(out, "# %s%s is not set\n",

   454 				    CONFIG_, sym->name);

   455 			break;

   456 		case mod:

   457 			fprintf(out, "%s%s=m\n", CONFIG_, sym->name);

   458 			break;

   459 		case yes:

   460 			fprintf(out, "%s%s=y\n", CONFIG_, sym->name);

   461 			break;

   462 		}

   463 		break;

   464 	case S_STRING:

   465 		conf_write_string(false, sym->name, sym_get_string_value(sym), out);

   466 		break;

   467 	case S_HEX:

   468 	case S_INT:

   469 		str = sym_get_string_value(sym);

   470 		fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str);

   471 		break;

   472 	case S_OTHER:

   473 	case S_UNKNOWN:

   474 		break;

   475 	}

   476 }

   478 /*

   479  * Write out a minimal config.

   480  * All values that has default values are skipped as this is redundant.

   481  */

   482 int conf_write_defconfig(const char *filename)

   483 {

   484 	struct symbol *sym;

   485 	struct menu *menu;

   486 	FILE *out;

   488 	out = fopen(filename, "w");

   489 	if (!out)

   490 		return 1;

   492 	sym_clear_all_valid();

   494 	/* Traverse all menus to find all relevant symbols */

   495 	menu = rootmenu.list;

   497 	while (menu != NULL)

   498 	{

   499 		sym = menu->sym;

   500 		if (sym == NULL) {

   501 			if (!menu_is_visible(menu))

   502 				goto next_menu;

   503 		} else if (!sym_is_choice(sym)) {

   504 			sym_calc_value(sym);

   505 			if (!(sym->flags & SYMBOL_WRITE))

   506 				goto next_menu;

   507 			sym->flags &= ~SYMBOL_WRITE;

   508 			/* If we cannot change the symbol - skip */

   509 			if (!sym_is_changable(sym))

   510 				goto next_menu;

   511 			/* If symbol equals to default value - skip */

   512 			if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)

   513 				goto next_menu;

   515 			/*

   516 			 * If symbol is a choice value and equals to the

   517 			 * default for a choice - skip.

   518 			 * But only if value is bool and equal to "y" and

   519 			 * choice is not "optional".

   520 			 * (If choice is "optional" then all values can be "n")

   521 			 */

   522 			if (sym_is_choice_value(sym)) {

   523 				struct symbol *cs;

   524 				struct symbol *ds;

   526 				cs = prop_get_symbol(sym_get_choice_prop(sym));

   527 				ds = sym_choice_default(cs);

   528 				if (!sym_is_optional(cs) && sym == ds) {

   529 					if ((sym->type == S_BOOLEAN) &&

   530 					    sym_get_tristate_value(sym) == yes)

   531 						goto next_menu;

   532 				}

   533 			}

   534 			conf_write_symbol(sym, out, true);

   535 		}

   536 next_menu:

   537 		if (menu->list != NULL) {

   538 			menu = menu->list;

   539 		}

   540 		else if (menu->next != NULL) {

   541 			menu = menu->next;

   542 		} else {

   543 			while ((menu = menu->parent)) {

   544 				if (menu->next != NULL) {

   545 					menu = menu->next;

   546 					break;

   547 				}

   548 			}

   549 		}

   550 	}

   551 	fclose(out);

   552 	return 0;

   553 }

   555 int conf_write(const char *name)

   556 {

   557 	FILE *out;

   558 	struct symbol *sym;

   559 	struct menu *menu;

   560 	const char *basename;

   561 	const char *str;

   562 	char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];

   563 	time_t now;

   564 	int use_timestamp = 1;

   565 	char *env;

   567 	dirname[0] = 0;

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

   569 		struct stat st;

   570 		char *slash;

   572 		if (!stat(name, &st) && S_ISDIR(st.st_mode)) {

   573 			strcpy(dirname, name);

   574 			strcat(dirname, "/");

   575 			basename = conf_get_configname();

   576 		} else if ((slash = strrchr(name, '/'))) {

   577 			int size = slash - name + 1;

   578 			memcpy(dirname, name, size);

   579 			dirname[size] = 0;

   580 			if (slash[1])

   581 				basename = slash + 1;

   582 			else

   583 				basename = conf_get_configname();

   584 		} else

   585 			basename = name;

   586 	} else

   587 		basename = conf_get_configname();

   589 	sprintf(newname, "%s%s", dirname, basename);

   590 	env = getenv("KCONFIG_OVERWRITECONFIG");

   591 	if (!env || !*env) {

   592 		sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());

   593 		out = fopen(tmpname, "w");

   594 	} else {

   595 		*tmpname = 0;

   596 		out = fopen(newname, "w");

   597 	}

   598 	if (!out)

   599 		return 1;

   601 	time(&now);

   602 	env = getenv("KCONFIG_NOTIMESTAMP");

   603 	if (env && *env)

   604 		use_timestamp = 0;

   606 	fprintf(out, _("#\n"

   607 		       "# Automatically generated make config: don't edit\n"

   608 		       "# %s\n"

   609 		       "%s%s"

   610 		       "#\n"),

   611 		     rootmenu.prompt->text,

   612 		     use_timestamp ? "# " : "",

   613 		     use_timestamp ? ctime(&now) : "");

   615 	if (!conf_get_changed())

   616 		sym_clear_all_valid();

   618 	menu = rootmenu.list;

   619 	while (menu) {

   620 		sym = menu->sym;

   621 		if (!sym) {

   622 			if (!menu_is_visible(menu))

   623 				goto next;

   624 			str = menu_get_prompt(menu);

   625 			fprintf(out, "\n"

   626 				     "#\n"

   627 				     "# %s\n"

   628 				     "#\n", str);

   629 		} else if (!(sym->flags & SYMBOL_CHOICE)) {

   630 			sym_calc_value(sym);

   631 			if (!(sym->flags & SYMBOL_WRITE))

   632 				goto next;

   633 			sym->flags &= ~SYMBOL_WRITE;

   634 			/* Write config symbol to file */

   635 			conf_write_symbol(sym, out, true);

   636 		}

   638 next:

   639 		if (menu->list) {

   640 			menu = menu->list;

   641 			continue;

   642 		}

   643 		if (menu->next)

   644 			menu = menu->next;

   645 		else while ((menu = menu->parent)) {

   646 			if (menu->next) {

   647 				menu = menu->next;

   648 				break;

   649 			}

   650 		}

   651 	}

   652 	fclose(out);

   654 	if (*tmpname) {

   655 		strcat(dirname, basename);

   656 		strcat(dirname, ".old");

   657 		rename(newname, dirname);

   658 		if (rename(tmpname, newname))

   659 			return 1;

   660 	}

   662 	conf_message(_("configuration saved"));

   664 	sym_set_change_count(0);

   666 	return 0;

   667 }

   669 static int conf_split_config(void)

   670 {

   671 	const char *name;

   672 	char path[PATH_MAX+1];

   673 	char *s, *d, c;

   674 	struct symbol *sym;

   675 	struct stat sb;

   676 	int res, i, fd;

   678 	name = conf_get_autoconfig_name();

   679 	conf_read_simple(name, S_DEF_AUTO);

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

   682 		return 1;

   684 	res = 0;

   685 	for_all_symbols(i, sym) {

   686 		sym_calc_value(sym);

   687 		if ((sym->flags & SYMBOL_AUTO) || !sym->name)

   688 			continue;

   689 		if (sym->flags & SYMBOL_WRITE) {

   690 			if (sym->flags & SYMBOL_DEF_AUTO) {

   691 				/*

   692 				 * symbol has old and new value,

   693 				 * so compare them...

   694 				 */

   695 				switch (sym->type) {

   696 				case S_BOOLEAN:

   697 				case S_TRISTATE:

   698 					if (sym_get_tristate_value(sym) ==

   699 					    sym->def[S_DEF_AUTO].tri)

   700 						continue;

   701 					break;

   702 				case S_STRING:

   703 				case S_HEX:

   704 				case S_INT:

   705 					if (!strcmp(sym_get_string_value(sym),

   706 						    sym->def[S_DEF_AUTO].val))

   707 						continue;

   708 					break;

   709 				default:

   710 					break;

   711 				}

   712 			} else {

   713 				/*

   714 				 * If there is no old value, only 'no' (unset)

   715 				 * is allowed as new value.

   716 				 */

   717 				switch (sym->type) {

   718 				case S_BOOLEAN:

   719 				case S_TRISTATE:

   720 					if (sym_get_tristate_value(sym) == no)

   721 						continue;

   722 					break;

   723 				default:

   724 					break;

   725 				}

   726 			}

   727 		} else if (!(sym->flags & SYMBOL_DEF_AUTO))

   728 			/* There is neither an old nor a new value. */

   729 			continue;

   730 		/* else

   731 		 *	There is an old value, but no new value ('no' (unset)

   732 		 *	isn't saved in auto.conf, so the old value is always

   733 		 *	different from 'no').

   734 		 */

   736 		/* Replace all '_' and append ".h" */

   737 		s = sym->name;

   738 		d = path;

   739 		while ((c = *s++)) {

   740 			c = tolower(c);

   741 			*d++ = (c == '_') ? '/' : c;

   742 		}

   743 		strcpy(d, ".h");

   745 		/* Assume directory path already exists. */

   746 		fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);

   747 		if (fd == -1) {

   748 			if (errno != ENOENT) {

   749 				res = 1;

   750 				break;

   751 			}

   752 			/*

   753 			 * Create directory components,

   754 			 * unless they exist already.

   755 			 */

   756 			d = path;

   757 			while ((d = strchr(d, '/'))) {

   758 				*d = 0;

   759 				if (stat(path, &sb) && mkdir(path, 0755)) {

   760 					res = 1;

   761 					goto out;

   762 				}

   763 				*d++ = '/';

   764 			}

   765 			/* Try it again. */

   766 			fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);

   767 			if (fd == -1) {

   768 				res = 1;

   769 				break;

   770 			}

   771 		}

   772 		close(fd);

   773 	}

   774 out:

   775 	if (chdir("../.."))

   776 		return 1;

   778 	return res;

   779 }

   781 int conf_write_autoconf(void)

   782 {

   783 	struct symbol *sym;

   784 	const char *str;

   785 	const char *name;

   786 	FILE *out, *tristate, *out_h;

   787 	int i;

   789 	sym_clear_all_valid();

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

   793 	if (conf_split_config())

   794 		return 1;

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

   797 	if (!out)

   798 		return 1;

   800 	tristate = fopen(".tmpconfig_tristate", "w");

   801 	if (!tristate) {

   802 		fclose(out);

   803 		return 1;

   804 	}

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

   807 	if (!out_h) {

   808 		fclose(out);

   809 		fclose(tristate);

   810 		return 1;

   811 	}

   813 	fprintf(out, "#\n"

   814 		     "# Automatically generated make config: don't edit\n"

   815 		     "# %s\n"

   816 		     "#\n",

   817 		     rootmenu.prompt->text);

   818 	fprintf(tristate, "#\n"

   819 			  "# Automatically generated - do not edit\n"

   820 			  "\n");

   821 	fprintf(out_h, "/*\n"

   822 		       " * Automatically generated C config: don't edit\n"

   823 		       " * %s\n"

   824 		       " */\n",

   825 		       rootmenu.prompt->text);

   827 	for_all_symbols(i, sym) {

   828 		sym_calc_value(sym);

   829 		if (!(sym->flags & SYMBOL_WRITE) || !sym->name)

   830 			continue;

   832 		/* write symbol to config file */

   833 		conf_write_symbol(sym, out, false);

   835 		/* update autoconf and tristate files */

   836 		switch (sym->type) {

   837 		case S_BOOLEAN:

   838 		case S_TRISTATE:

   839 			switch (sym_get_tristate_value(sym)) {

   840 			case no:

   841 				break;

   842 			case mod:

   843 				fprintf(tristate, "%s%s=M\n",

   844 				    CONFIG_, sym->name);

   845 				fprintf(out_h, "#define %s%s_MODULE 1\n",

   846 				    CONFIG_, sym->name);

   847 				break;

   848 			case yes:

   849 				if (sym->type == S_TRISTATE)

   850 					fprintf(tristate,"%s%s=Y\n",

   851 					    CONFIG_, sym->name);

   852 				fprintf(out_h, "#define %s%s 1\n",

   853 				    CONFIG_, sym->name);

   854 				break;

   855 			}

   856 			break;

   857 		case S_STRING:

   858 			conf_write_string(true, sym->name, sym_get_string_value(sym), out_h);

   859 			break;

   860 		case S_HEX:

   861 			str = sym_get_string_value(sym);

   862 			if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {

   863 				fprintf(out_h, "#define %s%s 0x%s\n",

   864 				    CONFIG_, sym->name, str);

   865 				break;

   866 			}

   867 		case S_INT:

   868 			str = sym_get_string_value(sym);

   869 			fprintf(out_h, "#define %s%s %s\n",

   870 			    CONFIG_, sym->name, str);

   871 			break;

   872 		default:

   873 			break;

   874 		}

   875 	}

   876 	fclose(out);

   877 	fclose(tristate);

   878 	fclose(out_h);

   880 	name = getenv("KCONFIG_AUTOHEADER");

   881 	if (!name)

   882 		name = "include/generated/autoconf.h";

   883 	if (rename(".tmpconfig.h", name))

   884 		return 1;

   885 	name = getenv("KCONFIG_TRISTATE");

   886 	if (!name)

   887 		name = "include/config/tristate.conf";

   888 	if (rename(".tmpconfig_tristate", name))

   889 		return 1;

   890 	name = conf_get_autoconfig_name();

   891 	/*

   892 	 * This must be the last step, kbuild has a dependency on auto.conf

   893 	 * and this marks the successful completion of the previous steps.

   894 	 */

   895 	if (rename(".tmpconfig", name))

   896 		return 1;

   898 	return 0;

   899 }

   901 static int sym_change_count;

   902 static void (*conf_changed_callback)(void);

   904 void sym_set_change_count(int count)

   905 {

   906 	int _sym_change_count = sym_change_count;

   907 	sym_change_count = count;

   908 	if (conf_changed_callback &&

   909 	    (bool)_sym_change_count != (bool)count)

   910 		conf_changed_callback();

   911 }

   913 void sym_add_change_count(int count)

   914 {

   915 	sym_set_change_count(count + sym_change_count);

   916 }

   918 bool conf_get_changed(void)

   919 {

   920 	return sym_change_count;

   921 }

   923 void conf_set_changed_callback(void (*fn)(void))

   924 {

   925 	conf_changed_callback = fn;

   926 }

   928 static void randomize_choice_values(struct symbol *csym)

   929 {

   930 	struct property *prop;

   931 	struct symbol *sym;

   932 	struct expr *e;

   933 	int cnt, def;

   935 	/*

   936 	 * If choice is mod then we may have more items selected

   937 	 * and if no then no-one.

   938 	 * In both cases stop.

   939 	 */

   940 	if (csym->curr.tri != yes)

   941 		return;

   943 	prop = sym_get_choice_prop(csym);

   945 	/* count entries in choice block */

   946 	cnt = 0;

   947 	expr_list_for_each_sym(prop->expr, e, sym)

   948 		cnt++;

   950 	/*

   951 	 * find a random value and set it to yes,

   952 	 * set the rest to no so we have only one set

   953 	 */

   954 	def = (rand() % cnt);

   956 	cnt = 0;

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

   958 		if (def == cnt++) {

   959 			sym->def[S_DEF_USER].tri = yes;

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

   961 		}

   962 		else {

   963 			sym->def[S_DEF_USER].tri = no;

   964 		}

   965 	}

   966 	csym->flags |= SYMBOL_DEF_USER;

   967 	/* clear VALID to get value calculated */

   968 	csym->flags &= ~(SYMBOL_VALID);

   969 }

   971 static void set_all_choice_values(struct symbol *csym)

   972 {

   973 	struct property *prop;

   974 	struct symbol *sym;

   975 	struct expr *e;

   977 	prop = sym_get_choice_prop(csym);

   979 	/*

   980 	 * Set all non-assinged choice values to no

   981 	 */

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

   983 		if (!sym_has_value(sym))

   984 			sym->def[S_DEF_USER].tri = no;

   985 	}

   986 	csym->flags |= SYMBOL_DEF_USER;

   987 	/* clear VALID to get value calculated */

   988 	csym->flags &= ~(SYMBOL_VALID);

   989 }

   991 void conf_set_all_new_symbols(enum conf_def_mode mode)

   992 {

   993 	struct symbol *sym, *csym;

   994 	int i, cnt;

   996 	for_all_symbols(i, sym) {

   997 		if (sym_has_value(sym))

   998 			continue;

   999 		switch (sym_get_type(sym)) {

  1000 		case S_BOOLEAN:

  1001 		case S_TRISTATE:

  1002 			switch (mode) {

  1003 			case def_yes:

  1004 				sym->def[S_DEF_USER].tri = yes;

  1005 				break;

  1006 			case def_mod:

  1007 				sym->def[S_DEF_USER].tri = mod;

  1008 				break;

  1009 			case def_no:

  1010 				sym->def[S_DEF_USER].tri = no;

  1011 				break;

  1012 			case def_random:

  1013 				cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2;

  1014 				sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt);

  1015 				break;

  1016 			default:

  1017 				continue;

  1018 			}

  1019 			if (!(sym_is_choice(sym) && mode == def_random))

  1020 				sym->flags |= SYMBOL_DEF_USER;

  1021 			break;

  1022 		default:

  1023 			break;

  1024 		}

  1026 	}

  1028 	sym_clear_all_valid();

  1030 	/*

  1031 	 * We have different type of choice blocks.

  1032 	 * If curr.tri equals to mod then we can select several

  1033 	 * choice symbols in one block.

  1034 	 * In this case we do nothing.

  1035 	 * If curr.tri equals yes then only one symbol can be

  1036 	 * selected in a choice block and we set it to yes,

  1037 	 * and the rest to no.

  1038 	 */

  1039 	for_all_symbols(i, csym) {

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

  1041 			continue;

  1043 		sym_calc_value(csym);

  1044 		if (mode == def_random)

  1045 			randomize_choice_values(csym);

  1046 		else

  1047 			set_all_choice_values(csym);

  1048 	}

  1049 }

author	"Yann E. MORIN" <yann.morin.1998@free.fr>
	Sun May 11 17:51:33 2014 +0200 (2014-05-11)
changeset 3317	6b2c4692f132
parent 2448	a103abae1560
permissions	-rw-r--r--