crosstool-ng: kconfig/confdata.c@d80e6dedcc13

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

    11 #include <stdio.h>

    12 #include <stdlib.h>

    13 #include <string.h>

    14 #include <time.h>

    15 #include <unistd.h>

    17 #define LKC_DIRECT_LINK

    18 #include "lkc.h"

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

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

    23 static const char *conf_filename;

    24 static int conf_lineno, conf_warnings, conf_unsaved;

    26 #ifndef conf_defname

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

    28 #endif

    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 const char *conf_get_configname(void)

    42 {

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

    45 	return name ? name : ".config";

    46 }

    48 static char *conf_expand_value(const char *in)

    49 {

    50 	struct symbol *sym;

    51 	const char *src;

    52 	static char res_value[SYMBOL_MAXLENGTH];

    53 	char *dst, name[SYMBOL_MAXLENGTH];

    55 	res_value[0] = 0;

    56 	dst = name;

    57 	while ((src = strchr(in, '$'))) {

    58 		strncat(res_value, in, src - in);

    59 		src++;

    60 		dst = name;

    61 		while (isalnum(*src) || *src == '_')

    62 			*dst++ = *src++;

    63 		*dst = 0;

    64 		sym = sym_lookup(name, 0);

    65 		sym_calc_value(sym);

    66 		strcat(res_value, sym_get_string_value(sym));

    67 		in = src;

    68 	}

    69 	strcat(res_value, in);

    71 	return res_value;

    72 }

    74 char *conf_get_default_confname(void)

    75 {

    76 	struct stat buf;

    77 	static char fullname[PATH_MAX+1];

    78 	char *env, *name;

    80 	name = conf_expand_value(conf_defname);

    81 	env = getenv(SRCTREE);

    82 	if (env) {

    83 		sprintf(fullname, "%s/%s", env, name);

    84 		if (!stat(fullname, &buf))

    85 			return fullname;

    86 	}

    87 	return name;

    88 }

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

    91 {

    92 	FILE *in = NULL;

    93 	char line[1024];

    94 	char *p, *p2;

    95 	struct symbol *sym;

    96 	int i, def_flags;

    98 	if (name) {

    99 		in = zconf_fopen(name);

   100 	} else {

   101 		struct property *prop;

   103 		name = conf_get_configname();

   104 		in = zconf_fopen(name);

   105 		if (in)

   106 			goto load;

   107 		sym_change_count++;

   108 		if (!sym_defconfig_list)

   109 			return 1;

   111 		for_all_defaults(sym_defconfig_list, prop) {

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

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

   114 				continue;

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

   116 			in = zconf_fopen(name);

   117 			if (in) {

   118 				printf(_("#\n"

   119 					 "# using defaults found in %s\n"

   120 					 "#\n"), name);

   121 				goto load;

   122 			}

   123 		}

   124 	}

   125 	if (!in)

   126 		return 1;

   128 load:

   129 	conf_filename = name;

   130 	conf_lineno = 0;

   131 	conf_warnings = 0;

   132 	conf_unsaved = 0;

   134 	def_flags = SYMBOL_DEF << def;

   135 	for_all_symbols(i, sym) {

   136 		sym->flags |= SYMBOL_CHANGED;

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

   138 		if (sym_is_choice(sym))

   139 			sym->flags |= def_flags;

   140 		switch (sym->type) {

   141 		case S_INT:

   142 		case S_HEX:

   143 		case S_STRING:

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

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

   146 		default:

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

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

   149 		}

   150 	}

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

   153 		conf_lineno++;

   154 		sym = NULL;

   155 		switch (line[0]) {

   156 		case '#':

   157 			if (memcmp(line + 2, "CT_", 3))

   158 				continue;

   159 			p = strchr(line + 5, ' ');

   160 			if (!p)

   161 				continue;

   162 			*p++ = 0;

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

   164 				continue;

   165 			if (def == S_DEF_USER) {

   166 				sym = sym_find(line + 5);

   167 				if (!sym) {

   168 					conf_warning("trying to assign nonexistent symbol %s", line + 5);

   169 					break;

   170 				}

   171 			} else {

   172 				sym = sym_lookup(line + 5, 0);

   173 				if (sym->type == S_UNKNOWN)

   174 					sym->type = S_BOOLEAN;

   175 			}

   176 			if (sym->flags & def_flags) {

   177 				conf_warning("trying to reassign symbol %s", sym->name);

   178 				break;

   179 			}

   180 			switch (sym->type) {

   181 			case S_BOOLEAN:

   182 			case S_TRISTATE:

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

   184 				sym->flags |= def_flags;

   185 				break;

   186 			default:

   187 				;

   188 			}

   189 			break;

   190 		case 'C':

   191 			if (memcmp(line, "CT_", 3)) {

   192 				conf_warning("unexpected data");

   193 				continue;

   194 			}

   195 			p = strchr(line + 3, '=');

   196 			if (!p)

   197 				continue;

   198 			*p++ = 0;

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

   200 			if (p2) {

   201 				*p2-- = 0;

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

   203 					*p2 = 0;

   204 			}

   205 			if (def == S_DEF_USER) {

   206 				sym = sym_find(line + 3);

   207 				if (!sym) {

   208 					conf_warning("trying to assign nonexistent symbol %s", line + 3);

   209 					break;

   210 				}

   211 			} else {

   212 				sym = sym_lookup(line + 3, 0);

   213 				if (sym->type == S_UNKNOWN)

   214 					sym->type = S_OTHER;

   215 			}

   216 			if (sym->flags & def_flags) {

   217 				conf_warning("trying to reassign symbol %s", sym->name);

   218 				break;

   219 			}

   220 			switch (sym->type) {

   221 			case S_TRISTATE:

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

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

   224 					sym->flags |= def_flags;

   225 					break;

   226 				}

   227 			case S_BOOLEAN:

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

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

   230 					sym->flags |= def_flags;

   231 					break;

   232 				}

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

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

   235 					sym->flags |= def_flags;

   236 					break;

   237 				}

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

   239 				break;

   240 			case S_OTHER:

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

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

   243 						;

   244 					sym->type = S_STRING;

   245 					goto done;

   246 				}

   247 			case S_STRING:

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

   249 					break;

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

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

   252 						*p2 = 0;

   253 						break;

   254 					}

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

   256 				}

   257 				if (!p2) {

   258 					conf_warning("invalid string found");

   259 					continue;

   260 				}

   261 			case S_INT:

   262 			case S_HEX:

   263 			done:

   264 				if (sym_string_valid(sym, p)) {

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

   266 					sym->flags |= def_flags;

   267 				} else {

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

   269 					continue;

   270 				}

   271 				break;

   272 			default:

   273 				;

   274 			}

   275 			break;

   276 		case '\r':

   277 		case '\n':

   278 			break;

   279 		default:

   280 			conf_warning("unexpected data");

   281 			continue;

   282 		}

   283 		if (sym && sym_is_choice_value(sym)) {

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

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

   286 			case no:

   287 				break;

   288 			case mod:

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

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

   291 					cs->flags &= ~def_flags;

   292 				}

   293 				break;

   294 			case yes:

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

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

   297 					cs->flags &= ~def_flags;

   298 				} else

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

   300 				break;

   301 			}

   302 			cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].tri);

   303 		}

   304 	}

   305 	fclose(in);

   307 	if (modules_sym)

   308 		sym_calc_value(modules_sym);

   309 	return 0;

   310 }

   312 int conf_read(const char *name)

   313 {

   314 	struct symbol *sym;

   315 	struct property *prop;

   316 	struct expr *e;

   317 	int i, flags;

   319 	sym_change_count = 0;

   321 	if (conf_read_simple(name, S_DEF_USER))

   322 		return 1;

   324 	for_all_symbols(i, sym) {

   325 		sym_calc_value(sym);

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

   327 			goto sym_ok;

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

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

   330 			switch (sym->type) {

   331 			case S_BOOLEAN:

   332 			case S_TRISTATE:

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

   334 					break;

   335 				if (!sym_is_choice(sym))

   336 					goto sym_ok;

   337 			default:

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

   339 					goto sym_ok;

   340 				break;

   341 			}

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

   343 			/* no previous value and not saved */

   344 			goto sym_ok;

   345 		conf_unsaved++;

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

   347 	sym_ok:

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

   349 			if (sym->visible == no)

   350 				sym->flags &= ~SYMBOL_DEF_USER;

   351 			switch (sym->type) {

   352 			case S_STRING:

   353 			case S_INT:

   354 			case S_HEX:

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

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

   357 			default:

   358 				break;

   359 			}

   360 		}

   361 		if (!sym_is_choice(sym))

   362 			continue;

   363 		prop = sym_get_choice_prop(sym);

   364 		flags = sym->flags;

   365 		for (e = prop->expr; e; e = e->left.expr)

   366 			if (e->right.sym->visible != no)

   367 				flags &= e->right.sym->flags;

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

   369 	}

   371 	sym_change_count += conf_warnings || conf_unsaved;

   373 	return 0;

   374 }

   376 struct menu *next_menu(struct menu *menu)

   377 {

   378 	if (menu->list) return menu->list;

   379 	do {

   380 		if (menu->next) {

   381 			menu = menu->next;

   382 			break;

   383 		}

   384 	} while ((menu = menu->parent));

   386 	return menu;

   387 }

   389 #define SYMBOL_FORCEWRITE (1<<31)

   391 int conf_write(const char *name)

   392 {

   393 	FILE *out;

   394 	struct symbol *sym;

   395 	struct menu *menu;

   396 	const char *basename;

   397 	char dirname[128], tmpname[128], newname[128];

   398 	int type, l, writetype;

   399 	const char *str;

   400 	time_t now;

   401 	int use_timestamp = 1;

   402 	char *env;

   404 	dirname[0] = 0;

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

   406 		struct stat st;

   407 		char *slash;

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

   410 			strcpy(dirname, name);

   411 			strcat(dirname, "/");

   412 			basename = conf_get_configname();

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

   414 			int size = slash - name + 1;

   415 			memcpy(dirname, name, size);

   416 			dirname[size] = 0;

   417 			if (slash[1])

   418 				basename = slash + 1;

   419 			else

   420 				basename = conf_get_configname();

   421 		} else

   422 			basename = name;

   423 	} else

   424 		basename = conf_get_configname();

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

   427 	env = getenv("KCONFIG_OVERWRITECONFIG");

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

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

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

   431 	} else {

   432 		*tmpname = 0;

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

   434 	}

   435 	if (!out)

   436 		return 1;

   438 	sym = sym_lookup("PROJECTVERSION", 0);

   439 	sym_calc_value(sym);

   440 	time(&now);

   441 	env = getenv("KCONFIG_NOTIMESTAMP");

   442 	if (env && *env)

   443 		use_timestamp = 0;

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

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

   447 		       "# "PROJECT_NAME" version: %s\n"

   448 		       "%s%s"

   449 		       "#\n"),

   450 		     sym_get_string_value(sym),

   451 		     use_timestamp ? "# " : "",

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

   454 	if (!sym_change_count)

   455 		sym_clear_all_valid();

   457 	// Write out all symbols (even in closed sub-menus).

   458 	if (1) {

   459 		for (menu = rootmenu.list; menu; menu = next_menu(menu))

   460 			if (menu->sym) menu->sym->flags |= SYMBOL_FORCEWRITE;

   461 		writetype = SYMBOL_FORCEWRITE;

   463 	// Don't write  out symbols in closed menus.

   465 	} else writetype = SYMBOL_WRITE;

   468 	menu = rootmenu.list;

   469 	while (menu) {

   470 		sym = menu->sym;

   471 		if (!sym) {

   472 			if (!menu_is_visible(menu))

   473 				goto next;

   474 			str = menu_get_prompt(menu);

   475 			fprintf(out, "\n"

   476 				     "#\n"

   477 				     "# %s\n"

   478 				     "#\n", str);

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

   480 			sym_calc_value(sym);

   481 			if (!(sym->flags & writetype))

   482 				goto next;

   483 			sym->flags &= ~writetype;

   484 			type = sym->type;

   485 			if (type == S_TRISTATE) {

   486 				sym_calc_value(modules_sym);

   487 				if (modules_sym->curr.tri == no)

   488 					type = S_BOOLEAN;

   489 			}

   490 			switch (type) {

   491 			case S_BOOLEAN:

   492 			case S_TRISTATE:

   493 				switch (sym_get_tristate_value(sym)) {

   494 				case no:

   495 					fprintf(out, "# CT_%s is not set\n", sym->name);

   496 					break;

   497 				case mod:

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

   499 					break;

   500 				case yes:

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

   502 					break;

   503 				}

   504 				break;

   505 			case S_STRING:

   506 				str = sym_get_string_value(sym);

   507 				fprintf(out, "CT_%s=\"", sym->name);

   508 				while (1) {

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

   510 					if (l) {

   511 						fwrite(str, l, 1, out);

   512 						str += l;

   513 					}

   514 					if (!*str)

   515 						break;

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

   517 				}

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

   519 				break;

   520 			case S_HEX:

   521 				str = sym_get_string_value(sym);

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

   523 					fprintf(out, "CT_%s=%s\n", sym->name, *str ? str : "0");

   524 					break;

   525 				}

   526 			case S_INT:

   527 				str = sym_get_string_value(sym);

   528 				fprintf(out, "CT_%s=%s\n", sym->name, *str ? str : "0");

   529 				break;

   530 			}

   531 		}

   533 	next:

   534 		if (writetype == SYMBOL_WRITE) {

   535 			if (menu->list) {

   536 				menu = menu->list;

   537 				continue;

   538 			}

   539 			if (menu->next)

   540 				menu = menu->next;

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

   542 				if (menu->next) {

   543 					menu = menu->next;

   544 					break;

   545 				}

   546 			}

   547 		} else

   548 			menu = next_menu(menu);

   549 	}

   550 	fclose(out);

   552 	if (*tmpname) {

   553 		strcat(dirname, basename);

   554 		strcat(dirname, ".old");

   555 		rename(newname, dirname);

   556 		if (rename(tmpname, newname))

   557 			return 1;

   558 	}

   560 	printf(_("#\n"

   561 		 "# configuration written to %s\n"

   562 		 "#\n"), newname);

   564 	sym_change_count = 0;

   566 	return 0;

   567 }

   569 int conf_split_config(void)

   570 {

   571 	char *name, path[128];

   572 	char *s, *d, c;

   573 	struct symbol *sym;

   574 	struct stat sb;

   575 	int res, i, fd;

   577 	name = getenv("KCONFIG_AUTOCONFIG");

   578 	if (!name)

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

   580 	conf_read_simple(name, S_DEF_AUTO);

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

   583 		return 1;

   585 	res = 0;

   586 	for_all_symbols(i, sym) {

   587 		sym_calc_value(sym);

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

   589 			continue;

   590 		if (sym->flags & SYMBOL_WRITE) {

   591 			if (sym->flags & SYMBOL_DEF_AUTO) {

   592 				/*

   593 				 * symbol has old and new value,

   594 				 * so compare them...

   595 				 */

   596 				switch (sym->type) {

   597 				case S_BOOLEAN:

   598 				case S_TRISTATE:

   599 					if (sym_get_tristate_value(sym) ==

   600 					    sym->def[S_DEF_AUTO].tri)

   601 						continue;

   602 					break;

   603 				case S_STRING:

   604 				case S_HEX:

   605 				case S_INT:

   606 					if (!strcmp(sym_get_string_value(sym),

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

   608 						continue;

   609 					break;

   610 				default:

   611 					break;

   612 				}

   613 			} else {

   614 				/*

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

   616 				 * is allowed as new value.

   617 				 */

   618 				switch (sym->type) {

   619 				case S_BOOLEAN:

   620 				case S_TRISTATE:

   621 					if (sym_get_tristate_value(sym) == no)

   622 						continue;

   623 					break;

   624 				default:

   625 					break;

   626 				}

   627 			}

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

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

   630 			continue;

   631 		/* else

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

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

   634 		 *	different from 'no').

   635 		 */

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

   638 		s = sym->name;

   639 		d = path;

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

   641 			c = tolower(c);

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

   643 		}

   644 		strcpy(d, ".h");

   646 		/* Assume directory path already exists. */

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

   648 		if (fd == -1) {

   649 			if (errno != ENOENT) {

   650 				res = 1;

   651 				break;

   652 			}

   653 			/*

   654 			 * Create directory components,

   655 			 * unless they exist already.

   656 			 */

   657 			d = path;

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

   659 				*d = 0;

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

   661 					res = 1;

   662 					goto out;

   663 				}

   664 				*d++ = '/';

   665 			}

   666 			/* Try it again. */

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

   668 			if (fd == -1) {

   669 				res = 1;

   670 				break;

   671 			}

   672 		}

   673 		close(fd);

   674 	}

   675 out:

   676 	if (chdir("../.."))

   677 		return 1;

   679 	return res;

   680 }

   682 int conf_write_autoconf(void)

   683 {

   684 	struct symbol *sym;

   685 	const char *str;

   686 	char *name;

   687 	FILE *out, *out_h;

   688 	time_t now;

   689 	int i, l;

   691 	sym_clear_all_valid();

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

   695 	if (conf_split_config())

   696 		return 1;

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

   699 	if (!out)

   700 		return 1;

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

   703 	if (!out_h) {

   704 		fclose(out);

   705 		return 1;

   706 	}

   708 	sym = sym_lookup("PROJECTVERSION", 0);

   709 	sym_calc_value(sym);

   710 	time(&now);

   711 	fprintf(out, "#\n"

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

   713 		     "# "PROJECT_NAME" version: %s\n"

   714 		     "# %s"

   715 		     "#\n",

   716 		     sym_get_string_value(sym), ctime(&now));

   717 	fprintf(out_h, "/*\n"

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

   719 		       " * "PROJECT_NAME" version: %s\n"

   720 		       " * %s"

   721 		       " */\n"

   722 		       "#define AUTOCONF_INCLUDED\n",

   723 		       sym_get_string_value(sym), ctime(&now));

   725 	for_all_symbols(i, sym) {

   726 		sym_calc_value(sym);

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

   728 			continue;

   729 		switch (sym->type) {

   730 		case S_BOOLEAN:

   731 		case S_TRISTATE:

   732 			switch (sym_get_tristate_value(sym)) {

   733 			case no:

   734 				break;

   735 			case mod:

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

   737 				fprintf(out_h, "#define CT_%s_MODULE 1\n", sym->name);

   738 				break;

   739 			case yes:

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

   741 				fprintf(out_h, "#define CT_%s 1\n", sym->name);

   742 				break;

   743 			}

   744 			break;

   745 		case S_STRING:

   746 			str = sym_get_string_value(sym);

   747 			fprintf(out, "CT_%s=\"", sym->name);

   748 			fprintf(out_h, "#define CT_%s \"", sym->name);

   749 			while (1) {

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

   751 				if (l) {

   752 					fwrite(str, l, 1, out);

   753 					fwrite(str, l, 1, out_h);

   754 					str += l;

   755 				}

   756 				if (!*str)

   757 					break;

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

   759 				fprintf(out_h, "\\%c", *str);

   760 				str++;

   761 			}

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

   763 			fputs("\"\n", out_h);

   764 			break;

   765 		case S_HEX:

   766 			str = sym_get_string_value(sym);

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

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

   769 				fprintf(out_h, "#define CT_%s 0x%s\n", sym->name, str);

   770 				break;

   771 			}

   772 		case S_INT:

   773 			str = sym_get_string_value(sym);

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

   775 			fprintf(out_h, "#define CT_%s %s\n", sym->name, str);

   776 			break;

   777 		default:

   778 			break;

   779 		}

   780 	}

   781 	fclose(out);

   782 	fclose(out_h);

   784 	name = getenv("KCONFIG_AUTOHEADER");

   785 	if (!name)

   786 		name = "include/linux/autoconf.h";

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

   788 		return 1;

   789 	name = getenv("KCONFIG_AUTOCONFIG");

   790 	if (!name)

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

   792 	/*

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

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

   795 	 */

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

   797 		return 1;

   799 	return 0;

   800 }

author	"Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>
	Mon Mar 12 18:59:31 2007 +0000 (2007-03-12)
changeset 19	d80e6dedcc13
child 39	af42eec9d383
permissions	-rw-r--r--