/*

 * 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 <errno.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 void conf_message(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++;

}

static void conf_default_message_callback(const char *fmt, va_list ap)

{

	printf("#\n# ");

	vprintf(fmt, ap);

	printf("\n#\n");

}

static void (*conf_message_callback) (const char *fmt, va_list ap) =

	conf_default_message_callback;

void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))

{

	conf_message_callback = fn;

}

static void conf_message(const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	if (conf_message_callback)

		conf_message_callback(fmt, ap);

}

const char *conf_get_configname(void)

{

	char *name = getenv("KCONFIG_CONFIG");

	return name ? name : ".config";

}

const char *conf_get_autoconfig_name(void)

{

	char *name = getenv("KCONFIG_AUTOCONFIG");

	return name ? name : "include/config/auto.conf";

}

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;

}

static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)

{

	char *p2;

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

			return 1;

		}

	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);

			return 1;

		}

		break;

	default:

		;

	}

	return 0;

}

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_add_change_count(1);

		if (!sym_defconfig_list) {

			if (modules_sym)

				sym_calc_value(modules_sym);

			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) {

				conf_message(_("using defaults found in %s"),

					 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;

		if (line[0] == '#') {

			if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))

				continue;

			p = strchr(line + 2 + strlen(CONFIG_), ' ');

			if (!p)

				continue;

			*p++ = 0;

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

				continue;

			if (def == S_DEF_USER) {

				sym = sym_find(line + 2 + strlen(CONFIG_));

				if (!sym) {

					sym_add_change_count(1);

					goto setsym;

				}

			} else {

				sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);

				if (sym->type == S_UNKNOWN)

					sym->type = S_BOOLEAN;

			}

			if (sym->flags & def_flags) {

				conf_warning("override: reassigning to symbol %s", sym->name);

			}

			switch (sym->type) {

			case S_BOOLEAN:

			case S_TRISTATE:

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

				sym->flags |= def_flags;

				break;

			default:

				;

			}

		} else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {

			p = strchr(line + strlen(CONFIG_), '=');

			if (!p)

				continue;

			*p++ = 0;

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

			if (p2) {

				*p2-- = 0;

				if (*p2 == '\r')

					*p2 = 0;

			}

			if (def == S_DEF_USER) {

				sym = sym_find(line + strlen(CONFIG_));

				if (!sym) {

					sym_add_change_count(1);

					goto setsym;

				}

			} else {

				sym = sym_lookup(line + strlen(CONFIG_), 0);

				if (sym->type == S_UNKNOWN)

					sym->type = S_OTHER;

			}

			if (sym->flags & def_flags) {

				conf_warning("override: reassigning to symbol %s", sym->name);

			}

			if (conf_set_sym_val(sym, def, def_flags, p))

				continue;

		} else {

			if (line[0] != '\r' && line[0] != '\n')

				conf_warning("unexpected data");

			continue;

		}

setsym:

		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("override: %s changes choice state", sym->name);

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

				break;

			}

			cs->def[def].tri = EXPR_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, *choice_sym;

	struct property *prop;

	struct expr *e;

	int i, flags;

	sym_set_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_is_choice(sym))

			continue;

		/* The choice symbol only has a set value (and thus is not new)

		 * if all its visible childs have values.

		 */

		prop = sym_get_choice_prop(sym);

		flags = sym->flags;

		expr_list_for_each_sym(prop->expr, e, choice_sym)

			if (choice_sym->visible != no)

				flags &= choice_sym->flags;

		sym->flags &= flags | ~SYMBOL_DEF_USER;

	}

	for_all_symbols(i, sym) {

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

			/* Reset values of generates values, so they'll appear

			 * as new, if they should become visible, but that

			 * doesn't quite work if the Kconfig and the saved

			 * configuration disagree.

			 */

			if (sym->visible == no && !conf_unsaved)

				sym->flags &= ~SYMBOL_DEF_USER;

			switch (sym->type) {

			case S_STRING:

			case S_INT:

			case S_HEX:

				/* Reset a string value if it's out of range */

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

					break;

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

				conf_unsaved++;

				break;

			default:

				break;

			}

		}

	}

	sym_add_change_count(conf_warnings || conf_unsaved);

	return 0;

}

/* Write a S_STRING */

static void conf_write_string(bool headerfile, const char *name,

                              const char *str, FILE *out)

{

	int l;

	if (headerfile)

		fprintf(out, "#define %s%s \"", CONFIG_, name);

	else

		fprintf(out, "%s%s=\"", CONFIG_, name);

	while (1) {

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

		if (l) {

			xfwrite(str, l, 1, out);

			str += l;

		}

		if (!*str)

			break;

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

	}

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

}

static void conf_write_symbol(struct symbol *sym, FILE *out, bool write_no)

{

	const char *str;

	switch (sym->type) {

	case S_BOOLEAN:

	case S_TRISTATE:

		switch (sym_get_tristate_value(sym)) {

		case no:

			if (write_no)

				fprintf(out, "# %s%s is not set\n",

				    CONFIG_, sym->name);

			break;

		case mod:

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

			break;

		case yes:

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

			break;

		}

		break;

	case S_STRING:

		conf_write_string(false, sym->name, sym_get_string_value(sym), out);

		break;

	case S_HEX:

	case S_INT:

		str = sym_get_string_value(sym);

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

		break;

	case S_OTHER:

	case S_UNKNOWN:

		break;

	}

}

/*

 * Write out a minimal config.

 * All values that has default values are skipped as this is redundant.

 */

int conf_write_defconfig(const char *filename)

{

	struct symbol *sym;

	struct menu *menu;

	FILE *out;

	out = fopen(filename, "w");

	if (!out)

		return 1;

	sym_clear_all_valid();

	/* Traverse all menus to find all relevant symbols */

	menu = rootmenu.list;

	while (menu != NULL)

	{

		sym = menu->sym;

		if (sym == NULL) {

			if (!menu_is_visible(menu))

				goto next_menu;

		} else if (!sym_is_choice(sym)) {

			sym_calc_value(sym);

			if (!(sym->flags & SYMBOL_WRITE))

				goto next_menu;

			sym->flags &= ~SYMBOL_WRITE;

			/* If we cannot change the symbol - skip */

			if (!sym_is_changable(sym))

				goto next_menu;

			/* If symbol equals to default value - skip */

			if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)

				goto next_menu;

			/*

			 * If symbol is a choice value and equals to the

			 * default for a choice - skip.

			 * But only if value is bool and equal to "y" and

			 * choice is not "optional".

			 * (If choice is "optional" then all values can be "n")

			 */

			if (sym_is_choice_value(sym)) {

				struct symbol *cs;

				struct symbol *ds;

				cs = prop_get_symbol(sym_get_choice_prop(sym));

				ds = sym_choice_default(cs);

				if (!sym_is_optional(cs) && sym == ds) {

					if ((sym->type == S_BOOLEAN) &&

					    sym_get_tristate_value(sym) == yes)

						goto next_menu;

				}

			}

			conf_write_symbol(sym, out, true);

		}

next_menu:

		if (menu->list != NULL) {

			menu = menu->list;

		}

		else if (menu->next != NULL) {

			menu = menu->next;

		} else {

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

				if (menu->next != NULL) {

					menu = menu->next;

					break;

				}

			}

		}

	}

	fclose(out);

	return 0;

}

int conf_write(const char *name)

{

	FILE *out;

	struct symbol *sym;

	struct menu *menu;

	const char *basename;

	const char *str;

	char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];

	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;

	time(&now);

	env = getenv("KCONFIG_NOTIMESTAMP");

	if (env && *env)

		use_timestamp = 0;

	fprintf(out, _("#\n"

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

		       "# %s\n"

		       "%s%s"

		       "#\n"),

		     rootmenu.prompt->text,

		     use_timestamp ? "# " : "",

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

	if (!conf_get_changed())

		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;

			/* Write config symbol to file */

			conf_write_symbol(sym, out, true);

		}

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, basename);

		strcat(dirname, ".old");

		rename(newname, dirname);

		if (rename(tmpname, newname))

			return 1;

	}

	conf_message(_("configuration written to %s"), newname);

	sym_set_change_count(0);

	return 0;

}

static int conf_split_config(void)

{

	const char *name;

	char path[PATH_MAX+1];

	char *s, *d, c;

	struct symbol *sym;

	struct stat sb;

	int res, i, fd;

	name = conf_get_autoconfig_name();

	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;

	const char *name;

	FILE *out, *tristate, *out_h;

	int i;

	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;

	tristate = fopen(".tmpconfig_tristate", "w");

	if (!tristate) {

		fclose(out);

		return 1;

	}

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

	if (!out_h) {

		fclose(out);

		fclose(tristate);

		return 1;

	}

	fprintf(out, "#\n"

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

		     "# %s\n"

		     "#\n",

		     rootmenu.prompt->text);

	fprintf(tristate, "#\n"

			  "# Automatically generated - do not edit\n"

			  "\n");

	fprintf(out_h, "/*\n"

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

		       " * %s\n"

		       " */\n",

		       rootmenu.prompt->text);

	for_all_symbols(i, sym) {

		sym_calc_value(sym);

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

			continue;

		/* write symbol to config file */

		conf_write_symbol(sym, out, false);

		/* update autoconf and tristate files */

		switch (sym->type) {

		case S_BOOLEAN:

		case S_TRISTATE:

			switch (sym_get_tristate_value(sym)) {

			case no:

				break;

			case mod:

				fprintf(tristate, "%s%s=M\n",

				    CONFIG_, sym->name);

				fprintf(out_h, "#define %s%s_MODULE 1\n",

				    CONFIG_, sym->name);

				break;

			case yes:

				if (sym->type == S_TRISTATE)

					fprintf(tristate,"%s%s=Y\n",

					    CONFIG_, sym->name);

				fprintf(out_h, "#define %s%s 1\n",

				    CONFIG_, sym->name);

				break;

			}

			break;

		case S_STRING:

			conf_write_string(true, sym->name, sym_get_string_value(sym), out_h);

			break;

		case S_HEX:

			str = sym_get_string_value(sym);

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

				fprintf(out_h, "#define %s%s 0x%s\n",

				    CONFIG_, sym->name, str);

				break;

			}

		case S_INT:

			str = sym_get_string_value(sym);

			fprintf(out_h, "#define %s%s %s\n",

			    CONFIG_, sym->name, str);

			break;

		default:

			break;

		}

	}

	fclose(out);

	fclose(tristate);

	fclose(out_h);

	name = getenv("KCONFIG_AUTOHEADER");

	if (!name)

		name = "include/generated/autoconf.h";

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

		return 1;

	name = getenv("KCONFIG_TRISTATE");

	if (!name)

		name = "include/config/tristate.conf";

	if (rename(".tmpconfig_tristate", name))

		return 1;

	name = conf_get_autoconfig_name();

	/*

	 * 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;

}

static int sym_change_count;

static void (*conf_changed_callback)(void);

void sym_set_change_count(int count)

{

	int _sym_change_count = sym_change_count;

	sym_change_count = count;

	if (conf_changed_callback &&

	    (bool)_sym_change_count != (bool)count)

		conf_changed_callback();

}

void sym_add_change_count(int count)

{

	sym_set_change_count(count + sym_change_count);

}

bool conf_get_changed(void)

{

	return sym_change_count;

}

void conf_set_changed_callback(void (*fn)(void))

{

	conf_changed_callback = fn;

}

static void randomize_choice_values(struct symbol *csym)

{

	struct property *prop;

	struct symbol *sym;

	struct expr *e;

	int cnt, def;

	/*

	 * If choice is mod then we may have more items selected

	 * and if no then no-one.

	 * In both cases stop.

	 */

	if (csym->curr.tri != yes)

		return;

	prop = sym_get_choice_prop(csym);

	/* count entries in choice block */

	cnt = 0;

	expr_list_for_each_sym(prop->expr, e, sym)

		cnt++;

	/*

	 * find a random value and set it to yes,

	 * set the rest to no so we have only one set

	 */

	def = (rand() % cnt);

	cnt = 0;

	expr_list_for_each_sym(prop->expr, e, sym) {

		if (def == cnt++) {

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

			csym->def[S_DEF_USER].val = sym;

		}

		else {

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

		}

	}

	csym->flags |= SYMBOL_DEF_USER;

	/* clear VALID to get value calculated */

	csym->flags &= ~(SYMBOL_VALID);

}

static void set_all_choice_values(struct symbol *csym)

{

	struct property *prop;

	struct symbol *sym;

	struct expr *e;

	prop = sym_get_choice_prop(csym);

	/*

	 * Set all non-assinged choice values to no

	 */

	expr_list_for_each_sym(prop->expr, e, sym) {

		if (!sym_has_value(sym))

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

	}

	csym->flags |= SYMBOL_DEF_USER;

	/* clear VALID to get value calculated */

	csym->flags &= ~(SYMBOL_VALID);

}

void conf_set_all_new_symbols(enum conf_def_mode mode)

{

	struct symbol *sym, *csym;