/*
 * 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>
#include <libgen.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[] = ".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("AT91BOOTSTRAP_CONFIG");

    return name ? name : ".config";
}

const char *conf_get_autoconfig_name(void)
{
    return getenv("KCONFIG_AUTOCONFIG");
}

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)
            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 (line[1] != ' ')
                continue;
            p = strchr(line + 2, ' ');
            if (!p)
                continue;
            *p++ = 0;
            if (strncmp(p, "is not set", 10))
                continue;
            if (def == S_DEF_USER) {
                sym = sym_find(line + 2);
                if (!sym) {
                    sym_add_change_count(1);
                    break;
                }
            } else {
                sym = sym_lookup(line + 2, 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:
                ;
            }
            break;
        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
        case 'G':
        case 'H':
        case 'I':
        case 'J':
        case 'K':
        case 'L':
        case 'M':
        case 'N':
        case 'O':
        case 'P':
        case 'Q':
        case 'R':
        case 'S':
        case 'T':
        case 'U':
        case 'V':
        case 'W':
        case 'X':
        case 'Y':
        case 'Z':
            p = strchr(line, '=');
            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);
                if (!sym) {
                    sym_add_change_count(1);
                    break;
                }
            } else {
                sym = sym_lookup(line, 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;
            break;
        case '\r':
        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("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 \"", name);
	else
		fprintf(out, "%s=\"", 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);
}

static void conf_write_symbol(struct symbol *sym, enum symbol_type type,
                              FILE *out, bool write_no)
{
	const char *str;

	switch (type) {
	case S_BOOLEAN:
	case S_TRISTATE:
		switch (sym_get_tristate_value(sym)) {
		case no:
			if (write_no)
				fprintf(out, "# %s is not set\n", sym->name);
			break;
		case mod:
			fprintf(out, "%s=m\n", sym->name);
			break;
		case yes:
			fprintf(out, "%s=y\n", 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\n", 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 equal to "y".
			 */
			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 == ds) {
					if ((sym->type == S_BOOLEAN ||
					sym->type == S_TRISTATE) &&
					sym_get_tristate_value(sym) == yes)
						goto next_menu;
				}
			}
			conf_write_symbol(sym, sym->type, 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;

    char dirname[PATH_MAX+1], tmpname[PATH_MAX+22], newname[PATH_MAX+8];
	enum symbol_type type;


    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("BR2_VERSION", 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"
                   "%s%s"
                   "#\n"),
            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;
            type = sym->type;
            if (type == S_TRISTATE) {
                sym_calc_value(modules_sym);
                if (modules_sym->curr.tri == no)
                    type = S_BOOLEAN;
            }
		/* Write config symbol to file */
		conf_write_symbol(sym, type, 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;
    }

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

    sym_set_change_count(0);

    return 0;
}

static int conf_split_config(void)
{
    const char *name;

    char path[128];

    char *opwd, *dir, *_name;

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

    opwd = malloc(256);
    _name = strdup(name);
    if (opwd == NULL || _name == NULL)
        return 1;
    opwd = getcwd(opwd, 256);
    dir = dirname(_name);
    if (dir == NULL) {
        res = 1;
        goto err;
    }
    if (chdir(dir)) {
        res = 1;
        goto err;
    }

    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(opwd))
        res = 1;
 err:
    free(opwd);
    free(_name);
    return res;
}

int conf_write_autoconf(void)
{
    struct symbol *sym;

    const char *str;

    const char *name;

    FILE *out, *out_h;

    time_t now;

    int i;

    sym_clear_all_valid();

    file_write_dep(".config.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("BR2_VERSION", 0);
    sym_calc_value(sym);
    time(&now);
    fprintf(out, "#\n"
            "# Automatically generated make config: don't edit\n"
            "# %s" "#\n", ctime(&now));
    fprintf(out_h, "/*\n"
            " * Automatically generated C config: don't edit\n"
            " * %s" " */\n", ctime(&now));

    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, sym->type, 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(out_h, "#define %s_MODULE 1\n", sym->name);
                break;
            case yes:
                fprintf(out_h, "#define %s 1\n", 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 0x%s\n", sym->name, str);
                break;
            }
        case S_INT:
            str = sym_get_string_value(sym);
            fprintf(out_h, "#define %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 = 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;
}

void conf_set_all_new_symbols(enum conf_def_mode mode)
{
    struct symbol *sym, *csym;

    struct property *prop;

    struct expr *e;

    int i, cnt, def;

    for_all_symbols(i, sym) {
        if (sym_has_value(sym))
            continue;
        switch (sym_get_type(sym)) {
        case S_BOOLEAN:
        case S_TRISTATE:
            switch (mode) {
            case def_yes:
                sym->def[S_DEF_USER].tri = yes;
                break;
            case def_mod:
                sym->def[S_DEF_USER].tri = mod;
                break;
            case def_no:
                sym->def[S_DEF_USER].tri = no;
                break;
            case def_random:
                sym->def[S_DEF_USER].tri = (tristate) (rand() % 3);
                break;
            default:
                continue;
            }
            if (!(sym_is_choice(sym) && mode == def_random))
                sym->flags |= SYMBOL_DEF_USER;
            break;
        default:
            break;
        }

    }

    sym_clear_all_valid();

    if (mode != def_random)
        return;
    /*
     * We have different type of choice blocks.
     * If curr.tri equal to mod then we can select several
     * choice symbols in one block.
     * In this case we do nothing.
     * If curr.tri equal yes then only one symbol can be
     * selected in a choice block and we set it to yes,
     * and the rest to no.
     */
    for_all_symbols(i, csym) {
        if (sym_has_value(csym) || !sym_is_choice(csym))
            continue;

        sym_calc_value(csym);

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

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