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