[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";

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

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