Root/scripts/kconfig/confdata.c

1/*
2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
4 */
5
6#include <sys/stat.h>
7#include <ctype.h>
8#include <errno.h>
9#include <fcntl.h>
10#include <stdio.h>
11#include <stdlib.h>
12#include <string.h>
13#include <time.h>
14#include <unistd.h>
15
16#define LKC_DIRECT_LINK
17#include "lkc.h"
18
19static void conf_warning(const char *fmt, ...)
20    __attribute__ ((format (printf, 1, 2)));
21
22static void conf_message(const char *fmt, ...)
23    __attribute__ ((format (printf, 1, 2)));
24
25static const char *conf_filename;
26static int conf_lineno, conf_warnings, conf_unsaved;
27
28const char conf_defname[] = "arch/$ARCH/defconfig";
29
30static void conf_warning(const char *fmt, ...)
31{
32    va_list ap;
33    va_start(ap, fmt);
34    fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
35    vfprintf(stderr, fmt, ap);
36    fprintf(stderr, "\n");
37    va_end(ap);
38    conf_warnings++;
39}
40
41static void conf_default_message_callback(const char *fmt, va_list ap)
42{
43    printf("#\n# ");
44    vprintf(fmt, ap);
45    printf("\n#\n");
46}
47
48static void (*conf_message_callback) (const char *fmt, va_list ap) =
49    conf_default_message_callback;
50void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))
51{
52    conf_message_callback = fn;
53}
54
55static void conf_message(const char *fmt, ...)
56{
57    va_list ap;
58
59    va_start(ap, fmt);
60    if (conf_message_callback)
61        conf_message_callback(fmt, ap);
62}
63
64const char *conf_get_configname(void)
65{
66    char *name = getenv("KCONFIG_CONFIG");
67
68    return name ? name : ".config";
69}
70
71const char *conf_get_autoconfig_name(void)
72{
73    char *name = getenv("KCONFIG_AUTOCONFIG");
74
75    return name ? name : "include/config/auto.conf";
76}
77
78static char *conf_expand_value(const char *in)
79{
80    struct symbol *sym;
81    const char *src;
82    static char res_value[SYMBOL_MAXLENGTH];
83    char *dst, name[SYMBOL_MAXLENGTH];
84
85    res_value[0] = 0;
86    dst = name;
87    while ((src = strchr(in, '$'))) {
88        strncat(res_value, in, src - in);
89        src++;
90        dst = name;
91        while (isalnum(*src) || *src == '_')
92            *dst++ = *src++;
93        *dst = 0;
94        sym = sym_lookup(name, 0);
95        sym_calc_value(sym);
96        strcat(res_value, sym_get_string_value(sym));
97        in = src;
98    }
99    strcat(res_value, in);
100
101    return res_value;
102}
103
104char *conf_get_default_confname(void)
105{
106    struct stat buf;
107    static char fullname[PATH_MAX+1];
108    char *env, *name;
109
110    name = conf_expand_value(conf_defname);
111    env = getenv(SRCTREE);
112    if (env) {
113        sprintf(fullname, "%s/%s", env, name);
114        if (!stat(fullname, &buf))
115            return fullname;
116    }
117    return name;
118}
119
120static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
121{
122    char *p2;
123
124    switch (sym->type) {
125    case S_TRISTATE:
126        if (p[0] == 'm') {
127            sym->def[def].tri = mod;
128            sym->flags |= def_flags;
129            break;
130        }
131    case S_BOOLEAN:
132        if (p[0] == 'y') {
133            sym->def[def].tri = yes;
134            sym->flags |= def_flags;
135            break;
136        }
137        if (p[0] == 'n') {
138            sym->def[def].tri = no;
139            sym->flags |= def_flags;
140            break;
141        }
142        conf_warning("symbol value '%s' invalid for %s", p, sym->name);
143        break;
144    case S_OTHER:
145        if (*p != '"') {
146            for (p2 = p; *p2 && !isspace(*p2); p2++)
147                ;
148            sym->type = S_STRING;
149            goto done;
150        }
151    case S_STRING:
152        if (*p++ != '"')
153            break;
154        for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
155            if (*p2 == '"') {
156                *p2 = 0;
157                break;
158            }
159            memmove(p2, p2 + 1, strlen(p2));
160        }
161        if (!p2) {
162            conf_warning("invalid string found");
163            return 1;
164        }
165    case S_INT:
166    case S_HEX:
167    done:
168        if (sym_string_valid(sym, p)) {
169            sym->def[def].val = strdup(p);
170            sym->flags |= def_flags;
171        } else {
172            conf_warning("symbol value '%s' invalid for %s", p, sym->name);
173            return 1;
174        }
175        break;
176    default:
177        ;
178    }
179    return 0;
180}
181
182int conf_read_simple(const char *name, int def)
183{
184    FILE *in = NULL;
185    char line[1024];
186    char *p, *p2;
187    struct symbol *sym;
188    int i, def_flags;
189
190    if (name) {
191        in = zconf_fopen(name);
192    } else {
193        struct property *prop;
194
195        name = conf_get_configname();
196        in = zconf_fopen(name);
197        if (in)
198            goto load;
199        sym_add_change_count(1);
200        if (!sym_defconfig_list) {
201            if (modules_sym)
202                sym_calc_value(modules_sym);
203            return 1;
204        }
205
206        for_all_defaults(sym_defconfig_list, prop) {
207            if (expr_calc_value(prop->visible.expr) == no ||
208                prop->expr->type != E_SYMBOL)
209                continue;
210            name = conf_expand_value(prop->expr->left.sym->name);
211            in = zconf_fopen(name);
212            if (in) {
213                conf_message(_("using defaults found in %s"),
214                     name);
215                goto load;
216            }
217        }
218    }
219    if (!in)
220        return 1;
221
222load:
223    conf_filename = name;
224    conf_lineno = 0;
225    conf_warnings = 0;
226    conf_unsaved = 0;
227
228    def_flags = SYMBOL_DEF << def;
229    for_all_symbols(i, sym) {
230        sym->flags |= SYMBOL_CHANGED;
231        sym->flags &= ~(def_flags|SYMBOL_VALID);
232        if (sym_is_choice(sym))
233            sym->flags |= def_flags;
234        switch (sym->type) {
235        case S_INT:
236        case S_HEX:
237        case S_STRING:
238            if (sym->def[def].val)
239                free(sym->def[def].val);
240        default:
241            sym->def[def].val = NULL;
242            sym->def[def].tri = no;
243        }
244    }
245
246    while (fgets(line, sizeof(line), in)) {
247        conf_lineno++;
248        sym = NULL;
249        if (line[0] == '#') {
250            if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
251                continue;
252            p = strchr(line + 2 + strlen(CONFIG_), ' ');
253            if (!p)
254                continue;
255            *p++ = 0;
256            if (strncmp(p, "is not set", 10))
257                continue;
258            if (def == S_DEF_USER) {
259                sym = sym_find(line + 2 + strlen(CONFIG_));
260                if (!sym) {
261                    sym_add_change_count(1);
262                    goto setsym;
263                }
264            } else {
265                sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
266                if (sym->type == S_UNKNOWN)
267                    sym->type = S_BOOLEAN;
268            }
269            if (sym->flags & def_flags) {
270                conf_warning("override: reassigning to symbol %s", sym->name);
271            }
272            switch (sym->type) {
273            case S_BOOLEAN:
274            case S_TRISTATE:
275                sym->def[def].tri = no;
276                sym->flags |= def_flags;
277                break;
278            default:
279                ;
280            }
281        } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
282            p = strchr(line + strlen(CONFIG_), '=');
283            if (!p)
284                continue;
285            *p++ = 0;
286            p2 = strchr(p, '\n');
287            if (p2) {
288                *p2-- = 0;
289                if (*p2 == '\r')
290                    *p2 = 0;
291            }
292            if (def == S_DEF_USER) {
293                sym = sym_find(line + strlen(CONFIG_));
294                if (!sym) {
295                    sym_add_change_count(1);
296                    goto setsym;
297                }
298            } else {
299                sym = sym_lookup(line + strlen(CONFIG_), 0);
300                if (sym->type == S_UNKNOWN)
301                    sym->type = S_OTHER;
302            }
303            if (sym->flags & def_flags) {
304                conf_warning("override: reassigning to symbol %s", sym->name);
305            }
306            if (conf_set_sym_val(sym, def, def_flags, p))
307                continue;
308        } else {
309            if (line[0] != '\r' && line[0] != '\n')
310                conf_warning("unexpected data");
311            continue;
312        }
313setsym:
314        if (sym && sym_is_choice_value(sym)) {
315            struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
316            switch (sym->def[def].tri) {
317            case no:
318                break;
319            case mod:
320                if (cs->def[def].tri == yes) {
321                    conf_warning("%s creates inconsistent choice state", sym->name);
322                    cs->flags &= ~def_flags;
323                }
324                break;
325            case yes:
326                if (cs->def[def].tri != no)
327                    conf_warning("override: %s changes choice state", sym->name);
328                cs->def[def].val = sym;
329                break;
330            }
331            cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
332        }
333    }
334    fclose(in);
335
336    if (modules_sym)
337        sym_calc_value(modules_sym);
338    return 0;
339}
340
341int conf_read(const char *name)
342{
343    struct symbol *sym, *choice_sym;
344    struct property *prop;
345    struct expr *e;
346    int i, flags;
347
348    sym_set_change_count(0);
349
350    if (conf_read_simple(name, S_DEF_USER))
351        return 1;
352
353    for_all_symbols(i, sym) {
354        sym_calc_value(sym);
355        if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
356            goto sym_ok;
357        if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
358            /* check that calculated value agrees with saved value */
359            switch (sym->type) {
360            case S_BOOLEAN:
361            case S_TRISTATE:
362                if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
363                    break;
364                if (!sym_is_choice(sym))
365                    goto sym_ok;
366            default:
367                if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
368                    goto sym_ok;
369                break;
370            }
371        } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
372            /* no previous value and not saved */
373            goto sym_ok;
374        conf_unsaved++;
375        /* maybe print value in verbose mode... */
376    sym_ok:
377        if (!sym_is_choice(sym))
378            continue;
379        /* The choice symbol only has a set value (and thus is not new)
380         * if all its visible childs have values.
381         */
382        prop = sym_get_choice_prop(sym);
383        flags = sym->flags;
384        expr_list_for_each_sym(prop->expr, e, choice_sym)
385            if (choice_sym->visible != no)
386                flags &= choice_sym->flags;
387        sym->flags &= flags | ~SYMBOL_DEF_USER;
388    }
389
390    for_all_symbols(i, sym) {
391        if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
392            /* Reset values of generates values, so they'll appear
393             * as new, if they should become visible, but that
394             * doesn't quite work if the Kconfig and the saved
395             * configuration disagree.
396             */
397            if (sym->visible == no && !conf_unsaved)
398                sym->flags &= ~SYMBOL_DEF_USER;
399            switch (sym->type) {
400            case S_STRING:
401            case S_INT:
402            case S_HEX:
403                /* Reset a string value if it's out of range */
404                if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))
405                    break;
406                sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
407                conf_unsaved++;
408                break;
409            default:
410                break;
411            }
412        }
413    }
414
415    sym_add_change_count(conf_warnings || conf_unsaved);
416
417    return 0;
418}
419
420/* Write a S_STRING */
421static void conf_write_string(bool headerfile, const char *name,
422                              const char *str, FILE *out)
423{
424    int l;
425    if (headerfile)
426        fprintf(out, "#define %s%s \"", CONFIG_, name);
427    else
428        fprintf(out, "%s%s=\"", CONFIG_, name);
429
430    while (1) {
431        l = strcspn(str, "\"\\");
432        if (l) {
433            xfwrite(str, l, 1, out);
434            str += l;
435        }
436        if (!*str)
437            break;
438        fprintf(out, "\\%c", *str++);
439    }
440    fputs("\"\n", out);
441}
442
443static void conf_write_symbol(struct symbol *sym, FILE *out, bool write_no)
444{
445    const char *str;
446
447    switch (sym->type) {
448    case S_BOOLEAN:
449    case S_TRISTATE:
450        switch (sym_get_tristate_value(sym)) {
451        case no:
452            if (write_no)
453                fprintf(out, "# %s%s is not set\n",
454                    CONFIG_, sym->name);
455            break;
456        case mod:
457            fprintf(out, "%s%s=m\n", CONFIG_, sym->name);
458            break;
459        case yes:
460            fprintf(out, "%s%s=y\n", CONFIG_, sym->name);
461            break;
462        }
463        break;
464    case S_STRING:
465        conf_write_string(false, sym->name, sym_get_string_value(sym), out);
466        break;
467    case S_HEX:
468    case S_INT:
469        str = sym_get_string_value(sym);
470        fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str);
471        break;
472    case S_OTHER:
473    case S_UNKNOWN:
474        break;
475    }
476}
477
478/*
479 * Write out a minimal config.
480 * All values that has default values are skipped as this is redundant.
481 */
482int conf_write_defconfig(const char *filename)
483{
484    struct symbol *sym;
485    struct menu *menu;
486    FILE *out;
487
488    out = fopen(filename, "w");
489    if (!out)
490        return 1;
491
492    sym_clear_all_valid();
493
494    /* Traverse all menus to find all relevant symbols */
495    menu = rootmenu.list;
496
497    while (menu != NULL)
498    {
499        sym = menu->sym;
500        if (sym == NULL) {
501            if (!menu_is_visible(menu))
502                goto next_menu;
503        } else if (!sym_is_choice(sym)) {
504            sym_calc_value(sym);
505            if (!(sym->flags & SYMBOL_WRITE))
506                goto next_menu;
507            sym->flags &= ~SYMBOL_WRITE;
508            /* If we cannot change the symbol - skip */
509            if (!sym_is_changable(sym))
510                goto next_menu;
511            /* If symbol equals to default value - skip */
512            if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
513                goto next_menu;
514
515            /*
516             * If symbol is a choice value and equals to the
517             * default for a choice - skip.
518             * But only if value is bool and equal to "y" and
519             * choice is not "optional".
520             * (If choice is "optional" then all values can be "n")
521             */
522            if (sym_is_choice_value(sym)) {
523                struct symbol *cs;
524                struct symbol *ds;
525
526                cs = prop_get_symbol(sym_get_choice_prop(sym));
527                ds = sym_choice_default(cs);
528                if (!sym_is_optional(cs) && sym == ds) {
529                    if ((sym->type == S_BOOLEAN) &&
530                        sym_get_tristate_value(sym) == yes)
531                        goto next_menu;
532                }
533            }
534            conf_write_symbol(sym, out, true);
535        }
536next_menu:
537        if (menu->list != NULL) {
538            menu = menu->list;
539        }
540        else if (menu->next != NULL) {
541            menu = menu->next;
542        } else {
543            while ((menu = menu->parent)) {
544                if (menu->next != NULL) {
545                    menu = menu->next;
546                    break;
547                }
548            }
549        }
550    }
551    fclose(out);
552    return 0;
553}
554
555int conf_write(const char *name)
556{
557    FILE *out;
558    struct symbol *sym;
559    struct menu *menu;
560    const char *basename;
561    const char *str;
562    char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];
563    char *env;
564
565    dirname[0] = 0;
566    if (name && name[0]) {
567        struct stat st;
568        char *slash;
569
570        if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
571            strcpy(dirname, name);
572            strcat(dirname, "/");
573            basename = conf_get_configname();
574        } else if ((slash = strrchr(name, '/'))) {
575            int size = slash - name + 1;
576            memcpy(dirname, name, size);
577            dirname[size] = 0;
578            if (slash[1])
579                basename = slash + 1;
580            else
581                basename = conf_get_configname();
582        } else
583            basename = name;
584    } else
585        basename = conf_get_configname();
586
587    sprintf(newname, "%s%s", dirname, basename);
588    env = getenv("KCONFIG_OVERWRITECONFIG");
589    if (!env || !*env) {
590        sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
591        out = fopen(tmpname, "w");
592    } else {
593        *tmpname = 0;
594        out = fopen(newname, "w");
595    }
596    if (!out)
597        return 1;
598
599    fprintf(out, _("#\n"
600               "# Automatically generated make config: don't edit\n"
601               "# %s\n"
602               "#\n"),
603             rootmenu.prompt->text);
604
605    if (!conf_get_changed())
606        sym_clear_all_valid();
607
608    menu = rootmenu.list;
609    while (menu) {
610        sym = menu->sym;
611        if (!sym) {
612            if (!menu_is_visible(menu))
613                goto next;
614            str = menu_get_prompt(menu);
615            fprintf(out, "\n"
616                     "#\n"
617                     "# %s\n"
618                     "#\n", str);
619        } else if (!(sym->flags & SYMBOL_CHOICE)) {
620            sym_calc_value(sym);
621            if (!(sym->flags & SYMBOL_WRITE))
622                goto next;
623            sym->flags &= ~SYMBOL_WRITE;
624            /* Write config symbol to file */
625            conf_write_symbol(sym, out, true);
626        }
627
628next:
629        if (menu->list) {
630            menu = menu->list;
631            continue;
632        }
633        if (menu->next)
634            menu = menu->next;
635        else while ((menu = menu->parent)) {
636            if (menu->next) {
637                menu = menu->next;
638                break;
639            }
640        }
641    }
642    fclose(out);
643
644    if (*tmpname) {
645        strcat(dirname, basename);
646        strcat(dirname, ".old");
647        rename(newname, dirname);
648        if (rename(tmpname, newname))
649            return 1;
650    }
651
652    conf_message(_("configuration written to %s"), newname);
653
654    sym_set_change_count(0);
655
656    return 0;
657}
658
659static int conf_split_config(void)
660{
661    const char *name;
662    char path[PATH_MAX+1];
663    char *s, *d, c;
664    struct symbol *sym;
665    struct stat sb;
666    int res, i, fd;
667
668    name = conf_get_autoconfig_name();
669    conf_read_simple(name, S_DEF_AUTO);
670
671    if (chdir("include/config"))
672        return 1;
673
674    res = 0;
675    for_all_symbols(i, sym) {
676        sym_calc_value(sym);
677        if ((sym->flags & SYMBOL_AUTO) || !sym->name)
678            continue;
679        if (sym->flags & SYMBOL_WRITE) {
680            if (sym->flags & SYMBOL_DEF_AUTO) {
681                /*
682                 * symbol has old and new value,
683                 * so compare them...
684                 */
685                switch (sym->type) {
686                case S_BOOLEAN:
687                case S_TRISTATE:
688                    if (sym_get_tristate_value(sym) ==
689                        sym->def[S_DEF_AUTO].tri)
690                        continue;
691                    break;
692                case S_STRING:
693                case S_HEX:
694                case S_INT:
695                    if (!strcmp(sym_get_string_value(sym),
696                            sym->def[S_DEF_AUTO].val))
697                        continue;
698                    break;
699                default:
700                    break;
701                }
702            } else {
703                /*
704                 * If there is no old value, only 'no' (unset)
705                 * is allowed as new value.
706                 */
707                switch (sym->type) {
708                case S_BOOLEAN:
709                case S_TRISTATE:
710                    if (sym_get_tristate_value(sym) == no)
711                        continue;
712                    break;
713                default:
714                    break;
715                }
716            }
717        } else if (!(sym->flags & SYMBOL_DEF_AUTO))
718            /* There is neither an old nor a new value. */
719            continue;
720        /* else
721         * There is an old value, but no new value ('no' (unset)
722         * isn't saved in auto.conf, so the old value is always
723         * different from 'no').
724         */
725
726        /* Replace all '_' and append ".h" */
727        s = sym->name;
728        d = path;
729        while ((c = *s++)) {
730            c = tolower(c);
731            *d++ = (c == '_') ? '/' : c;
732        }
733        strcpy(d, ".h");
734
735        /* Assume directory path already exists. */
736        fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
737        if (fd == -1) {
738            if (errno != ENOENT) {
739                res = 1;
740                break;
741            }
742            /*
743             * Create directory components,
744             * unless they exist already.
745             */
746            d = path;
747            while ((d = strchr(d, '/'))) {
748                *d = 0;
749                if (stat(path, &sb) && mkdir(path, 0755)) {
750                    res = 1;
751                    goto out;
752                }
753                *d++ = '/';
754            }
755            /* Try it again. */
756            fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
757            if (fd == -1) {
758                res = 1;
759                break;
760            }
761        }
762        close(fd);
763    }
764out:
765    if (chdir("../.."))
766        return 1;
767
768    return res;
769}
770
771int conf_write_autoconf(void)
772{
773    struct symbol *sym;
774    const char *str;
775    const char *name;
776    FILE *out, *tristate, *out_h;
777    int i;
778
779    sym_clear_all_valid();
780
781    file_write_dep("include/config/auto.conf.cmd");
782
783    if (conf_split_config())
784        return 1;
785
786    out = fopen(".tmpconfig", "w");
787    if (!out)
788        return 1;
789
790    tristate = fopen(".tmpconfig_tristate", "w");
791    if (!tristate) {
792        fclose(out);
793        return 1;
794    }
795
796    out_h = fopen(".tmpconfig.h", "w");
797    if (!out_h) {
798        fclose(out);
799        fclose(tristate);
800        return 1;
801    }
802
803    fprintf(out, "#\n"
804             "# Automatically generated make config: don't edit\n"
805             "# %s\n"
806             "#\n",
807             rootmenu.prompt->text);
808    fprintf(tristate, "#\n"
809              "# Automatically generated - do not edit\n"
810              "\n");
811    fprintf(out_h, "/*\n"
812               " * Automatically generated C config: don't edit\n"
813               " * %s\n"
814               " */\n",
815               rootmenu.prompt->text);
816
817    for_all_symbols(i, sym) {
818        sym_calc_value(sym);
819        if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
820            continue;
821
822        /* write symbol to config file */
823        conf_write_symbol(sym, out, false);
824
825        /* update autoconf and tristate files */
826        switch (sym->type) {
827        case S_BOOLEAN:
828        case S_TRISTATE:
829            switch (sym_get_tristate_value(sym)) {
830            case no:
831                break;
832            case mod:
833                fprintf(tristate, "%s%s=M\n",
834                    CONFIG_, sym->name);
835                fprintf(out_h, "#define %s%s_MODULE 1\n",
836                    CONFIG_, sym->name);
837                break;
838            case yes:
839                if (sym->type == S_TRISTATE)
840                    fprintf(tristate,"%s%s=Y\n",
841                        CONFIG_, sym->name);
842                fprintf(out_h, "#define %s%s 1\n",
843                    CONFIG_, sym->name);
844                break;
845            }
846            break;
847        case S_STRING:
848            conf_write_string(true, sym->name, sym_get_string_value(sym), out_h);
849            break;
850        case S_HEX:
851            str = sym_get_string_value(sym);
852            if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
853                fprintf(out_h, "#define %s%s 0x%s\n",
854                    CONFIG_, sym->name, str);
855                break;
856            }
857        case S_INT:
858            str = sym_get_string_value(sym);
859            fprintf(out_h, "#define %s%s %s\n",
860                CONFIG_, sym->name, str);
861            break;
862        default:
863            break;
864        }
865    }
866    fclose(out);
867    fclose(tristate);
868    fclose(out_h);
869
870    name = getenv("KCONFIG_AUTOHEADER");
871    if (!name)
872        name = "include/generated/autoconf.h";
873    if (rename(".tmpconfig.h", name))
874        return 1;
875    name = getenv("KCONFIG_TRISTATE");
876    if (!name)
877        name = "include/config/tristate.conf";
878    if (rename(".tmpconfig_tristate", name))
879        return 1;
880    name = conf_get_autoconfig_name();
881    /*
882     * This must be the last step, kbuild has a dependency on auto.conf
883     * and this marks the successful completion of the previous steps.
884     */
885    if (rename(".tmpconfig", name))
886        return 1;
887
888    return 0;
889}
890
891static int sym_change_count;
892static void (*conf_changed_callback)(void);
893
894void sym_set_change_count(int count)
895{
896    int _sym_change_count = sym_change_count;
897    sym_change_count = count;
898    if (conf_changed_callback &&
899        (bool)_sym_change_count != (bool)count)
900        conf_changed_callback();
901}
902
903void sym_add_change_count(int count)
904{
905    sym_set_change_count(count + sym_change_count);
906}
907
908bool conf_get_changed(void)
909{
910    return sym_change_count;
911}
912
913void conf_set_changed_callback(void (*fn)(void))
914{
915    conf_changed_callback = fn;
916}
917
918static void randomize_choice_values(struct symbol *csym)
919{
920    struct property *prop;
921    struct symbol *sym;
922    struct expr *e;
923    int cnt, def;
924
925    /*
926     * If choice is mod then we may have more items selected
927     * and if no then no-one.
928     * In both cases stop.
929     */
930    if (csym->curr.tri != yes)
931        return;
932
933    prop = sym_get_choice_prop(csym);
934
935    /* count entries in choice block */
936    cnt = 0;
937    expr_list_for_each_sym(prop->expr, e, sym)
938        cnt++;
939
940    /*
941     * find a random value and set it to yes,
942     * set the rest to no so we have only one set
943     */
944    def = (rand() % cnt);
945
946    cnt = 0;
947    expr_list_for_each_sym(prop->expr, e, sym) {
948        if (def == cnt++) {
949            sym->def[S_DEF_USER].tri = yes;
950            csym->def[S_DEF_USER].val = sym;
951        }
952        else {
953            sym->def[S_DEF_USER].tri = no;
954        }
955    }
956    csym->flags |= SYMBOL_DEF_USER;
957    /* clear VALID to get value calculated */
958    csym->flags &= ~(SYMBOL_VALID);
959}
960
961static void set_all_choice_values(struct symbol *csym)
962{
963    struct property *prop;
964    struct symbol *sym;
965    struct expr *e;
966
967    prop = sym_get_choice_prop(csym);
968
969    /*
970     * Set all non-assinged choice values to no
971     */
972    expr_list_for_each_sym(prop->expr, e, sym) {
973        if (!sym_has_value(sym))
974            sym->def[S_DEF_USER].tri = no;
975    }
976    csym->flags |= SYMBOL_DEF_USER;
977    /* clear VALID to get value calculated */
978    csym->flags &= ~(SYMBOL_VALID);
979}
980
981void conf_set_all_new_symbols(enum conf_def_mode mode)
982{
983    struct symbol *sym, *csym;
984    int i, cnt;
985
986    for_all_symbols(i, sym) {
987        if (sym_has_value(sym))
988            continue;
989        switch (sym_get_type(sym)) {
990        case S_BOOLEAN:
991        case S_TRISTATE:
992            switch (mode) {
993            case def_yes:
994                sym->def[S_DEF_USER].tri = yes;
995                break;
996            case def_mod:
997                sym->def[S_DEF_USER].tri = mod;
998                break;
999            case def_no:
1000                sym->def[S_DEF_USER].tri = no;
1001                break;
1002            case def_random:
1003                cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2;
1004                sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt);
1005                break;
1006            default:
1007                continue;
1008            }
1009            if (!(sym_is_choice(sym) && mode == def_random))
1010                sym->flags |= SYMBOL_DEF_USER;
1011            break;
1012        default:
1013            break;
1014        }
1015
1016    }
1017
1018    sym_clear_all_valid();
1019
1020    /*
1021     * We have different type of choice blocks.
1022     * If curr.tri equals to mod then we can select several
1023     * choice symbols in one block.
1024     * In this case we do nothing.
1025     * If curr.tri equals yes then only one symbol can be
1026     * selected in a choice block and we set it to yes,
1027     * and the rest to no.
1028     */
1029    for_all_symbols(i, csym) {
1030        if (sym_has_value(csym) || !sym_is_choice(csym))
1031            continue;
1032
1033        sym_calc_value(csym);
1034        if (mode == def_random)
1035            randomize_choice_values(csym);
1036        else
1037            set_all_choice_values(csym);
1038    }
1039}
1040

Archive Download this file



interactive