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