[deliverable/linux.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_defname[] = "arch/$ARCH/defconfig";

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++;
}

const char *conf_get_configname(void)
{
	char *name = getenv("KCONFIG_CONFIG");

	return name ? name : ".config";
}

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 {
		struct property *prop;

		name = conf_get_configname();
		in = zconf_fopen(name);
		if (in)
			goto load;
		sym_change_count++;
		if (!sym_defconfig_list)
			return 1;

		for_all_defaults(sym_defconfig_list, prop) {
			if (expr_calc_value(prop->visible.expr) == no ||
			    prop->expr->type != E_SYMBOL)
				continue;
			name = conf_expand_value(prop->expr->left.sym->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_get_configname();
		} 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_get_configname();
		} else
			basename = name;
	} else
		basename = conf_get_configname();

	sprintf(newname, "%s%s", dirname, basename);
	env = getenv("KCONFIG_OVERWRITECONFIG");
	if (!env || !*env) {
		sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
		out = fopen(tmpname, "w");
	} else {
		*tmpname = 0;
		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 (*tmpname) {
		strcat(dirname, name ? name : conf_get_configname());
		strcat(dirname, ".old");
		rename(newname, dirname);
		if (rename(tmpname, newname))
			return 1;
	}

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

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