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