linux/scripts/kconfig/symbol.c
<<
>>
Prefs
   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 <ctype.h>
   7#include <stdlib.h>
   8#include <string.h>
   9#include <regex.h>
  10#include <sys/utsname.h>
  11
  12#define LKC_DIRECT_LINK
  13#include "lkc.h"
  14
  15struct symbol symbol_yes = {
  16        .name = "y",
  17        .curr = { "y", yes },
  18        .flags = SYMBOL_CONST|SYMBOL_VALID,
  19}, symbol_mod = {
  20        .name = "m",
  21        .curr = { "m", mod },
  22        .flags = SYMBOL_CONST|SYMBOL_VALID,
  23}, symbol_no = {
  24        .name = "n",
  25        .curr = { "n", no },
  26        .flags = SYMBOL_CONST|SYMBOL_VALID,
  27}, symbol_empty = {
  28        .name = "",
  29        .curr = { "", no },
  30        .flags = SYMBOL_VALID,
  31};
  32
  33struct symbol *sym_defconfig_list;
  34struct symbol *modules_sym;
  35tristate modules_val;
  36
  37struct expr *sym_env_list;
  38
  39void sym_add_default(struct symbol *sym, const char *def)
  40{
  41        struct property *prop = prop_alloc(P_DEFAULT, sym);
  42
  43        prop->expr = expr_alloc_symbol(sym_lookup(def, SYMBOL_CONST));
  44}
  45
  46void sym_init(void)
  47{
  48        struct symbol *sym;
  49        struct utsname uts;
  50        static bool inited = false;
  51
  52        if (inited)
  53                return;
  54        inited = true;
  55
  56        uname(&uts);
  57
  58        sym = sym_lookup("UNAME_RELEASE", 0);
  59        sym->type = S_STRING;
  60        sym->flags |= SYMBOL_AUTO;
  61        sym_add_default(sym, uts.release);
  62}
  63
  64enum symbol_type sym_get_type(struct symbol *sym)
  65{
  66        enum symbol_type type = sym->type;
  67
  68        if (type == S_TRISTATE) {
  69                if (sym_is_choice_value(sym) && sym->visible == yes)
  70                        type = S_BOOLEAN;
  71                else if (modules_val == no)
  72                        type = S_BOOLEAN;
  73        }
  74        return type;
  75}
  76
  77const char *sym_type_name(enum symbol_type type)
  78{
  79        switch (type) {
  80        case S_BOOLEAN:
  81                return "boolean";
  82        case S_TRISTATE:
  83                return "tristate";
  84        case S_INT:
  85                return "integer";
  86        case S_HEX:
  87                return "hex";
  88        case S_STRING:
  89                return "string";
  90        case S_UNKNOWN:
  91                return "unknown";
  92        case S_OTHER:
  93                break;
  94        }
  95        return "???";
  96}
  97
  98struct property *sym_get_choice_prop(struct symbol *sym)
  99{
 100        struct property *prop;
 101
 102        for_all_choices(sym, prop)
 103                return prop;
 104        return NULL;
 105}
 106
 107struct property *sym_get_env_prop(struct symbol *sym)
 108{
 109        struct property *prop;
 110
 111        for_all_properties(sym, prop, P_ENV)
 112                return prop;
 113        return NULL;
 114}
 115
 116struct property *sym_get_default_prop(struct symbol *sym)
 117{
 118        struct property *prop;
 119
 120        for_all_defaults(sym, prop) {
 121                prop->visible.tri = expr_calc_value(prop->visible.expr);
 122                if (prop->visible.tri != no)
 123                        return prop;
 124        }
 125        return NULL;
 126}
 127
 128struct property *sym_get_range_prop(struct symbol *sym)
 129{
 130        struct property *prop;
 131
 132        for_all_properties(sym, prop, P_RANGE) {
 133                prop->visible.tri = expr_calc_value(prop->visible.expr);
 134                if (prop->visible.tri != no)
 135                        return prop;
 136        }
 137        return NULL;
 138}
 139
 140static int sym_get_range_val(struct symbol *sym, int base)
 141{
 142        sym_calc_value(sym);
 143        switch (sym->type) {
 144        case S_INT:
 145                base = 10;
 146                break;
 147        case S_HEX:
 148                base = 16;
 149                break;
 150        default:
 151                break;
 152        }
 153        return strtol(sym->curr.val, NULL, base);
 154}
 155
 156static void sym_validate_range(struct symbol *sym)
 157{
 158        struct property *prop;
 159        int base, val, val2;
 160        char str[64];
 161
 162        switch (sym->type) {
 163        case S_INT:
 164                base = 10;
 165                break;
 166        case S_HEX:
 167                base = 16;
 168                break;
 169        default:
 170                return;
 171        }
 172        prop = sym_get_range_prop(sym);
 173        if (!prop)
 174                return;
 175        val = strtol(sym->curr.val, NULL, base);
 176        val2 = sym_get_range_val(prop->expr->left.sym, base);
 177        if (val >= val2) {
 178                val2 = sym_get_range_val(prop->expr->right.sym, base);
 179                if (val <= val2)
 180                        return;
 181        }
 182        if (sym->type == S_INT)
 183                sprintf(str, "%d", val2);
 184        else
 185                sprintf(str, "0x%x", val2);
 186        sym->curr.val = strdup(str);
 187}
 188
 189static void sym_calc_visibility(struct symbol *sym)
 190{
 191        struct property *prop;
 192        tristate tri;
 193
 194        /* any prompt visible? */
 195        tri = no;
 196        for_all_prompts(sym, prop) {
 197                prop->visible.tri = expr_calc_value(prop->visible.expr);
 198                tri = EXPR_OR(tri, prop->visible.tri);
 199        }
 200        if (tri == mod && (sym->type != S_TRISTATE || modules_val == no))
 201                tri = yes;
 202        if (sym->visible != tri) {
 203                sym->visible = tri;
 204                sym_set_changed(sym);
 205        }
 206        if (sym_is_choice_value(sym))
 207                return;
 208        tri = no;
 209        if (sym->rev_dep.expr)
 210                tri = expr_calc_value(sym->rev_dep.expr);
 211        if (tri == mod && sym_get_type(sym) == S_BOOLEAN)
 212                tri = yes;
 213        if (sym->rev_dep.tri != tri) {
 214                sym->rev_dep.tri = tri;
 215                sym_set_changed(sym);
 216        }
 217}
 218
 219static struct symbol *sym_calc_choice(struct symbol *sym)
 220{
 221        struct symbol *def_sym;
 222        struct property *prop;
 223        struct expr *e;
 224
 225        /* is the user choice visible? */
 226        def_sym = sym->def[S_DEF_USER].val;
 227        if (def_sym) {
 228                sym_calc_visibility(def_sym);
 229                if (def_sym->visible != no)
 230                        return def_sym;
 231        }
 232
 233        /* any of the defaults visible? */
 234        for_all_defaults(sym, prop) {
 235                prop->visible.tri = expr_calc_value(prop->visible.expr);
 236                if (prop->visible.tri == no)
 237                        continue;
 238                def_sym = prop_get_symbol(prop);
 239                sym_calc_visibility(def_sym);
 240                if (def_sym->visible != no)
 241                        return def_sym;
 242        }
 243
 244        /* just get the first visible value */
 245        prop = sym_get_choice_prop(sym);
 246        expr_list_for_each_sym(prop->expr, e, def_sym) {
 247                sym_calc_visibility(def_sym);
 248                if (def_sym->visible != no)
 249                        return def_sym;
 250        }
 251
 252        /* no choice? reset tristate value */
 253        sym->curr.tri = no;
 254        return NULL;
 255}
 256
 257void sym_calc_value(struct symbol *sym)
 258{
 259        struct symbol_value newval, oldval;
 260        struct property *prop;
 261        struct expr *e;
 262
 263        if (!sym)
 264                return;
 265
 266        if (sym->flags & SYMBOL_VALID)
 267                return;
 268        sym->flags |= SYMBOL_VALID;
 269
 270        oldval = sym->curr;
 271
 272        switch (sym->type) {
 273        case S_INT:
 274        case S_HEX:
 275        case S_STRING:
 276                newval = symbol_empty.curr;
 277                break;
 278        case S_BOOLEAN:
 279        case S_TRISTATE:
 280                newval = symbol_no.curr;
 281                break;
 282        default:
 283                sym->curr.val = sym->name;
 284                sym->curr.tri = no;
 285                return;
 286        }
 287        if (!sym_is_choice_value(sym))
 288                sym->flags &= ~SYMBOL_WRITE;
 289
 290        sym_calc_visibility(sym);
 291
 292        /* set default if recursively called */
 293        sym->curr = newval;
 294
 295        switch (sym_get_type(sym)) {
 296        case S_BOOLEAN:
 297        case S_TRISTATE:
 298                if (sym_is_choice_value(sym) && sym->visible == yes) {
 299                        prop = sym_get_choice_prop(sym);
 300                        newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no;
 301                } else {
 302                        if (sym->visible != no) {
 303                                /* if the symbol is visible use the user value
 304                                 * if available, otherwise try the default value
 305                                 */
 306                                sym->flags |= SYMBOL_WRITE;
 307                                if (sym_has_value(sym)) {
 308                                        newval.tri = EXPR_AND(sym->def[S_DEF_USER].tri,
 309                                                              sym->visible);
 310                                        goto calc_newval;
 311                                }
 312                        }
 313                        if (sym->rev_dep.tri != no)
 314                                sym->flags |= SYMBOL_WRITE;
 315                        if (!sym_is_choice(sym)) {
 316                                prop = sym_get_default_prop(sym);
 317                                if (prop) {
 318                                        sym->flags |= SYMBOL_WRITE;
 319                                        newval.tri = EXPR_AND(expr_calc_value(prop->expr),
 320                                                              prop->visible.tri);
 321                                }
 322                        }
 323                calc_newval:
 324                        newval.tri = EXPR_OR(newval.tri, sym->rev_dep.tri);
 325                }
 326                if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN)
 327                        newval.tri = yes;
 328                break;
 329        case S_STRING:
 330        case S_HEX:
 331        case S_INT:
 332                if (sym->visible != no) {
 333                        sym->flags |= SYMBOL_WRITE;
 334                        if (sym_has_value(sym)) {
 335                                newval.val = sym->def[S_DEF_USER].val;
 336                                break;
 337                        }
 338                }
 339                prop = sym_get_default_prop(sym);
 340                if (prop) {
 341                        struct symbol *ds = prop_get_symbol(prop);
 342                        if (ds) {
 343                                sym->flags |= SYMBOL_WRITE;
 344                                sym_calc_value(ds);
 345                                newval.val = ds->curr.val;
 346                        }
 347                }
 348                break;
 349        default:
 350                ;
 351        }
 352
 353        sym->curr = newval;
 354        if (sym_is_choice(sym) && newval.tri == yes)
 355                sym->curr.val = sym_calc_choice(sym);
 356        sym_validate_range(sym);
 357
 358        if (memcmp(&oldval, &sym->curr, sizeof(oldval))) {
 359                sym_set_changed(sym);
 360                if (modules_sym == sym) {
 361                        sym_set_all_changed();
 362                        modules_val = modules_sym->curr.tri;
 363                }
 364        }
 365
 366        if (sym_is_choice(sym)) {
 367                struct symbol *choice_sym;
 368                int flags = sym->flags & (SYMBOL_CHANGED | SYMBOL_WRITE);
 369
 370                prop = sym_get_choice_prop(sym);
 371                expr_list_for_each_sym(prop->expr, e, choice_sym) {
 372                        choice_sym->flags |= flags;
 373                        if (flags & SYMBOL_CHANGED)
 374                                sym_set_changed(choice_sym);
 375                }
 376        }
 377
 378        if (sym->flags & SYMBOL_AUTO)
 379                sym->flags &= ~SYMBOL_WRITE;
 380}
 381
 382void sym_clear_all_valid(void)
 383{
 384        struct symbol *sym;
 385        int i;
 386
 387        for_all_symbols(i, sym)
 388                sym->flags &= ~SYMBOL_VALID;
 389        sym_add_change_count(1);
 390        if (modules_sym)
 391                sym_calc_value(modules_sym);
 392}
 393
 394void sym_set_changed(struct symbol *sym)
 395{
 396        struct property *prop;
 397
 398        sym->flags |= SYMBOL_CHANGED;
 399        for (prop = sym->prop; prop; prop = prop->next) {
 400                if (prop->menu)
 401                        prop->menu->flags |= MENU_CHANGED;
 402        }
 403}
 404
 405void sym_set_all_changed(void)
 406{
 407        struct symbol *sym;
 408        int i;
 409
 410        for_all_symbols(i, sym)
 411                sym_set_changed(sym);
 412}
 413
 414bool sym_tristate_within_range(struct symbol *sym, tristate val)
 415{
 416        int type = sym_get_type(sym);
 417
 418        if (sym->visible == no)
 419                return false;
 420
 421        if (type != S_BOOLEAN && type != S_TRISTATE)
 422                return false;
 423
 424        if (type == S_BOOLEAN && val == mod)
 425                return false;
 426        if (sym->visible <= sym->rev_dep.tri)
 427                return false;
 428        if (sym_is_choice_value(sym) && sym->visible == yes)
 429                return val == yes;
 430        return val >= sym->rev_dep.tri && val <= sym->visible;
 431}
 432
 433bool sym_set_tristate_value(struct symbol *sym, tristate val)
 434{
 435        tristate oldval = sym_get_tristate_value(sym);
 436
 437        if (oldval != val && !sym_tristate_within_range(sym, val))
 438                return false;
 439
 440        if (!(sym->flags & SYMBOL_DEF_USER)) {
 441                sym->flags |= SYMBOL_DEF_USER;
 442                sym_set_changed(sym);
 443        }
 444        /*
 445         * setting a choice value also resets the new flag of the choice
 446         * symbol and all other choice values.
 447         */
 448        if (sym_is_choice_value(sym) && val == yes) {
 449                struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
 450                struct property *prop;
 451                struct expr *e;
 452
 453                cs->def[S_DEF_USER].val = sym;
 454                cs->flags |= SYMBOL_DEF_USER;
 455                prop = sym_get_choice_prop(cs);
 456                for (e = prop->expr; e; e = e->left.expr) {
 457                        if (e->right.sym->visible != no)
 458                                e->right.sym->flags |= SYMBOL_DEF_USER;
 459                }
 460        }
 461
 462        sym->def[S_DEF_USER].tri = val;
 463        if (oldval != val)
 464                sym_clear_all_valid();
 465
 466        return true;
 467}
 468
 469tristate sym_toggle_tristate_value(struct symbol *sym)
 470{
 471        tristate oldval, newval;
 472
 473        oldval = newval = sym_get_tristate_value(sym);
 474        do {
 475                switch (newval) {
 476                case no:
 477                        newval = mod;
 478                        break;
 479                case mod:
 480                        newval = yes;
 481                        break;
 482                case yes:
 483                        newval = no;
 484                        break;
 485                }
 486                if (sym_set_tristate_value(sym, newval))
 487                        break;
 488        } while (oldval != newval);
 489        return newval;
 490}
 491
 492bool sym_string_valid(struct symbol *sym, const char *str)
 493{
 494        signed char ch;
 495
 496        switch (sym->type) {
 497        case S_STRING:
 498                return true;
 499        case S_INT:
 500                ch = *str++;
 501                if (ch == '-')
 502                        ch = *str++;
 503                if (!isdigit(ch))
 504                        return false;
 505                if (ch == '0' && *str != 0)
 506                        return false;
 507                while ((ch = *str++)) {
 508                        if (!isdigit(ch))
 509                                return false;
 510                }
 511                return true;
 512        case S_HEX:
 513                if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
 514                        str += 2;
 515                ch = *str++;
 516                do {
 517                        if (!isxdigit(ch))
 518                                return false;
 519                } while ((ch = *str++));
 520                return true;
 521        case S_BOOLEAN:
 522        case S_TRISTATE:
 523                switch (str[0]) {
 524                case 'y': case 'Y':
 525                case 'm': case 'M':
 526                case 'n': case 'N':
 527                        return true;
 528                }
 529                return false;
 530        default:
 531                return false;
 532        }
 533}
 534
 535bool sym_string_within_range(struct symbol *sym, const char *str)
 536{
 537        struct property *prop;
 538        int val;
 539
 540        switch (sym->type) {
 541        case S_STRING:
 542                return sym_string_valid(sym, str);
 543        case S_INT:
 544                if (!sym_string_valid(sym, str))
 545                        return false;
 546                prop = sym_get_range_prop(sym);
 547                if (!prop)
 548                        return true;
 549                val = strtol(str, NULL, 10);
 550                return val >= sym_get_range_val(prop->expr->left.sym, 10) &&
 551                       val <= sym_get_range_val(prop->expr->right.sym, 10);
 552        case S_HEX:
 553                if (!sym_string_valid(sym, str))
 554                        return false;
 555                prop = sym_get_range_prop(sym);
 556                if (!prop)
 557                        return true;
 558                val = strtol(str, NULL, 16);
 559                return val >= sym_get_range_val(prop->expr->left.sym, 16) &&
 560                       val <= sym_get_range_val(prop->expr->right.sym, 16);
 561        case S_BOOLEAN:
 562        case S_TRISTATE:
 563                switch (str[0]) {
 564                case 'y': case 'Y':
 565                        return sym_tristate_within_range(sym, yes);
 566                case 'm': case 'M':
 567                        return sym_tristate_within_range(sym, mod);
 568                case 'n': case 'N':
 569                        return sym_tristate_within_range(sym, no);
 570                }
 571                return false;
 572        default:
 573                return false;
 574        }
 575}
 576
 577bool sym_set_string_value(struct symbol *sym, const char *newval)
 578{
 579        const char *oldval;
 580        char *val;
 581        int size;
 582
 583        switch (sym->type) {
 584        case S_BOOLEAN:
 585        case S_TRISTATE:
 586                switch (newval[0]) {
 587                case 'y': case 'Y':
 588                        return sym_set_tristate_value(sym, yes);
 589                case 'm': case 'M':
 590                        return sym_set_tristate_value(sym, mod);
 591                case 'n': case 'N':
 592                        return sym_set_tristate_value(sym, no);
 593                }
 594                return false;
 595        default:
 596                ;
 597        }
 598
 599        if (!sym_string_within_range(sym, newval))
 600                return false;
 601
 602        if (!(sym->flags & SYMBOL_DEF_USER)) {
 603                sym->flags |= SYMBOL_DEF_USER;
 604                sym_set_changed(sym);
 605        }
 606
 607        oldval = sym->def[S_DEF_USER].val;
 608        size = strlen(newval) + 1;
 609        if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) {
 610                size += 2;
 611                sym->def[S_DEF_USER].val = val = malloc(size);
 612                *val++ = '0';
 613                *val++ = 'x';
 614        } else if (!oldval || strcmp(oldval, newval))
 615                sym->def[S_DEF_USER].val = val = malloc(size);
 616        else
 617                return true;
 618
 619        strcpy(val, newval);
 620        free((void *)oldval);
 621        sym_clear_all_valid();
 622
 623        return true;
 624}
 625
 626const char *sym_get_string_value(struct symbol *sym)
 627{
 628        tristate val;
 629
 630        switch (sym->type) {
 631        case S_BOOLEAN:
 632        case S_TRISTATE:
 633                val = sym_get_tristate_value(sym);
 634                switch (val) {
 635                case no:
 636                        return "n";
 637                case mod:
 638                        return "m";
 639                case yes:
 640                        return "y";
 641                }
 642                break;
 643        default:
 644                ;
 645        }
 646        return (const char *)sym->curr.val;
 647}
 648
 649bool sym_is_changable(struct symbol *sym)
 650{
 651        return sym->visible > sym->rev_dep.tri;
 652}
 653
 654struct symbol *sym_lookup(const char *name, int flags)
 655{
 656        struct symbol *symbol;
 657        const char *ptr;
 658        char *new_name;
 659        int hash = 0;
 660
 661        if (name) {
 662                if (name[0] && !name[1]) {
 663                        switch (name[0]) {
 664                        case 'y': return &symbol_yes;
 665                        case 'm': return &symbol_mod;
 666                        case 'n': return &symbol_no;
 667                        }
 668                }
 669                for (ptr = name; *ptr; ptr++)
 670                        hash += *ptr;
 671                hash &= 0xff;
 672
 673                for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
 674                        if (!strcmp(symbol->name, name) &&
 675                            (flags ? symbol->flags & flags
 676                                   : !(symbol->flags & (SYMBOL_CONST|SYMBOL_CHOICE))))
 677                                return symbol;
 678                }
 679                new_name = strdup(name);
 680        } else {
 681                new_name = NULL;
 682                hash = 256;
 683        }
 684
 685        symbol = malloc(sizeof(*symbol));
 686        memset(symbol, 0, sizeof(*symbol));
 687        symbol->name = new_name;
 688        symbol->type = S_UNKNOWN;
 689        symbol->flags |= flags;
 690
 691        symbol->next = symbol_hash[hash];
 692        symbol_hash[hash] = symbol;
 693
 694        return symbol;
 695}
 696
 697struct symbol *sym_find(const char *name)
 698{
 699        struct symbol *symbol = NULL;
 700        const char *ptr;
 701        int hash = 0;
 702
 703        if (!name)
 704                return NULL;
 705
 706        if (name[0] && !name[1]) {
 707                switch (name[0]) {
 708                case 'y': return &symbol_yes;
 709                case 'm': return &symbol_mod;
 710                case 'n': return &symbol_no;
 711                }
 712        }
 713        for (ptr = name; *ptr; ptr++)
 714                hash += *ptr;
 715        hash &= 0xff;
 716
 717        for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
 718                if (!strcmp(symbol->name, name) &&
 719                    !(symbol->flags & SYMBOL_CONST))
 720                                break;
 721        }
 722
 723        return symbol;
 724}
 725
 726struct symbol **sym_re_search(const char *pattern)
 727{
 728        struct symbol *sym, **sym_arr = NULL;
 729        int i, cnt, size;
 730        regex_t re;
 731
 732        cnt = size = 0;
 733        /* Skip if empty */
 734        if (strlen(pattern) == 0)
 735                return NULL;
 736        if (regcomp(&re, pattern, REG_EXTENDED|REG_NOSUB|REG_ICASE))
 737                return NULL;
 738
 739        for_all_symbols(i, sym) {
 740                if (sym->flags & SYMBOL_CONST || !sym->name)
 741                        continue;
 742                if (regexec(&re, sym->name, 0, NULL, 0))
 743                        continue;
 744                if (cnt + 1 >= size) {
 745                        void *tmp = sym_arr;
 746                        size += 16;
 747                        sym_arr = realloc(sym_arr, size * sizeof(struct symbol *));
 748                        if (!sym_arr) {
 749                                free(tmp);
 750                                return NULL;
 751                        }
 752                }
 753                sym_arr[cnt++] = sym;
 754        }
 755        if (sym_arr)
 756                sym_arr[cnt] = NULL;
 757        regfree(&re);
 758
 759        return sym_arr;
 760}
 761
 762
 763static struct symbol *sym_check_expr_deps(struct expr *e)
 764{
 765        struct symbol *sym;
 766
 767        if (!e)
 768                return NULL;
 769        switch (e->type) {
 770        case E_OR:
 771        case E_AND:
 772                sym = sym_check_expr_deps(e->left.expr);
 773                if (sym)
 774                        return sym;
 775                return sym_check_expr_deps(e->right.expr);
 776        case E_NOT:
 777                return sym_check_expr_deps(e->left.expr);
 778        case E_EQUAL:
 779        case E_UNEQUAL:
 780                sym = sym_check_deps(e->left.sym);
 781                if (sym)
 782                        return sym;
 783                return sym_check_deps(e->right.sym);
 784        case E_SYMBOL:
 785                return sym_check_deps(e->left.sym);
 786        default:
 787                break;
 788        }
 789        printf("Oops! How to check %d?\n", e->type);
 790        return NULL;
 791}
 792
 793/* return NULL when dependencies are OK */
 794static struct symbol *sym_check_sym_deps(struct symbol *sym)
 795{
 796        struct symbol *sym2;
 797        struct property *prop;
 798
 799        sym2 = sym_check_expr_deps(sym->rev_dep.expr);
 800        if (sym2)
 801                return sym2;
 802
 803        for (prop = sym->prop; prop; prop = prop->next) {
 804                if (prop->type == P_CHOICE || prop->type == P_SELECT)
 805                        continue;
 806                sym2 = sym_check_expr_deps(prop->visible.expr);
 807                if (sym2)
 808                        break;
 809                if (prop->type != P_DEFAULT || sym_is_choice(sym))
 810                        continue;
 811                sym2 = sym_check_expr_deps(prop->expr);
 812                if (sym2)
 813                        break;
 814        }
 815
 816        return sym2;
 817}
 818
 819static struct symbol *sym_check_choice_deps(struct symbol *choice)
 820{
 821        struct symbol *sym, *sym2;
 822        struct property *prop;
 823        struct expr *e;
 824
 825        prop = sym_get_choice_prop(choice);
 826        expr_list_for_each_sym(prop->expr, e, sym)
 827                sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
 828
 829        choice->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
 830        sym2 = sym_check_sym_deps(choice);
 831        choice->flags &= ~SYMBOL_CHECK;
 832        if (sym2)
 833                goto out;
 834
 835        expr_list_for_each_sym(prop->expr, e, sym) {
 836                sym2 = sym_check_sym_deps(sym);
 837                if (sym2) {
 838                        fprintf(stderr, " -> %s", sym->name);
 839                        break;
 840                }
 841        }
 842out:
 843        expr_list_for_each_sym(prop->expr, e, sym)
 844                sym->flags &= ~SYMBOL_CHECK;
 845
 846        if (sym2 && sym_is_choice_value(sym2) &&
 847            prop_get_symbol(sym_get_choice_prop(sym2)) == choice)
 848                sym2 = choice;
 849
 850        return sym2;
 851}
 852
 853struct symbol *sym_check_deps(struct symbol *sym)
 854{
 855        struct symbol *sym2;
 856        struct property *prop;
 857
 858        if (sym->flags & SYMBOL_CHECK) {
 859                fprintf(stderr, "%s:%d:error: found recursive dependency: %s",
 860                        sym->prop->file->name, sym->prop->lineno,
 861                        sym->name ? sym->name : "<choice>");
 862                return sym;
 863        }
 864        if (sym->flags & SYMBOL_CHECKED)
 865                return NULL;
 866
 867        if (sym_is_choice_value(sym)) {
 868                /* for choice groups start the check with main choice symbol */
 869                prop = sym_get_choice_prop(sym);
 870                sym2 = sym_check_deps(prop_get_symbol(prop));
 871        } else if (sym_is_choice(sym)) {
 872                sym2 = sym_check_choice_deps(sym);
 873        } else {
 874                sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
 875                sym2 = sym_check_sym_deps(sym);
 876                sym->flags &= ~SYMBOL_CHECK;
 877        }
 878
 879        if (sym2) {
 880                fprintf(stderr, " -> %s", sym->name ? sym->name : "<choice>");
 881                if (sym2 == sym) {
 882                        fprintf(stderr, "\n");
 883                        zconfnerrs++;
 884                        sym2 = NULL;
 885                }
 886        }
 887
 888        return sym2;
 889}
 890
 891struct property *prop_alloc(enum prop_type type, struct symbol *sym)
 892{
 893        struct property *prop;
 894        struct property **propp;
 895
 896        prop = malloc(sizeof(*prop));
 897        memset(prop, 0, sizeof(*prop));
 898        prop->type = type;
 899        prop->sym = sym;
 900        prop->file = current_file;
 901        prop->lineno = zconf_lineno();
 902
 903        /* append property to the prop list of symbol */
 904        if (sym) {
 905                for (propp = &sym->prop; *propp; propp = &(*propp)->next)
 906                        ;
 907                *propp = prop;
 908        }
 909
 910        return prop;
 911}
 912
 913struct symbol *prop_get_symbol(struct property *prop)
 914{
 915        if (prop->expr && (prop->expr->type == E_SYMBOL ||
 916                           prop->expr->type == E_LIST))
 917                return prop->expr->left.sym;
 918        return NULL;
 919}
 920
 921const char *prop_get_type_name(enum prop_type type)
 922{
 923        switch (type) {
 924        case P_PROMPT:
 925                return "prompt";
 926        case P_ENV:
 927                return "env";
 928        case P_COMMENT:
 929                return "comment";
 930        case P_MENU:
 931                return "menu";
 932        case P_DEFAULT:
 933                return "default";
 934        case P_CHOICE:
 935                return "choice";
 936        case P_SELECT:
 937                return "select";
 938        case P_RANGE:
 939                return "range";
 940        case P_UNKNOWN:
 941                break;
 942        }
 943        return "unknown";
 944}
 945
 946void prop_add_env(const char *env)
 947{
 948        struct symbol *sym, *sym2;
 949        struct property *prop;
 950        char *p;
 951
 952        sym = current_entry->sym;
 953        sym->flags |= SYMBOL_AUTO;
 954        for_all_properties(sym, prop, P_ENV) {
 955                sym2 = prop_get_symbol(prop);
 956                if (strcmp(sym2->name, env))
 957                        menu_warn(current_entry, "redefining environment symbol from %s",
 958                                  sym2->name);
 959                return;
 960        }
 961
 962        prop = prop_alloc(P_ENV, sym);
 963        prop->expr = expr_alloc_symbol(sym_lookup(env, SYMBOL_CONST));
 964
 965        sym_env_list = expr_alloc_one(E_LIST, sym_env_list);
 966        sym_env_list->right.sym = sym;
 967
 968        p = getenv(env);
 969        if (p)
 970                sym_add_default(sym, p);
 971        else
 972                menu_warn(current_entry, "environment variable %s undefined", env);
 973}
 974