[net-next-2.6.git] / scripts / kconfig / confdata.c

/*
 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
 * Released under the terms of the GNU GPL v2.0.
 */

#include <sys/stat.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define LKC_DIRECT_LINK
#include "lkc.h"

static void conf_warning(const char *fmt, ...)
	__attribute__ ((format (printf, 1, 2)));

static const char *conf_filename;
static int conf_lineno, conf_warnings, conf_unsaved;

const char conf_def_filename[] = ".config";

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

const char *conf_confnames[] = {
	".config",
	"/lib/modules/$UNAME_RELEASE/.config",
	"/etc/kernel-config",
	"/boot/config-$UNAME_RELEASE",
	conf_defname,
	NULL,
};

static void conf_warning(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, "\n");
	va_end(ap);
	conf_warnings++;
}

static char *conf_expand_value(const char *in)
{
	struct symbol *sym;
	const char *src;
	static char res_value[SYMBOL_MAXLENGTH];
	char *dst, name[SYMBOL_MAXLENGTH];

	res_value[0] = 0;
	dst = name;
	while ((src = strchr(in, '$'))) {
		strncat(res_value, in, src - in);
		src++;
		dst = name;
		while (isalnum(*src) || *src == '_')
			*dst++ = *src++;
		*dst = 0;
		sym = sym_lookup(name, 0);
		sym_calc_value(sym);
		strcat(res_value, sym_get_string_value(sym));
		in = src;
	}
	strcat(res_value, in);

	return res_value;
}

char *conf_get_default_confname(void)
{
	struct stat buf;
	static char fullname[PATH_MAX+1];
	char *env, *name;

	name = conf_expand_value(conf_defname);
	env = getenv(SRCTREE);
	if (env) {
		sprintf(fullname, "%s/%s", env, name);
		if (!stat(fullname, &buf))
			return fullname;
	}
	return name;
}

int conf_read_simple(const char *name)
{
	FILE *in = NULL;
	char line[1024];
	char *p, *p2;
	struct symbol *sym;
	int i;

	if (name) {
		in = zconf_fopen(name);
	} else {
		const char **names = conf_confnames;
		name = *names++;
		if (!name)
			return 1;
		in = zconf_fopen(name);
		if (in)
			goto load;
		sym_change_count++;
		while ((name = *names++)) {
			name = conf_expand_value(name);
			in = zconf_fopen(name);
			if (in) {
				printf(_("#\n"
					 "# using defaults found in %s\n"
					 "#\n"), name);
				goto load;
			}
		}
	}
	if (!in)
		return 1;

load:
	conf_filename = name;
	conf_lineno = 0;
	conf_warnings = 0;
	conf_unsaved = 0;

	for_all_symbols(i, sym) {
		sym->flags |= SYMBOL_NEW | SYMBOL_CHANGED;
		if (sym_is_choice(sym))
			sym->flags &= ~SYMBOL_NEW;
		sym->flags &= ~SYMBOL_VALID;
		switch (sym->type) {
		case S_INT:
		case S_HEX:
		case S_STRING:
			if (sym->user.val)
				free(sym->user.val);
		default:
			sym->user.val = NULL;
			sym->user.tri = no;
		}
	}

	while (fgets(line, sizeof(line), in)) {
		conf_lineno++;
		sym = NULL;
		switch (line[0]) {
		case '#':
			if (memcmp(line + 2, "CONFIG_", 7))
				continue;
			p = strchr(line + 9, ' ');
			if (!p)
				continue;
			*p++ = 0;
			if (strncmp(p, "is not set", 10))
				continue;
			sym = sym_find(line + 9);
			if (!sym) {
				conf_warning("trying to assign nonexistent symbol %s", line + 9);
				break;
			} else if (!(sym->flags & SYMBOL_NEW)) {
				conf_warning("trying to reassign symbol %s", sym->name);
				break;
			}
			switch (sym->type) {
			case S_BOOLEAN:
			case S_TRISTATE:
				sym->user.tri = no;
				sym->flags &= ~SYMBOL_NEW;
				break;
			default:
				;
			}
			break;
		case 'C':
			if (memcmp(line, "CONFIG_", 7)) {
				conf_warning("unexpected data");
				continue;
			}
			p = strchr(line + 7, '=');
			if (!p)
				continue;
			*p++ = 0;
			p2 = strchr(p, '\n');
			if (p2)
				*p2 = 0;
			sym = sym_find(line + 7);
			if (!sym) {
				conf_warning("trying to assign nonexistent symbol %s", line + 7);
				break;
			} else if (!(sym->flags & SYMBOL_NEW)) {
				conf_warning("trying to reassign symbol %s", sym->name);
				break;
			}
			switch (sym->type) {
			case S_TRISTATE:
				if (p[0] == 'm') {
					sym->user.tri = mod;
					sym->flags &= ~SYMBOL_NEW;
					break;
				}
			case S_BOOLEAN:
				if (p[0] == 'y') {
					sym->user.tri = yes;
					sym->flags &= ~SYMBOL_NEW;
					break;
				}
				if (p[0] == 'n') {
					sym->user.tri = no;
					sym->flags &= ~SYMBOL_NEW;
					break;
				}
				conf_warning("symbol value '%s' invalid for %s", p, sym->name);
				break;
			case S_STRING:
				if (*p++ != '"')
					break;
				for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
					if (*p2 == '"') {
						*p2 = 0;
						break;
					}
					memmove(p2, p2 + 1, strlen(p2));
				}
				if (!p2) {
					conf_warning("invalid string found");
					continue;
				}
			case S_INT:
			case S_HEX:
				if (sym_string_valid(sym, p)) {
					sym->user.val = strdup(p);
					sym->flags &= ~SYMBOL_NEW;
				} else {
					conf_warning("symbol value '%s' invalid for %s", p, sym->name);
					continue;
				}
				break;
			default:
				;
			}
			break;
		case '\n':
			break;
		default:
			conf_warning("unexpected data");
			continue;
		}
		if (sym && sym_is_choice_value(sym)) {
			struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
			switch (sym->user.tri) {
			case no:
				break;
			case mod:
				if (cs->user.tri == yes) {
					conf_warning("%s creates inconsistent choice state", sym->name);
					cs->flags |= SYMBOL_NEW;
				}
				break;
			case yes:
				if (cs->user.tri != no) {
					conf_warning("%s creates inconsistent choice state", sym->name);
					cs->flags |= SYMBOL_NEW;
				} else
					cs->user.val = sym;
				break;
			}
			cs->user.tri = E_OR(cs->user.tri, sym->user.tri);
		}
	}
	fclose(in);

	if (modules_sym)
		sym_calc_value(modules_sym);
	return 0;
}

int conf_read(const char *name)
{
	struct symbol *sym;
	struct property *prop;
	struct expr *e;
	int i;

	sym_change_count = 0;

	if (conf_read_simple(name))
		return 1;

	for_all_symbols(i, sym) {
		sym_calc_value(sym);
		if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
			goto sym_ok;
		if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
			/* check that calculated value agrees with saved value */
			switch (sym->type) {
			case S_BOOLEAN:
			case S_TRISTATE:
				if (sym->user.tri != sym_get_tristate_value(sym))
					break;
				if (!sym_is_choice(sym))
					goto sym_ok;
			default:
				if (!strcmp(sym->curr.val, sym->user.val))
					goto sym_ok;
				break;
			}
		} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
			/* no previous value and not saved */
			goto sym_ok;
		conf_unsaved++;
		/* maybe print value in verbose mode... */
	sym_ok:
		if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
			if (sym->visible == no)
				sym->flags |= SYMBOL_NEW;
			switch (sym->type) {
			case S_STRING:
			case S_INT:
			case S_HEX:
				if (!sym_string_within_range(sym, sym->user.val)) {
					sym->flags |= SYMBOL_NEW;
					sym->flags &= ~SYMBOL_VALID;
				}
			default:
				break;
			}
		}
		if (!sym_is_choice(sym))
			continue;
		prop = sym_get_choice_prop(sym);
		for (e = prop->expr; e; e = e->left.expr)
			if (e->right.sym->visible != no)
				sym->flags |= e->right.sym->flags & SYMBOL_NEW;
	}

	sym_change_count += conf_warnings || conf_unsaved;

	return 0;
}

int conf_write(const char *name)
{
	FILE *out, *out_h;
	struct symbol *sym;
	struct menu *menu;
	const char *basename;
	char dirname[128], tmpname[128], newname[128];
	int type, l;
	const char *str;
	time_t now;
	int use_timestamp = 1;
	char *env;

	dirname[0] = 0;
	if (name && name[0]) {
		struct stat st;
		char *slash;

		if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
			strcpy(dirname, name);
			strcat(dirname, "/");
			basename = conf_def_filename;
		} else if ((slash = strrchr(name, '/'))) {
			int size = slash - name + 1;
			memcpy(dirname, name, size);
			dirname[size] = 0;
			if (slash[1])
				basename = slash + 1;
			else
				basename = conf_def_filename;
		} else
			basename = name;
	} else
		basename = conf_def_filename;

	sprintf(newname, "%s.tmpconfig.%d", dirname, (int)getpid());
	out = fopen(newname, "w");
	if (!out)
		return 1;
	out_h = NULL;
	if (!name) {
		out_h = fopen(".tmpconfig.h", "w");
		if (!out_h)
			return 1;
		file_write_dep(NULL);
	}
	sym = sym_lookup("KERNELVERSION", 0);
	sym_calc_value(sym);
	time(&now);
	env = getenv("KCONFIG_NOTIMESTAMP");
	if (env && *env)
		use_timestamp = 0;

	fprintf(out, _("#\n"
		       "# Automatically generated make config: don't edit\n"
		       "# Linux kernel version: %s\n"
		       "%s%s"
		       "#\n"),
		     sym_get_string_value(sym),
		     use_timestamp ? "# " : "",
		     use_timestamp ? ctime(&now) : "");
	if (out_h)
		fprintf(out_h, "/*\n"
			       " * Automatically generated C config: don't edit\n"
			       " * Linux kernel version: %s\n"
			       "%s%s"
			       " */\n"
			       "#define AUTOCONF_INCLUDED\n",
			       sym_get_string_value(sym),
			       use_timestamp ? " * " : "",
			       use_timestamp ? ctime(&now) : "");

	if (!sym_change_count)
		sym_clear_all_valid();

	menu = rootmenu.list;
	while (menu) {
		sym = menu->sym;
		if (!sym) {
			if (!menu_is_visible(menu))
				goto next;
			str = menu_get_prompt(menu);
			fprintf(out, "\n"
				     "#\n"
				     "# %s\n"
				     "#\n", str);
			if (out_h)
				fprintf(out_h, "\n"
					       "/*\n"
					       " * %s\n"
					       " */\n", str);
		} else if (!(sym->flags & SYMBOL_CHOICE)) {
			sym_calc_value(sym);
			if (!(sym->flags & SYMBOL_WRITE))
				goto next;
			sym->flags &= ~SYMBOL_WRITE;
			type = sym->type;
			if (type == S_TRISTATE) {
				sym_calc_value(modules_sym);
				if (modules_sym->curr.tri == no)
					type = S_BOOLEAN;
			}
			switch (type) {
			case S_BOOLEAN:
			case S_TRISTATE:
				switch (sym_get_tristate_value(sym)) {
				case no:
					fprintf(out, "# CONFIG_%s is not set\n", sym->name);
					if (out_h)
						fprintf(out_h, "#undef CONFIG_%s\n", sym->name);
					break;
				case mod:
					fprintf(out, "CONFIG_%s=m\n", sym->name);
					if (out_h)
						fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
					break;
				case yes:
					fprintf(out, "CONFIG_%s=y\n", sym->name);
					if (out_h)
						fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
					break;
				}
				break;
			case S_STRING:
				// fix me
				str = sym_get_string_value(sym);
				fprintf(out, "CONFIG_%s=\"", sym->name);
				if (out_h)
					fprintf(out_h, "#define CONFIG_%s \"", sym->name);
				do {
					l = strcspn(str, "\"\\");
					if (l) {
						fwrite(str, l, 1, out);
						if (out_h)
							fwrite(str, l, 1, out_h);
					}
					str += l;
					while (*str == '\\' || *str == '"') {
						fprintf(out, "\\%c", *str);
						if (out_h)
							fprintf(out_h, "\\%c", *str);
						str++;
					}
				} while (*str);
				fputs("\"\n", out);
				if (out_h)
					fputs("\"\n", out_h);
				break;
			case S_HEX:
				str = sym_get_string_value(sym);
				if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
					fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
					if (out_h)
						fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
					break;
				}
			case S_INT:
				str = sym_get_string_value(sym);
				fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
				if (out_h)
					fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
				break;
			}
		}

	next:
		if (menu->list) {
			menu = menu->list;
			continue;
		}
		if (menu->next)
			menu = menu->next;
		else while ((menu = menu->parent)) {
			if (menu->next) {
				menu = menu->next;
				break;
			}
		}
	}
	fclose(out);
	if (out_h) {
		fclose(out_h);
		rename(".tmpconfig.h", "include/linux/autoconf.h");
	}
	if (!name || basename != conf_def_filename) {
		if (!name)
			name = conf_def_filename;
		sprintf(tmpname, "%s.old", name);
		rename(name, tmpname);
	}
	sprintf(tmpname, "%s%s", dirname, basename);
	if (rename(newname, tmpname))
		return 1;

	printf(_("#\n"
		 "# configuration written to %s\n"
		 "#\n"), tmpname);

	sym_change_count = 0;

	return 0;
}
Commit	Line	Data
1da177e4 LT	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 <stdio.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11	#include <time.h>
	12	#include <unistd.h>
	13
	14	#define LKC_DIRECT_LINK
	15	#include "lkc.h"
	16
c1a0f5e3 RZ	17	static void conf_warning(const char *fmt, ...)
	18	__attribute__ ((format (printf, 1, 2)));
	19
	20	static const char *conf_filename;
	21	static int conf_lineno, conf_warnings, conf_unsaved;
	22
1da177e4 LT	23	const char conf_def_filename[] = ".config";
	24
	25	const char conf_defname[] = "arch/$ARCH/defconfig";
	26
	27	const char *conf_confnames[] = {
	28	".config",
	29	"/lib/modules/$UNAME_RELEASE/.config",
	30	"/etc/kernel-config",
	31	"/boot/config-$UNAME_RELEASE",
	32	conf_defname,
	33	NULL,
	34	};
	35
c1a0f5e3 RZ	36	static void conf_warning(const char *fmt, ...)
	37	{
	38	va_list ap;
	39	va_start(ap, fmt);
	40	fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
	41	vfprintf(stderr, fmt, ap);
	42	fprintf(stderr, "\n");
	43	va_end(ap);
	44	conf_warnings++;
	45	}
	46
48b9d03c	47	static char conf_expand_value(const char in)
1da177e4 LT	48	{
1da177e4 LT	49	struct symbol *sym;
48b9d03c	50	const char *src;
1da177e4 LT	51	static char res_value[SYMBOL_MAXLENGTH];
	52	char *dst, name[SYMBOL_MAXLENGTH];
	53
	54	res_value[0] = 0;
	55	dst = name;
	56	while ((src = strchr(in, '$'))) {
	57	strncat(res_value, in, src - in);
	58	src++;
	59	dst = name;
	60	while (isalnum(src) \|\| src == '_')
	61	dst++ = src++;
	62	*dst = 0;
	63	sym = sym_lookup(name, 0);
	64	sym_calc_value(sym);
	65	strcat(res_value, sym_get_string_value(sym));
	66	in = src;
	67	}
	68	strcat(res_value, in);
	69
	70	return res_value;
	71	}
	72
	73	char *conf_get_default_confname(void)
	74	{
	75	struct stat buf;
	76	static char fullname[PATH_MAX+1];
	77	char env, name;
	78
	79	name = conf_expand_value(conf_defname);
	80	env = getenv(SRCTREE);
	81	if (env) {
	82	sprintf(fullname, "%s/%s", env, name);
	83	if (!stat(fullname, &buf))
	84	return fullname;
	85	}
	86	return name;
	87	}
	88
90389160	89	int conf_read_simple(const char *name)
1da177e4 LT	90	{
	91	FILE *in = NULL;
	92	char line[1024];
	93	char p, p2;
1da177e4	94	struct symbol *sym;
1da177e4 LT	95	int i;
	96
	97	if (name) {
	98	in = zconf_fopen(name);
	99	} else {
	100	const char **names = conf_confnames;
ddc97cac RZ	101	name = *names++;
	102	if (!name)
	103	return 1;
	104	in = zconf_fopen(name);
	105	if (in)
	106	goto load;
	107	sym_change_count++;
1da177e4 LT	108	while ((name = *names++)) {
	109	name = conf_expand_value(name);
	110	in = zconf_fopen(name);
	111	if (in) {
3b9fa093	112	printf(_("#\n"
ddc97cac RZ	113	"# using defaults found in %s\n"
	114	"#\n"), name);
	115	goto load;
1da177e4 LT	116	}
	117	}
	118	}
1da177e4 LT	119	if (!in)
	120	return 1;
	121
ddc97cac	122	load:
c1a0f5e3 RZ	123	conf_filename = name;
	124	conf_lineno = 0;
	125	conf_warnings = 0;
	126	conf_unsaved = 0;
	127
1da177e4 LT	128	for_all_symbols(i, sym) {
1da177e4 LT	129	sym->flags \|= SYMBOL_NEW \| SYMBOL_CHANGED;
c1a0f5e3 RZ	130	if (sym_is_choice(sym))
c1a0f5e3 RZ	131	sym->flags &= ~SYMBOL_NEW;
1da177e4 LT	132	sym->flags &= ~SYMBOL_VALID;
	133	switch (sym->type) {
	134	case S_INT:
	135	case S_HEX:
	136	case S_STRING:
	137	if (sym->user.val)
	138	free(sym->user.val);
	139	default:
	140	sym->user.val = NULL;
	141	sym->user.tri = no;
	142	}
	143	}
	144
	145	while (fgets(line, sizeof(line), in)) {
c1a0f5e3	146	conf_lineno++;
1da177e4 LT	147	sym = NULL;
	148	switch (line[0]) {
	149	case '#':
	150	if (memcmp(line + 2, "CONFIG_", 7))
	151	continue;
	152	p = strchr(line + 9, ' ');
	153	if (!p)
	154	continue;
	155	*p++ = 0;
	156	if (strncmp(p, "is not set", 10))
	157	continue;
	158	sym = sym_find(line + 9);
	159	if (!sym) {
c1a0f5e3 RZ	160	conf_warning("trying to assign nonexistent symbol %s", line + 9);
	161	break;
	162	} else if (!(sym->flags & SYMBOL_NEW)) {
	163	conf_warning("trying to reassign symbol %s", sym->name);
1da177e4 LT	164	break;
	165	}
	166	switch (sym->type) {
	167	case S_BOOLEAN:
	168	case S_TRISTATE:
	169	sym->user.tri = no;
	170	sym->flags &= ~SYMBOL_NEW;
	171	break;
	172	default:
	173	;
	174	}
	175	break;
	176	case 'C':
c1a0f5e3 RZ	177	if (memcmp(line, "CONFIG_", 7)) {
c1a0f5e3 RZ	178	conf_warning("unexpected data");
1da177e4	179	continue;
c1a0f5e3	180	}
1da177e4 LT	181	p = strchr(line + 7, '=');
	182	if (!p)
	183	continue;
	184	*p++ = 0;
	185	p2 = strchr(p, '\n');
	186	if (p2)
	187	*p2 = 0;
	188	sym = sym_find(line + 7);
	189	if (!sym) {
c1a0f5e3 RZ	190	conf_warning("trying to assign nonexistent symbol %s", line + 7);
	191	break;
	192	} else if (!(sym->flags & SYMBOL_NEW)) {
	193	conf_warning("trying to reassign symbol %s", sym->name);
1da177e4 LT	194	break;
	195	}
	196	switch (sym->type) {
	197	case S_TRISTATE:
	198	if (p[0] == 'm') {
	199	sym->user.tri = mod;
	200	sym->flags &= ~SYMBOL_NEW;
	201	break;
	202	}
	203	case S_BOOLEAN:
	204	if (p[0] == 'y') {
	205	sym->user.tri = yes;
	206	sym->flags &= ~SYMBOL_NEW;
	207	break;
	208	}
	209	if (p[0] == 'n') {
	210	sym->user.tri = no;
	211	sym->flags &= ~SYMBOL_NEW;
	212	break;
	213	}
c1a0f5e3	214	conf_warning("symbol value '%s' invalid for %s", p, sym->name);
1da177e4 LT	215	break;
	216	case S_STRING:
	217	if (*p++ != '"')
	218	break;
	219	for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
	220	if (*p2 == '"') {
	221	*p2 = 0;
	222	break;
	223	}
	224	memmove(p2, p2 + 1, strlen(p2));
	225	}
	226	if (!p2) {
c1a0f5e3 RZ	227	conf_warning("invalid string found");
c1a0f5e3 RZ	228	continue;
1da177e4 LT	229	}
	230	case S_INT:
	231	case S_HEX:
	232	if (sym_string_valid(sym, p)) {
	233	sym->user.val = strdup(p);
	234	sym->flags &= ~SYMBOL_NEW;
	235	} else {
c1a0f5e3 RZ	236	conf_warning("symbol value '%s' invalid for %s", p, sym->name);
c1a0f5e3 RZ	237	continue;
1da177e4 LT	238	}
	239	break;
	240	default:
	241	;
	242	}
	243	break;
	244	case '\n':
	245	break;
	246	default:
c1a0f5e3	247	conf_warning("unexpected data");
1da177e4 LT	248	continue;
	249	}
	250	if (sym && sym_is_choice_value(sym)) {
	251	struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
	252	switch (sym->user.tri) {
	253	case no:
	254	break;
	255	case mod:
c1a0f5e3 RZ	256	if (cs->user.tri == yes) {
	257	conf_warning("%s creates inconsistent choice state", sym->name);
	258	cs->flags \|= SYMBOL_NEW;
	259	}
1da177e4 LT	260	break;
1da177e4 LT	261	case yes:
c1a0f5e3 RZ	262	if (cs->user.tri != no) {
	263	conf_warning("%s creates inconsistent choice state", sym->name);
	264	cs->flags \|= SYMBOL_NEW;
	265	} else
	266	cs->user.val = sym;
1da177e4 LT	267	break;
	268	}
	269	cs->user.tri = E_OR(cs->user.tri, sym->user.tri);
1da177e4 LT	270	}
	271	}
	272	fclose(in);
	273
	274	if (modules_sym)
	275	sym_calc_value(modules_sym);
90389160 RZ	276	return 0;
	277	}
	278
	279	int conf_read(const char *name)
	280	{
	281	struct symbol *sym;
	282	struct property *prop;
	283	struct expr *e;
	284	int i;
	285
ddc97cac RZ	286	sym_change_count = 0;
ddc97cac RZ	287
90389160 RZ	288	if (conf_read_simple(name))
	289	return 1;
	290
1da177e4 LT	291	for_all_symbols(i, sym) {
1da177e4 LT	292	sym_calc_value(sym);
c1a0f5e3 RZ	293	if (sym_is_choice(sym) \|\| (sym->flags & SYMBOL_AUTO))
	294	goto sym_ok;
	295	if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
	296	/* check that calculated value agrees with saved value */
	297	switch (sym->type) {
	298	case S_BOOLEAN:
	299	case S_TRISTATE:
	300	if (sym->user.tri != sym_get_tristate_value(sym))
	301	break;
	302	if (!sym_is_choice(sym))
	303	goto sym_ok;
	304	default:
	305	if (!strcmp(sym->curr.val, sym->user.val))
	306	goto sym_ok;
	307	break;
	308	}
	309	} else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
	310	/* no previous value and not saved */
	311	goto sym_ok;
	312	conf_unsaved++;
	313	/* maybe print value in verbose mode... */
	314	sym_ok:
1da177e4 LT	315	if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
	316	if (sym->visible == no)
	317	sym->flags \|= SYMBOL_NEW;
	318	switch (sym->type) {
	319	case S_STRING:
	320	case S_INT:
	321	case S_HEX:
c1a0f5e3	322	if (!sym_string_within_range(sym, sym->user.val)) {
1da177e4	323	sym->flags \|= SYMBOL_NEW;
c1a0f5e3 RZ	324	sym->flags &= ~SYMBOL_VALID;
c1a0f5e3 RZ	325	}
1da177e4 LT	326	default:
	327	break;
	328	}
	329	}
	330	if (!sym_is_choice(sym))
	331	continue;
	332	prop = sym_get_choice_prop(sym);
	333	for (e = prop->expr; e; e = e->left.expr)
	334	if (e->right.sym->visible != no)
	335	sym->flags \|= e->right.sym->flags & SYMBOL_NEW;
	336	}
	337
ddc97cac	338	sym_change_count += conf_warnings \|\| conf_unsaved;
1da177e4 LT	339
	340	return 0;
	341	}
	342
	343	int conf_write(const char *name)
	344	{
	345	FILE out, out_h;
	346	struct symbol *sym;
	347	struct menu *menu;
	348	const char *basename;
	349	char dirname[128], tmpname[128], newname[128];
	350	int type, l;
	351	const char *str;
	352	time_t now;
	353	int use_timestamp = 1;
	354	char *env;
	355
	356	dirname[0] = 0;
	357	if (name && name[0]) {
	358	struct stat st;
	359	char *slash;
	360
	361	if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
	362	strcpy(dirname, name);
	363	strcat(dirname, "/");
	364	basename = conf_def_filename;
	365	} else if ((slash = strrchr(name, '/'))) {
	366	int size = slash - name + 1;
	367	memcpy(dirname, name, size);
	368	dirname[size] = 0;
	369	if (slash[1])
	370	basename = slash + 1;
	371	else
	372	basename = conf_def_filename;
	373	} else
	374	basename = name;
	375	} else
	376	basename = conf_def_filename;
	377
	378	sprintf(newname, "%s.tmpconfig.%d", dirname, (int)getpid());
	379	out = fopen(newname, "w");
	380	if (!out)
	381	return 1;
	382	out_h = NULL;
	383	if (!name) {
	384	out_h = fopen(".tmpconfig.h", "w");
	385	if (!out_h)
	386	return 1;
dc9a49a4	387	file_write_dep(NULL);
1da177e4	388	}
2244cbd8	389	sym = sym_lookup("KERNELVERSION", 0);
1da177e4 LT	390	sym_calc_value(sym);
	391	time(&now);
	392	env = getenv("KCONFIG_NOTIMESTAMP");
	393	if (env && *env)
	394	use_timestamp = 0;
	395
3b9fa093 ACM	396	fprintf(out, _("#\n"
	397	"# Automatically generated make config: don't edit\n"
	398	"# Linux kernel version: %s\n"
	399	"%s%s"
	400	"#\n"),
1da177e4 LT	401	sym_get_string_value(sym),
	402	use_timestamp ? "# " : "",
	403	use_timestamp ? ctime(&now) : "");
	404	if (out_h)
	405	fprintf(out_h, "/*\n"
	406	" * Automatically generated C config: don't edit\n"
	407	" * Linux kernel version: %s\n"
	408	"%s%s"
	409	" */\n"
	410	"#define AUTOCONF_INCLUDED\n",
	411	sym_get_string_value(sym),
	412	use_timestamp ? " * " : "",
	413	use_timestamp ? ctime(&now) : "");
	414
	415	if (!sym_change_count)
	416	sym_clear_all_valid();
	417
	418	menu = rootmenu.list;
	419	while (menu) {
	420	sym = menu->sym;
	421	if (!sym) {
	422	if (!menu_is_visible(menu))
	423	goto next;
	424	str = menu_get_prompt(menu);
	425	fprintf(out, "\n"
	426	"#\n"
	427	"# %s\n"
	428	"#\n", str);
	429	if (out_h)
	430	fprintf(out_h, "\n"
	431	"/*\n"
	432	" * %s\n"
	433	" */\n", str);
	434	} else if (!(sym->flags & SYMBOL_CHOICE)) {
	435	sym_calc_value(sym);
	436	if (!(sym->flags & SYMBOL_WRITE))
	437	goto next;
	438	sym->flags &= ~SYMBOL_WRITE;
	439	type = sym->type;
	440	if (type == S_TRISTATE) {
	441	sym_calc_value(modules_sym);
	442	if (modules_sym->curr.tri == no)
	443	type = S_BOOLEAN;
	444	}
	445	switch (type) {
	446	case S_BOOLEAN:
	447	case S_TRISTATE:
	448	switch (sym_get_tristate_value(sym)) {
	449	case no:
	450	fprintf(out, "# CONFIG_%s is not set\n", sym->name);
	451	if (out_h)
	452	fprintf(out_h, "#undef CONFIG_%s\n", sym->name);
	453	break;
	454	case mod:
	455	fprintf(out, "CONFIG_%s=m\n", sym->name);
	456	if (out_h)
	457	fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
	458	break;
	459	case yes:
	460	fprintf(out, "CONFIG_%s=y\n", sym->name);
	461	if (out_h)
	462	fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
	463	break;
	464	}
465	break;
466	case S_STRING:
467	// fix me
468	str = sym_get_string_value(sym);
469	fprintf(out, "CONFIG_%s=\"", sym->name);
470	if (out_h)
471	fprintf(out_h, "#define CONFIG_%s \"", sym->name);
472	do {
473	l = strcspn(str, "\"\\");
474	if (l) {
475	fwrite(str, l, 1, out);
476	if (out_h)
477	fwrite(str, l, 1, out_h);
478	}
479	str += l;
480	while (str == '\\' \|\| str == '"') {
481	fprintf(out, "\\%c", *str);
482	if (out_h)
483	fprintf(out_h, "\\%c", *str);
484	str++;
485	}
486	} while (*str);
487	fputs("\"\n", out);
488	if (out_h)
489	fputs("\"\n", out_h);
490	break;
491	case S_HEX:
492	str = sym_get_string_value(sym);
493	if (str[0] != '0' \|\| (str[1] != 'x' && str[1] != 'X')) {
494	fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
495	if (out_h)
496	fprintf(out_h, "#define CONFIG_%s 0x%s\n", sym->name, str);
497	break;
498	}
499	case S_INT:
500	str = sym_get_string_value(sym);
501	fprintf(out, "CONFIG_%s=%s\n", sym->name, str);
502	if (out_h)
503	fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
504	break;
505	}
506	}
507
508	next:
509	if (menu->list) {
510	menu = menu->list;
511	continue;
512	}
513	if (menu->next)
514	menu = menu->next;
515	else while ((menu = menu->parent)) {
516	if (menu->next) {
517	menu = menu->next;
518	break;
519	}
520	}
521	}
522	fclose(out);
523	if (out_h) {
524	fclose(out_h);
525	rename(".tmpconfig.h", "include/linux/autoconf.h");
1da177e4 LT	526	}
	527	if (!name \|\| basename != conf_def_filename) {
	528	if (!name)
	529	name = conf_def_filename;
	530	sprintf(tmpname, "%s.old", name);
	531	rename(name, tmpname);
	532	}
	533	sprintf(tmpname, "%s%s", dirname, basename);
	534	if (rename(newname, tmpname))
	535	return 1;
	536
ddc97cac RZ	537	printf(_("#\n"
	538	"# configuration written to %s\n"
	539	"#\n"), tmpname);
	540
1da177e4 LT	541	sym_change_count = 0;
	542
	543	return 0;
	544	}