[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 <fcntl.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, int def)
{
	FILE *in = NULL;
	char line[1024];
	char *p, *p2;
	struct symbol *sym;
	int i, def_flags;

	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;

	def_flags = SYMBOL_DEF << def;
	for_all_symbols(i, sym) {
		sym->flags |= SYMBOL_CHANGED;
		sym->flags &= ~(def_flags|SYMBOL_VALID);
		if (sym_is_choice(sym))
			sym->flags |= def_flags;
		switch (sym->type) {
		case S_INT:
		case S_HEX:
		case S_STRING:
			if (sym->def[def].val)
				free(sym->def[def].val);
		default:
			sym->def[def].val = NULL;
			sym->def[def].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;
			if (def == S_DEF_USER) {
				sym = sym_find(line + 9);
				if (!sym) {
					conf_warning("trying to assign nonexistent symbol %s", line + 9);
					break;
				}
			} else {
				sym = sym_lookup(line + 9, 0);
				if (sym->type == S_UNKNOWN)
					sym->type = S_BOOLEAN;
			}
			if (sym->flags & def_flags) {
				conf_warning("trying to reassign symbol %s", sym->name);
				break;
			}
			switch (sym->type) {
			case S_BOOLEAN:
			case S_TRISTATE:
				sym->def[def].tri = no;
				sym->flags |= def_flags;
				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;
			if (def == S_DEF_USER) {
				sym = sym_find(line + 7);
				if (!sym) {
					conf_warning("trying to assign nonexistent symbol %s", line + 7);
					break;
				}
			} else {
				sym = sym_lookup(line + 7, 0);
				if (sym->type == S_UNKNOWN)
					sym->type = S_OTHER;
			}
			if (sym->flags & def_flags) {
				conf_warning("trying to reassign symbol %s", sym->name);
				break;
			}
			switch (sym->type) {
			case S_TRISTATE:
				if (p[0] == 'm') {
					sym->def[def].tri = mod;
					sym->flags |= def_flags;
					break;
				}
			case S_BOOLEAN:
				if (p[0] == 'y') {
					sym->def[def].tri = yes;
					sym->flags |= def_flags;
					break;
				}
				if (p[0] == 'n') {
					sym->def[def].tri = no;
					sym->flags |= def_flags;
					break;
				}
				conf_warning("symbol value '%s' invalid for %s", p, sym->name);
				break;
			case S_OTHER:
				if (*p != '"') {
					for (p2 = p; *p2 && !isspace(*p2); p2++)
						;
					sym->type = S_STRING;
					goto done;
				}
			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:
			done:
				if (sym_string_valid(sym, p)) {
					sym->def[def].val = strdup(p);
					sym->flags |= def_flags;
				} 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->def[def].tri) {
			case no:
				break;
			case mod:
				if (cs->def[def].tri == yes) {
					conf_warning("%s creates inconsistent choice state", sym->name);
					cs->flags &= ~def_flags;
				}
				break;
			case yes:
				if (cs->def[def].tri != no) {
					conf_warning("%s creates inconsistent choice state", sym->name);
					cs->flags &= ~def_flags;
				} else
					cs->def[def].val = sym;
				break;
			}
			cs->def[def].tri = E_OR(cs->def[def].tri, sym->def[def].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, flags;

	sym_change_count = 0;

	if (conf_read_simple(name, S_DEF_USER))
		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->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
					break;
				if (!sym_is_choice(sym))
					goto sym_ok;
			default:
				if (!strcmp(sym->curr.val, sym->def[S_DEF_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_DEF_USER;
			switch (sym->type) {
			case S_STRING:
			case S_INT:
			case S_HEX:
				if (!sym_string_within_range(sym, sym->def[S_DEF_USER].val))
					sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
			default:
				break;
			}
		}
		if (!sym_is_choice(sym))
			continue;
		prop = sym_get_choice_prop(sym);
		flags = sym->flags;
		for (e = prop->expr; e; e = e->left.expr)
			if (e->right.sym->visible != no)
				flags &= e->right.sym->flags;
		sym->flags |= flags & SYMBOL_DEF_USER;
	}

	sym_change_count += conf_warnings || conf_unsaved;

	return 0;
}

int conf_write(const char *name)
{
	FILE *out;
	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;
	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 (!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);
		} 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);
					break;
				case mod:
					fprintf(out, "CONFIG_%s=m\n", sym->name);
					break;
				case yes:
					fprintf(out, "CONFIG_%s=y\n", sym->name);
					break;
				}
				break;
			case S_STRING:
				str = sym_get_string_value(sym);
				fprintf(out, "CONFIG_%s=\"", sym->name);
				while (1) {
					l = strcspn(str, "\"\\");
					if (l) {
						fwrite(str, l, 1, out);
						str += l;
					}
					if (!*str)
						break;
					fprintf(out, "\\%c", *str++);
				}
				fputs("\"\n", out);
				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);
					break;
				}
			case S_INT:
				str = sym_get_string_value(sym);
				fprintf(out, "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 (!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;
}

int conf_split_config(void)
{
	char *name, path[128];
	char *s, *d, c;
	struct symbol *sym;
	struct stat sb;
	int res, i, fd;

	name = getenv("KCONFIG_AUTOCONFIG");
	if (!name)
		name = "include/config/auto.conf";
	conf_read_simple(name, S_DEF_AUTO);

	if (chdir("include/config"))
		return 1;

	res = 0;
	for_all_symbols(i, sym) {
		sym_calc_value(sym);
		if ((sym->flags & SYMBOL_AUTO) || !sym->name)
			continue;
		if (sym->flags & SYMBOL_WRITE) {
			if (sym->flags & SYMBOL_DEF_AUTO) {
				/*
				 * symbol has old and new value,
				 * so compare them...
				 */
				switch (sym->type) {
				case S_BOOLEAN:
				case S_TRISTATE:
					if (sym_get_tristate_value(sym) ==
					    sym->def[S_DEF_AUTO].tri)
						continue;
					break;
				case S_STRING:
				case S_HEX:
				case S_INT:
					if (!strcmp(sym_get_string_value(sym),
						    sym->def[S_DEF_AUTO].val))
						continue;
					break;
				default:
					break;
				}
			} else {
				/*
				 * If there is no old value, only 'no' (unset)
				 * is allowed as new value.
				 */
				switch (sym->type) {
				case S_BOOLEAN:
				case S_TRISTATE:
					if (sym_get_tristate_value(sym) == no)
						continue;
					break;
				default:
					break;
				}
			}
		} else if (!(sym->flags & SYMBOL_DEF_AUTO))
			/* There is neither an old nor a new value. */
			continue;
		/* else
		 *	There is an old value, but no new value ('no' (unset)
		 *	isn't saved in auto.conf, so the old value is always
		 *	different from 'no').
		 */

		/* Replace all '_' and append ".h" */
		s = sym->name;
		d = path;
		while ((c = *s++)) {
			c = tolower(c);
			*d++ = (c == '_') ? '/' : c;
		}
		strcpy(d, ".h");

		/* Assume directory path already exists. */
		fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
		if (fd == -1) {
			if (errno != ENOENT) {
				res = 1;
				break;
			}
			/*
			 * Create directory components,
			 * unless they exist already.
			 */
			d = path;
			while ((d = strchr(d, '/'))) {
				*d = 0;
				if (stat(path, &sb) && mkdir(path, 0755)) {
					res = 1;
					goto out;
				}
				*d++ = '/';
			}
			/* Try it again. */
			fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
			if (fd == -1) {
				res = 1;
				break;
			}
		}
		close(fd);
	}
out:
	if (chdir("../.."))
		return 1;

	return res;
}

int conf_write_autoconf(void)
{
	struct symbol *sym;
	const char *str;
	char *name;
	FILE *out, *out_h;
	time_t now;
	int i, l;

	sym_clear_all_valid();

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

	if (conf_split_config())
		return 1;

	out = fopen(".tmpconfig", "w");
	if (!out)
		return 1;

	out_h = fopen(".tmpconfig.h", "w");
	if (!out_h) {
		fclose(out);
		return 1;
	}

	sym = sym_lookup("KERNELVERSION", 0);
	sym_calc_value(sym);
	time(&now);
	fprintf(out, "#\n"
		     "# Automatically generated make config: don't edit\n"
		     "# Linux kernel version: %s\n"
		     "# %s"
		     "#\n",
		     sym_get_string_value(sym), ctime(&now));
	fprintf(out_h, "/*\n"
		       " * Automatically generated C config: don't edit\n"
		       " * Linux kernel version: %s\n"
		       " * %s"
		       " */\n"
		       "#define AUTOCONF_INCLUDED\n",
		       sym_get_string_value(sym), ctime(&now));

	for_all_symbols(i, sym) {
		sym_calc_value(sym);
		if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
			continue;
		switch (sym->type) {
		case S_BOOLEAN:
		case S_TRISTATE:
			switch (sym_get_tristate_value(sym)) {
			case no:
				break;
			case mod:
				fprintf(out, "CONFIG_%s=m\n", sym->name);
				fprintf(out_h, "#define CONFIG_%s_MODULE 1\n", sym->name);
				break;
			case yes:
				fprintf(out, "CONFIG_%s=y\n", sym->name);
				fprintf(out_h, "#define CONFIG_%s 1\n", sym->name);
				break;
			}
			break;
		case S_STRING:
			str = sym_get_string_value(sym);
			fprintf(out, "CONFIG_%s=\"", sym->name);
			fprintf(out_h, "#define CONFIG_%s \"", sym->name);
			while (1) {
				l = strcspn(str, "\"\\");
				if (l) {
					fwrite(str, l, 1, out);
					fwrite(str, l, 1, out_h);
					str += l;
				}
				if (!*str)
					break;
				fprintf(out, "\\%c", *str);
				fprintf(out_h, "\\%c", *str);
				str++;
			}
			fputs("\"\n", out);
			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);
				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);
			fprintf(out_h, "#define CONFIG_%s %s\n", sym->name, str);
			break;
		default:
			break;
		}
	}
	fclose(out);
	fclose(out_h);

	name = getenv("KCONFIG_AUTOHEADER");
	if (!name)
		name = "include/linux/autoconf.h";
	if (rename(".tmpconfig.h", name))
		return 1;
	name = getenv("KCONFIG_AUTOCONFIG");
	if (!name)
		name = "include/config/auto.conf";
	/*
	 * This must be the last step, kbuild has a dependency on auto.conf
	 * and this marks the successful completion of the previous steps.
	 */
	if (rename(".tmpconfig", name))
		return 1;

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