err.no Git - linux-2.6/blob - 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 struct symbol *sym_defconfig_list;
  34 struct symbol *modules_sym;
  35 tristate modules_val;
  36
  37 void sym_add_default(struct symbol *sym, const char *def)
  38 {
  39         struct property *prop = prop_alloc(P_DEFAULT, sym);
  40
  41         prop->expr = expr_alloc_symbol(sym_lookup(def, 1));
  42 }
  43
  44 void sym_init(void)
  45 {
  46         struct symbol *sym;
  47         struct utsname uts;
  48         char *p;
  49         static bool inited = false;
  50
  51         if (inited)
  52                 return;
  53         inited = true;
  54
  55         uname(&uts);
  56
  57         sym = sym_lookup("ARCH", 0);
  58         sym->type = S_STRING;
  59         sym->flags |= SYMBOL_AUTO;
  60         p = getenv("ARCH");
  61         if (p)
  62                 sym_add_default(sym, p);
  63
  64         sym = sym_lookup("KERNELVERSION", 0);
  65         sym->type = S_STRING;
  66         sym->flags |= SYMBOL_AUTO;
  67         p = getenv("KERNELVERSION");
  68         if (p)
  69                 sym_add_default(sym, p);
  70
  71         sym = sym_lookup("UNAME_RELEASE", 0);
  72         sym->type = S_STRING;
  73         sym->flags |= SYMBOL_AUTO;
  74         sym_add_default(sym, uts.release);
  75 }
  76
  77 enum symbol_type sym_get_type(struct symbol *sym)
  78 {
  79         enum symbol_type type = sym->type;
  80
  81         if (type == S_TRISTATE) {
  82                 if (sym_is_choice_value(sym) && sym->visible == yes)
  83                         type = S_BOOLEAN;
  84                 else if (modules_val == no)
  85                         type = S_BOOLEAN;
  86         }
  87         return type;
  88 }
  89
  90 const char *sym_type_name(enum symbol_type type)
  91 {
  92         switch (type) {
  93         case S_BOOLEAN:
  94                 return "boolean";
  95         case S_TRISTATE:
  96                 return "tristate";
  97         case S_INT:
  98                 return "integer";
  99         case S_HEX:
 100                 return "hex";
 101         case S_STRING:
 102                 return "string";
 103         case S_UNKNOWN:
 104                 return "unknown";
 105         case S_OTHER:
 106                 break;
 107         }
 108         return "???";
 109 }
 110
 111 struct property *sym_get_choice_prop(struct symbol *sym)
 112 {
 113         struct property *prop;
 114
 115         for_all_choices(sym, prop)
 116                 return prop;
 117         return NULL;
 118 }
 119
 120 struct property *sym_get_default_prop(struct symbol *sym)
 121 {
 122         struct property *prop;
 123
 124         for_all_defaults(sym, prop) {
 125                 prop->visible.tri = expr_calc_value(prop->visible.expr);
 126                 if (prop->visible.tri != no)
 127                         return prop;
 128         }
 129         return NULL;
 130 }
 131
 132 struct property *sym_get_range_prop(struct symbol *sym)
 133 {
 134         struct property *prop;
 135
 136         for_all_properties(sym, prop, P_RANGE) {
 137                 prop->visible.tri = expr_calc_value(prop->visible.expr);
 138                 if (prop->visible.tri != no)
 139                         return prop;
 140         }
 141         return NULL;
 142 }
 143
 144 static int sym_get_range_val(struct symbol *sym, int base)
 145 {
 146         sym_calc_value(sym);
 147         switch (sym->type) {
 148         case S_INT:
 149                 base = 10;
 150                 break;
 151         case S_HEX:
 152                 base = 16;
 153                 break;
 154         default:
 155                 break;
 156         }
 157         return strtol(sym->curr.val, NULL, base);
 158 }
 159
 160 static void sym_validate_range(struct symbol *sym)
 161 {
 162         struct property *prop;
 163         int base, val, val2;
 164         char str[64];
 165
 166         switch (sym->type) {
 167         case S_INT:
 168                 base = 10;
 169                 break;
 170         case S_HEX:
 171                 base = 16;
 172                 break;
 173         default:
 174                 return;
 175         }
 176         prop = sym_get_range_prop(sym);
 177         if (!prop)
 178                 return;
 179         val = strtol(sym->curr.val, NULL, base);
 180         val2 = sym_get_range_val(prop->expr->left.sym, base);
 181         if (val >= val2) {
 182                 val2 = sym_get_range_val(prop->expr->right.sym, base);
 183                 if (val <= val2)
 184                         return;
 185         }
 186         if (sym->type == S_INT)
 187                 sprintf(str, "%d", val2);
 188         else
 189                 sprintf(str, "0x%x", val2);
 190         sym->curr.val = strdup(str);
 191 }
 192
 193 static void sym_calc_visibility(struct symbol *sym)
 194 {
 195         struct property *prop;
 196         tristate tri;
 197
 198         /* any prompt visible? */
 199         tri = no;
 200         for_all_prompts(sym, prop) {
 201                 prop->visible.tri = expr_calc_value(prop->visible.expr);
 202                 tri = EXPR_OR(tri, prop->visible.tri);
 203         }
 204         if (tri == mod && (sym->type != S_TRISTATE || modules_val == no))
 205                 tri = yes;
 206         if (sym->visible != tri) {
 207                 sym->visible = tri;
 208                 sym_set_changed(sym);
 209         }
 210         if (sym_is_choice_value(sym))
 211                 return;
 212         tri = no;
 213         if (sym->rev_dep.expr)
 214                 tri = expr_calc_value(sym->rev_dep.expr);
 215         if (tri == mod && sym_get_type(sym) == S_BOOLEAN)
 216                 tri = yes;
 217         if (sym->rev_dep.tri != tri) {
 218                 sym->rev_dep.tri = tri;
 219                 sym_set_changed(sym);
 220         }
 221 }
 222
 223 static struct symbol *sym_calc_choice(struct symbol *sym)
 224 {
 225         struct symbol *def_sym;
 226         struct property *prop;
 227         struct expr *e;
 228
 229         /* is the user choice visible? */
 230         def_sym = sym->def[S_DEF_USER].val;
 231         if (def_sym) {
 232                 sym_calc_visibility(def_sym);
 233                 if (def_sym->visible != no)
 234                         return def_sym;
 235         }
 236
 237         /* any of the defaults visible? */
 238         for_all_defaults(sym, prop) {
 239                 prop->visible.tri = expr_calc_value(prop->visible.expr);
 240                 if (prop->visible.tri == no)
 241                         continue;
 242                 def_sym = prop_get_symbol(prop);
 243                 sym_calc_visibility(def_sym);
 244                 if (def_sym->visible != no)
 245                         return def_sym;
 246         }
 247
 248         /* just get the first visible value */
 249         prop = sym_get_choice_prop(sym);
 250         expr_list_for_each_sym(prop->expr, e, def_sym) {
 251                 sym_calc_visibility(def_sym);
 252                 if (def_sym->visible != no)
 253                         return def_sym;
 254         }
 255
 256         /* no choice? reset tristate value */
 257         sym->curr.tri = no;
 258         return NULL;
 259 }
 260
 261 void sym_calc_value(struct symbol *sym)
 262 {
 263         struct symbol_value newval, oldval;
 264         struct property *prop;
 265         struct expr *e;
 266
 267         if (!sym)
 268                 return;
 269
 270         if (sym->flags & SYMBOL_VALID)
 271                 return;
 272         sym->flags |= SYMBOL_VALID;
 273
 274         oldval = sym->curr;
 275
 276         switch (sym->type) {
 277         case S_INT:
 278         case S_HEX:
 279         case S_STRING:
 280                 newval = symbol_empty.curr;
 281                 break;
 282         case S_BOOLEAN:
 283         case S_TRISTATE:
 284                 newval = symbol_no.curr;
 285                 break;
 286         default:
 287                 sym->curr.val = sym->name;
 288                 sym->curr.tri = no;
 289                 return;
 290         }
 291         if (!sym_is_choice_value(sym))
 292                 sym->flags &= ~SYMBOL_WRITE;
 293
 294         sym_calc_visibility(sym);
 295
 296         /* set default if recursively called */
 297         sym->curr = newval;
 298
 299         switch (sym_get_type(sym)) {
 300         case S_BOOLEAN:
 301         case S_TRISTATE:
 302                 if (sym_is_choice_value(sym) && sym->visible == yes) {
 303                         prop = sym_get_choice_prop(sym);
 304                         newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no;
 305                 } else if (EXPR_OR(sym->visible, sym->rev_dep.tri) != no) {
 306                         sym->flags |= SYMBOL_WRITE;
 307                         if (sym_has_value(sym))
 308                                 newval.tri = sym->def[S_DEF_USER].tri;
 309                         else if (!sym_is_choice(sym)) {
 310                                 prop = sym_get_default_prop(sym);
 311                                 if (prop)
 312                                         newval.tri = expr_calc_value(prop->expr);
 313                         }
 314                         newval.tri = EXPR_OR(EXPR_AND(newval.tri, sym->visible), sym->rev_dep.tri);
 315                 } else if (!sym_is_choice(sym)) {
 316                         prop = sym_get_default_prop(sym);
 317                         if (prop) {
 318                                 sym->flags |= SYMBOL_WRITE;
 319                                 newval.tri = expr_calc_value(prop->expr);
 320                         }
 321                 }
 322                 if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN)
 323                         newval.tri = yes;
 324                 break;
 325         case S_STRING:
 326         case S_HEX:
 327         case S_INT:
 328                 if (sym->visible != no) {
 329                         sym->flags |= SYMBOL_WRITE;
 330                         if (sym_has_value(sym)) {
 331                                 newval.val = sym->def[S_DEF_USER].val;
 332                                 break;
 333                         }
 334                 }
 335                 prop = sym_get_default_prop(sym);
 336                 if (prop) {
 337                         struct symbol *ds = prop_get_symbol(prop);
 338                         if (ds) {
 339                                 sym->flags |= SYMBOL_WRITE;
 340                                 sym_calc_value(ds);
 341                                 newval.val = ds->curr.val;
 342                         }
 343                 }
 344                 break;
 345         default:
 346                 ;
 347         }
 348
 349         sym->curr = newval;
 350         if (sym_is_choice(sym) && newval.tri == yes)
 351                 sym->curr.val = sym_calc_choice(sym);
 352         sym_validate_range(sym);
 353
 354         if (memcmp(&oldval, &sym->curr, sizeof(oldval))) {
 355                 sym_set_changed(sym);
 356                 if (modules_sym == sym) {
 357                         sym_set_all_changed();
 358                         modules_val = modules_sym->curr.tri;
 359                 }
 360         }
 361
 362         if (sym_is_choice(sym)) {
 363                 struct symbol *choice_sym;
 364                 int flags = sym->flags & (SYMBOL_CHANGED | SYMBOL_WRITE);
 365
 366                 prop = sym_get_choice_prop(sym);
 367                 expr_list_for_each_sym(prop->expr, e, choice_sym) {
 368                         choice_sym->flags |= flags;
 369                         if (flags & SYMBOL_CHANGED)
 370                                 sym_set_changed(choice_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_add_change_count(1);
 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 /* return NULL when dependencies are OK */
 791 struct symbol *sym_check_deps(struct symbol *sym)
 792 {
 793         struct symbol *sym2;
 794         struct property *prop;
 795
 796         if (sym->flags & SYMBOL_CHECK) {
 797                 fprintf(stderr, "%s:%d:error: found recursive dependency: %s",
 798                         sym->prop->file->name, sym->prop->lineno, sym->name);
 799                 return sym;
 800         }
 801         if (sym->flags & SYMBOL_CHECKED)
 802                 return NULL;
 803
 804         sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
 805         sym2 = sym_check_expr_deps(sym->rev_dep.expr);
 806         if (sym2)
 807                 goto out;
 808
 809         for (prop = sym->prop; prop; prop = prop->next) {
 810                 if (prop->type == P_CHOICE || prop->type == P_SELECT)
 811                         continue;
 812                 sym2 = sym_check_expr_deps(prop->visible.expr);
 813                 if (sym2)
 814                         goto out;
 815                 if (prop->type != P_DEFAULT || sym_is_choice(sym))
 816                         continue;
 817                 sym2 = sym_check_expr_deps(prop->expr);
 818                 if (sym2)
 819                         goto out;
 820         }
 821 out:
 822         if (sym2)
 823                 fprintf(stderr, " -> %s%s", sym->name, sym2 == sym? "\n": "");
 824         sym->flags &= ~SYMBOL_CHECK;
 825         return sym2;
 826 }
 827
 828 struct property *prop_alloc(enum prop_type type, struct symbol *sym)
 829 {
 830         struct property *prop;
 831         struct property **propp;
 832
 833         prop = malloc(sizeof(*prop));
 834         memset(prop, 0, sizeof(*prop));
 835         prop->type = type;
 836         prop->sym = sym;
 837         prop->file = current_file;
 838         prop->lineno = zconf_lineno();
 839
 840         /* append property to the prop list of symbol */
 841         if (sym) {
 842                 for (propp = &sym->prop; *propp; propp = &(*propp)->next)
 843                         ;
 844                 *propp = prop;
 845         }
 846
 847         return prop;
 848 }
 849
 850 struct symbol *prop_get_symbol(struct property *prop)
 851 {
 852         if (prop->expr && (prop->expr->type == E_SYMBOL ||
 853                            prop->expr->type == E_LIST))
 854                 return prop->expr->left.sym;
 855         return NULL;
 856 }
 857
 858 const char *prop_get_type_name(enum prop_type type)
 859 {
 860         switch (type) {
 861         case P_PROMPT:
 862                 return "prompt";
 863         case P_COMMENT:
 864                 return "comment";
 865         case P_MENU:
 866                 return "menu";
 867         case P_DEFAULT:
 868                 return "default";
 869         case P_CHOICE:
 870                 return "choice";
 871         case P_SELECT:
 872                 return "select";
 873         case P_RANGE:
 874                 return "range";
 875         case P_UNKNOWN:
 876                 break;
 877         }
 878         return "unknown";
 879 }