URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [scripts/] [kconfig/] [confdata.c] - Blame information for rev 79

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * 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;
}
 
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 (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 (*p2 == '\r')
                                        *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;
                        }
                        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("%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_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;
                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;
        }
 
        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;
}
 
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 (!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;
                        }
                        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, 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;
}
 
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;
}
 
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;
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [scripts/] [kconfig/] [confdata.c] - Blame information for rev 79

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