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