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 #include "lkc.h" 13 14 struct symbol symbol_yes = { 15 .name = "y", 16 .curr = { "y", yes }, 17 .flags = SYMBOL_CONST|SYMBOL_VALID, 18 }, symbol_mod = { 19 .name = "m", 20 .curr = { "m", mod }, 21 .flags = SYMBOL_CONST|SYMBOL_VALID, 22 }, symbol_no = { 23 .name = "n", 24 .curr = { "n", no }, 25 .flags = SYMBOL_CONST|SYMBOL_VALID, 26 }, symbol_empty = { 27 .name = "", 28 .curr = { "", no }, 29 .flags = SYMBOL_VALID, 30 }; 31 32 struct symbol *sym_defconfig_list; 33 struct symbol *modules_sym; 34 tristate modules_val; 35 36 struct expr *sym_env_list; 37 38 static void sym_add_default(struct symbol *sym, const char *def) 39 { 40 struct property *prop = prop_alloc(P_DEFAULT, sym); 41 42 prop->expr = expr_alloc_symbol(sym_lookup(def, SYMBOL_CONST)); 43 } 44 45 void sym_init(void) 46 { 47 struct symbol *sym; 48 struct utsname uts; 49 static bool inited = false; 50 51 if (inited) 52 return; 53 inited = true; 54 55 uname(&uts); 56 57 sym = sym_lookup("UNAME_RELEASE", 0); 58 sym->type = S_STRING; 59 sym->flags |= SYMBOL_AUTO; 60 sym_add_default(sym, uts.release); 61 } 62 63 enum symbol_type sym_get_type(struct symbol *sym) 64 { 65 enum symbol_type type = sym->type; 66 67 if (type == S_TRISTATE) { 68 if (sym_is_choice_value(sym) && sym->visible == yes) 69 type = S_BOOLEAN; 70 else if (modules_val == no) 71 type = S_BOOLEAN; 72 } 73 return type; 74 } 75 76 const char *sym_type_name(enum symbol_type type) 77 { 78 switch (type) { 79 case S_BOOLEAN: 80 return "bool"; 81 case S_TRISTATE: 82 return "tristate"; 83 case S_INT: 84 return "integer"; 85 case S_HEX: 86 return "hex"; 87 case S_STRING: 88 return "string"; 89 case S_UNKNOWN: 90 return "unknown"; 91 case S_OTHER: 92 break; 93 } 94 return "???"; 95 } 96 97 struct property *sym_get_choice_prop(struct symbol *sym) 98 { 99 struct property *prop; 100 101 for_all_choices(sym, prop) 102 return prop; 103 return NULL; 104 } 105 106 struct property *sym_get_env_prop(struct symbol *sym) 107 { 108 struct property *prop; 109 110 for_all_properties(sym, prop, P_ENV) 111 return prop; 112 return NULL; 113 } 114 115 static struct property *sym_get_default_prop(struct symbol *sym) 116 { 117 struct property *prop; 118 119 for_all_defaults(sym, prop) { 120 prop->visible.tri = expr_calc_value(prop->visible.expr); 121 if (prop->visible.tri != no) 122 return prop; 123 } 124 return NULL; 125 } 126 127 static struct property *sym_get_range_prop(struct symbol *sym) 128 { 129 struct property *prop; 130 131 for_all_properties(sym, prop, P_RANGE) { 132 prop->visible.tri = expr_calc_value(prop->visible.expr); 133 if (prop->visible.tri != no) 134 return prop; 135 } 136 return NULL; 137 } 138 139 static long long sym_get_range_val(struct symbol *sym, int base) 140 { 141 sym_calc_value(sym); 142 switch (sym->type) { 143 case S_INT: 144 base = 10; 145 break; 146 case S_HEX: 147 base = 16; 148 break; 149 default: 150 break; 151 } 152 return strtoll(sym->curr.val, NULL, base); 153 } 154 155 static void sym_validate_range(struct symbol *sym) 156 { 157 struct property *prop; 158 int base; 159 long long 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 = strtoll(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, "%lld", val2); 184 else 185 sprintf(str, "0x%llx", val2); 186 sym->curr.val = strdup(str); 187 } 188 189 static void sym_set_changed(struct symbol *sym) 190 { 191 struct property *prop; 192 193 sym->flags |= SYMBOL_CHANGED; 194 for (prop = sym->prop; prop; prop = prop->next) { 195 if (prop->menu) 196 prop->menu->flags |= MENU_CHANGED; 197 } 198 } 199 200 static void sym_set_all_changed(void) 201 { 202 struct symbol *sym; 203 int i; 204 205 for_all_symbols(i, sym) 206 sym_set_changed(sym); 207 } 208 209 static void sym_calc_visibility(struct symbol *sym) 210 { 211 struct property *prop; 212 struct symbol *choice_sym = NULL; 213 tristate tri; 214 215 /* any prompt visible? */ 216 tri = no; 217 218 if (sym_is_choice_value(sym)) 219 choice_sym = prop_get_symbol(sym_get_choice_prop(sym)); 220 221 for_all_prompts(sym, prop) { 222 prop->visible.tri = expr_calc_value(prop->visible.expr); 223 /* 224 * Tristate choice_values with visibility 'mod' are 225 * not visible if the corresponding choice's value is 226 * 'yes'. 227 */ 228 if (choice_sym && sym->type == S_TRISTATE && 229 prop->visible.tri == mod && choice_sym->curr.tri == yes) 230 prop->visible.tri = no; 231 232 tri = EXPR_OR(tri, prop->visible.tri); 233 } 234 if (tri == mod && (sym->type != S_TRISTATE || modules_val == no)) 235 tri = yes; 236 if (sym->visible != tri) { 237 sym->visible = tri; 238 sym_set_changed(sym); 239 } 240 if (sym_is_choice_value(sym)) 241 return; 242 /* defaulting to "yes" if no explicit "depends on" are given */ 243 tri = yes; 244 if (sym->dir_dep.expr) 245 tri = expr_calc_value(sym->dir_dep.expr); 246 if (tri == mod) 247 tri = yes; 248 if (sym->dir_dep.tri != tri) { 249 sym->dir_dep.tri = tri; 250 sym_set_changed(sym); 251 } 252 tri = no; 253 if (sym->rev_dep.expr) 254 tri = expr_calc_value(sym->rev_dep.expr); 255 if (tri == mod && sym_get_type(sym) == S_BOOLEAN) 256 tri = yes; 257 if (sym->rev_dep.tri != tri) { 258 sym->rev_dep.tri = tri; 259 sym_set_changed(sym); 260 } 261 tri = no; 262 if (sym->implied.expr && sym->dir_dep.tri != no) 263 tri = expr_calc_value(sym->implied.expr); 264 if (tri == mod && sym_get_type(sym) == S_BOOLEAN) 265 tri = yes; 266 if (sym->implied.tri != tri) { 267 sym->implied.tri = tri; 268 sym_set_changed(sym); 269 } 270 } 271 272 /* 273 * Find the default symbol for a choice. 274 * First try the default values for the choice symbol 275 * Next locate the first visible choice value 276 * Return NULL if none was found 277 */ 278 struct symbol *sym_choice_default(struct symbol *sym) 279 { 280 struct symbol *def_sym; 281 struct property *prop; 282 struct expr *e; 283 284 /* any of the defaults visible? */ 285 for_all_defaults(sym, prop) { 286 prop->visible.tri = expr_calc_value(prop->visible.expr); 287 if (prop->visible.tri == no) 288 continue; 289 def_sym = prop_get_symbol(prop); 290 if (def_sym->visible != no) 291 return def_sym; 292 } 293 294 /* just get the first visible value */ 295 prop = sym_get_choice_prop(sym); 296 expr_list_for_each_sym(prop->expr, e, def_sym) 297 if (def_sym->visible != no) 298 return def_sym; 299 300 /* failed to locate any defaults */ 301 return NULL; 302 } 303 304 static struct symbol *sym_calc_choice(struct symbol *sym) 305 { 306 struct symbol *def_sym; 307 struct property *prop; 308 struct expr *e; 309 int flags; 310 311 /* first calculate all choice values' visibilities */ 312 flags = sym->flags; 313 prop = sym_get_choice_prop(sym); 314 expr_list_for_each_sym(prop->expr, e, def_sym) { 315 sym_calc_visibility(def_sym); 316 if (def_sym->visible != no) 317 flags &= def_sym->flags; 318 } 319 320 sym->flags &= flags | ~SYMBOL_DEF_USER; 321 322 /* is the user choice visible? */ 323 def_sym = sym->def[S_DEF_USER].val; 324 if (def_sym && def_sym->visible != no) 325 return def_sym; 326 327 def_sym = sym_choice_default(sym); 328 329 if (def_sym == NULL) 330 /* no choice? reset tristate value */ 331 sym->curr.tri = no; 332 333 return def_sym; 334 } 335 336 void sym_calc_value(struct symbol *sym) 337 { 338 struct symbol_value newval, oldval; 339 struct property *prop; 340 struct expr *e; 341 342 if (!sym) 343 return; 344 345 if (sym->flags & SYMBOL_VALID) 346 return; 347 348 if (sym_is_choice_value(sym) && 349 sym->flags & SYMBOL_NEED_SET_CHOICE_VALUES) { 350 sym->flags &= ~SYMBOL_NEED_SET_CHOICE_VALUES; 351 prop = sym_get_choice_prop(sym); 352 sym_calc_value(prop_get_symbol(prop)); 353 } 354 355 sym->flags |= SYMBOL_VALID; 356 357 oldval = sym->curr; 358 359 switch (sym->type) { 360 case S_INT: 361 case S_HEX: 362 case S_STRING: 363 newval = symbol_empty.curr; 364 break; 365 case S_BOOLEAN: 366 case S_TRISTATE: 367 newval = symbol_no.curr; 368 break; 369 default: 370 sym->curr.val = sym->name; 371 sym->curr.tri = no; 372 return; 373 } 374 if (!sym_is_choice_value(sym)) 375 sym->flags &= ~SYMBOL_WRITE; 376 377 sym_calc_visibility(sym); 378 379 /* set default if recursively called */ 380 sym->curr = newval; 381 382 switch (sym_get_type(sym)) { 383 case S_BOOLEAN: 384 case S_TRISTATE: 385 if (sym_is_choice_value(sym) && sym->visible == yes) { 386 prop = sym_get_choice_prop(sym); 387 newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no; 388 } else { 389 if (sym->visible != no) { 390 /* if the symbol is visible use the user value 391 * if available, otherwise try the default value 392 */ 393 sym->flags |= SYMBOL_WRITE; 394 if (sym_has_value(sym)) { 395 newval.tri = EXPR_AND(sym->def[S_DEF_USER].tri, 396 sym->visible); 397 goto calc_newval; 398 } 399 } 400 if (sym->rev_dep.tri != no) 401 sym->flags |= SYMBOL_WRITE; 402 if (!sym_is_choice(sym)) { 403 prop = sym_get_default_prop(sym); 404 if (prop) { 405 sym->flags |= SYMBOL_WRITE; 406 newval.tri = EXPR_AND(expr_calc_value(prop->expr), 407 prop->visible.tri); 408 } 409 if (sym->implied.tri != no) { 410 sym->flags |= SYMBOL_WRITE; 411 newval.tri = EXPR_OR(newval.tri, sym->implied.tri); 412 } 413 } 414 calc_newval: 415 if (sym->dir_dep.tri == no && sym->rev_dep.tri != no) { 416 struct expr *e; 417 e = expr_simplify_unmet_dep(sym->rev_dep.expr, 418 sym->dir_dep.expr); 419 fprintf(stderr, "warning: ("); 420 expr_fprint(e, stderr); 421 fprintf(stderr, ") selects %s which has unmet direct dependencies (", 422 sym->name); 423 expr_fprint(sym->dir_dep.expr, stderr); 424 fprintf(stderr, ")\n"); 425 expr_free(e); 426 } 427 newval.tri = EXPR_OR(newval.tri, sym->rev_dep.tri); 428 } 429 if (newval.tri == mod && 430 (sym_get_type(sym) == S_BOOLEAN || sym->implied.tri == yes)) 431 newval.tri = yes; 432 break; 433 case S_STRING: 434 case S_HEX: 435 case S_INT: 436 if (sym->visible != no) { 437 sym->flags |= SYMBOL_WRITE; 438 if (sym_has_value(sym)) { 439 newval.val = sym->def[S_DEF_USER].val; 440 break; 441 } 442 } 443 prop = sym_get_default_prop(sym); 444 if (prop) { 445 struct symbol *ds = prop_get_symbol(prop); 446 if (ds) { 447 sym->flags |= SYMBOL_WRITE; 448 sym_calc_value(ds); 449 newval.val = ds->curr.val; 450 } 451 } 452 break; 453 default: 454 ; 455 } 456 457 sym->curr = newval; 458 if (sym_is_choice(sym) && newval.tri == yes) 459 sym->curr.val = sym_calc_choice(sym); 460 sym_validate_range(sym); 461 462 if (memcmp(&oldval, &sym->curr, sizeof(oldval))) { 463 sym_set_changed(sym); 464 if (modules_sym == sym) { 465 sym_set_all_changed(); 466 modules_val = modules_sym->curr.tri; 467 } 468 } 469 470 if (sym_is_choice(sym)) { 471 struct symbol *choice_sym; 472 473 prop = sym_get_choice_prop(sym); 474 expr_list_for_each_sym(prop->expr, e, choice_sym) { 475 if ((sym->flags & SYMBOL_WRITE) && 476 choice_sym->visible != no) 477 choice_sym->flags |= SYMBOL_WRITE; 478 if (sym->flags & SYMBOL_CHANGED) 479 sym_set_changed(choice_sym); 480 } 481 } 482 483 if (sym->flags & SYMBOL_AUTO) 484 sym->flags &= ~SYMBOL_WRITE; 485 486 if (sym->flags & SYMBOL_NEED_SET_CHOICE_VALUES) 487 set_all_choice_values(sym); 488 } 489 490 void sym_clear_all_valid(void) 491 { 492 struct symbol *sym; 493 int i; 494 495 for_all_symbols(i, sym) 496 sym->flags &= ~SYMBOL_VALID; 497 sym_add_change_count(1); 498 sym_calc_value(modules_sym); 499 } 500 501 bool sym_tristate_within_range(struct symbol *sym, tristate val) 502 { 503 int type = sym_get_type(sym); 504 505 if (sym->visible == no) 506 return false; 507 508 if (type != S_BOOLEAN && type != S_TRISTATE) 509 return false; 510 511 if (type == S_BOOLEAN && val == mod) 512 return false; 513 if (sym->visible <= sym->rev_dep.tri) 514 return false; 515 if (sym->implied.tri == yes && val == mod) 516 return false; 517 if (sym_is_choice_value(sym) && sym->visible == yes) 518 return val == yes; 519 return val >= sym->rev_dep.tri && val <= sym->visible; 520 } 521 522 bool sym_set_tristate_value(struct symbol *sym, tristate val) 523 { 524 tristate oldval = sym_get_tristate_value(sym); 525 526 if (oldval != val && !sym_tristate_within_range(sym, val)) 527 return false; 528 529 if (!(sym->flags & SYMBOL_DEF_USER)) { 530 sym->flags |= SYMBOL_DEF_USER; 531 sym_set_changed(sym); 532 } 533 /* 534 * setting a choice value also resets the new flag of the choice 535 * symbol and all other choice values. 536 */ 537 if (sym_is_choice_value(sym) && val == yes) { 538 struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); 539 struct property *prop; 540 struct expr *e; 541 542 cs->def[S_DEF_USER].val = sym; 543 cs->flags |= SYMBOL_DEF_USER; 544 prop = sym_get_choice_prop(cs); 545 for (e = prop->expr; e; e = e->left.expr) { 546 if (e->right.sym->visible != no) 547 e->right.sym->flags |= SYMBOL_DEF_USER; 548 } 549 } 550 551 sym->def[S_DEF_USER].tri = val; 552 if (oldval != val) 553 sym_clear_all_valid(); 554 555 return true; 556 } 557 558 tristate sym_toggle_tristate_value(struct symbol *sym) 559 { 560 tristate oldval, newval; 561 562 oldval = newval = sym_get_tristate_value(sym); 563 do { 564 switch (newval) { 565 case no: 566 newval = mod; 567 break; 568 case mod: 569 newval = yes; 570 break; 571 case yes: 572 newval = no; 573 break; 574 } 575 if (sym_set_tristate_value(sym, newval)) 576 break; 577 } while (oldval != newval); 578 return newval; 579 } 580 581 bool sym_string_valid(struct symbol *sym, const char *str) 582 { 583 signed char ch; 584 585 switch (sym->type) { 586 case S_STRING: 587 return true; 588 case S_INT: 589 ch = *str++; 590 if (ch == '-') 591 ch = *str++; 592 if (!isdigit(ch)) 593 return false; 594 if (ch == '0' && *str != 0) 595 return false; 596 while ((ch = *str++)) { 597 if (!isdigit(ch)) 598 return false; 599 } 600 return true; 601 case S_HEX: 602 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) 603 str += 2; 604 ch = *str++; 605 do { 606 if (!isxdigit(ch)) 607 return false; 608 } while ((ch = *str++)); 609 return true; 610 case S_BOOLEAN: 611 case S_TRISTATE: 612 switch (str[0]) { 613 case 'y': case 'Y': 614 case 'm': case 'M': 615 case 'n': case 'N': 616 return true; 617 } 618 return false; 619 default: 620 return false; 621 } 622 } 623 624 bool sym_string_within_range(struct symbol *sym, const char *str) 625 { 626 struct property *prop; 627 long long val; 628 629 switch (sym->type) { 630 case S_STRING: 631 return sym_string_valid(sym, str); 632 case S_INT: 633 if (!sym_string_valid(sym, str)) 634 return false; 635 prop = sym_get_range_prop(sym); 636 if (!prop) 637 return true; 638 val = strtoll(str, NULL, 10); 639 return val >= sym_get_range_val(prop->expr->left.sym, 10) && 640 val <= sym_get_range_val(prop->expr->right.sym, 10); 641 case S_HEX: 642 if (!sym_string_valid(sym, str)) 643 return false; 644 prop = sym_get_range_prop(sym); 645 if (!prop) 646 return true; 647 val = strtoll(str, NULL, 16); 648 return val >= sym_get_range_val(prop->expr->left.sym, 16) && 649 val <= sym_get_range_val(prop->expr->right.sym, 16); 650 case S_BOOLEAN: 651 case S_TRISTATE: 652 switch (str[0]) { 653 case 'y': case 'Y': 654 return sym_tristate_within_range(sym, yes); 655 case 'm': case 'M': 656 return sym_tristate_within_range(sym, mod); 657 case 'n': case 'N': 658 return sym_tristate_within_range(sym, no); 659 } 660 return false; 661 default: 662 return false; 663 } 664 } 665 666 bool sym_set_string_value(struct symbol *sym, const char *newval) 667 { 668 const char *oldval; 669 char *val; 670 int size; 671 672 switch (sym->type) { 673 case S_BOOLEAN: 674 case S_TRISTATE: 675 switch (newval[0]) { 676 case 'y': case 'Y': 677 return sym_set_tristate_value(sym, yes); 678 case 'm': case 'M': 679 return sym_set_tristate_value(sym, mod); 680 case 'n': case 'N': 681 return sym_set_tristate_value(sym, no); 682 } 683 return false; 684 default: 685 ; 686 } 687 688 if (!sym_string_within_range(sym, newval)) 689 return false; 690 691 if (!(sym->flags & SYMBOL_DEF_USER)) { 692 sym->flags |= SYMBOL_DEF_USER; 693 sym_set_changed(sym); 694 } 695 696 oldval = sym->def[S_DEF_USER].val; 697 size = strlen(newval) + 1; 698 if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) { 699 size += 2; 700 sym->def[S_DEF_USER].val = val = xmalloc(size); 701 *val++ = '0'; 702 *val++ = 'x'; 703 } else if (!oldval || strcmp(oldval, newval)) 704 sym->def[S_DEF_USER].val = val = xmalloc(size); 705 else 706 return true; 707 708 strcpy(val, newval); 709 free((void *)oldval); 710 sym_clear_all_valid(); 711 712 return true; 713 } 714 715 /* 716 * Find the default value associated to a symbol. 717 * For tristate symbol handle the modules=n case 718 * in which case "m" becomes "y". 719 * If the symbol does not have any default then fallback 720 * to the fixed default values. 721 */ 722 const char *sym_get_string_default(struct symbol *sym) 723 { 724 struct property *prop; 725 struct symbol *ds; 726 const char *str; 727 tristate val; 728 729 sym_calc_visibility(sym); 730 sym_calc_value(modules_sym); 731 val = symbol_no.curr.tri; 732 str = symbol_empty.curr.val; 733 734 /* If symbol has a default value look it up */ 735 prop = sym_get_default_prop(sym); 736 if (prop != NULL) { 737 switch (sym->type) { 738 case S_BOOLEAN: 739 case S_TRISTATE: 740 /* The visibility may limit the value from yes => mod */ 741 val = EXPR_AND(expr_calc_value(prop->expr), prop->visible.tri); 742 break; 743 default: 744 /* 745 * The following fails to handle the situation 746 * where a default value is further limited by 747 * the valid range. 748 */ 749 ds = prop_get_symbol(prop); 750 if (ds != NULL) { 751 sym_calc_value(ds); 752 str = (const char *)ds->curr.val; 753 } 754 } 755 } 756 757 /* Handle select statements */ 758 val = EXPR_OR(val, sym->rev_dep.tri); 759 760 /* transpose mod to yes if modules are not enabled */ 761 if (val == mod) 762 if (!sym_is_choice_value(sym) && modules_sym->curr.tri == no) 763 val = yes; 764 765 /* transpose mod to yes if type is bool */ 766 if (sym->type == S_BOOLEAN && val == mod) 767 val = yes; 768 769 /* adjust the default value if this symbol is implied by another */ 770 if (val < sym->implied.tri) 771 val = sym->implied.tri; 772 773 switch (sym->type) { 774 case S_BOOLEAN: 775 case S_TRISTATE: 776 switch (val) { 777 case no: return "n"; 778 case mod: return "m"; 779 case yes: return "y"; 780 } 781 case S_INT: 782 case S_HEX: 783 return str; 784 case S_STRING: 785 return str; 786 case S_OTHER: 787 case S_UNKNOWN: 788 break; 789 } 790 return ""; 791 } 792 793 const char *sym_get_string_value(struct symbol *sym) 794 { 795 tristate val; 796 797 switch (sym->type) { 798 case S_BOOLEAN: 799 case S_TRISTATE: 800 val = sym_get_tristate_value(sym); 801 switch (val) { 802 case no: 803 return "n"; 804 case mod: 805 sym_calc_value(modules_sym); 806 return (modules_sym->curr.tri == no) ? "n" : "m"; 807 case yes: 808 return "y"; 809 } 810 break; 811 default: 812 ; 813 } 814 return (const char *)sym->curr.val; 815 } 816 817 bool sym_is_changable(struct symbol *sym) 818 { 819 return sym->visible > sym->rev_dep.tri; 820 } 821 822 static unsigned strhash(const char *s) 823 { 824 /* fnv32 hash */ 825 unsigned hash = 2166136261U; 826 for (; *s; s++) 827 hash = (hash ^ *s) * 0x01000193; 828 return hash; 829 } 830 831 struct symbol *sym_lookup(const char *name, int flags) 832 { 833 struct symbol *symbol; 834 char *new_name; 835 int hash; 836 837 if (name) { 838 if (name[0] && !name[1]) { 839 switch (name[0]) { 840 case 'y': return &symbol_yes; 841 case 'm': return &symbol_mod; 842 case 'n': return &symbol_no; 843 } 844 } 845 hash = strhash(name) % SYMBOL_HASHSIZE; 846 847 for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) { 848 if (symbol->name && 849 !strcmp(symbol->name, name) && 850 (flags ? symbol->flags & flags 851 : !(symbol->flags & (SYMBOL_CONST|SYMBOL_CHOICE)))) 852 return symbol; 853 } 854 new_name = strdup(name); 855 } else { 856 new_name = NULL; 857 hash = 0; 858 } 859 860 symbol = xmalloc(sizeof(*symbol)); 861 memset(symbol, 0, sizeof(*symbol)); 862 symbol->name = new_name; 863 symbol->type = S_UNKNOWN; 864 symbol->flags |= flags; 865 866 symbol->next = symbol_hash[hash]; 867 symbol_hash[hash] = symbol; 868 869 return symbol; 870 } 871 872 struct symbol *sym_find(const char *name) 873 { 874 struct symbol *symbol = NULL; 875 int hash = 0; 876 877 if (!name) 878 return NULL; 879 880 if (name[0] && !name[1]) { 881 switch (name[0]) { 882 case 'y': return &symbol_yes; 883 case 'm': return &symbol_mod; 884 case 'n': return &symbol_no; 885 } 886 } 887 hash = strhash(name) % SYMBOL_HASHSIZE; 888 889 for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) { 890 if (symbol->name && 891 !strcmp(symbol->name, name) && 892 !(symbol->flags & SYMBOL_CONST)) 893 break; 894 } 895 896 return symbol; 897 } 898 899 /* 900 * Expand symbol's names embedded in the string given in argument. Symbols' 901 * name to be expanded shall be prefixed by a '$'. Unknown symbol expands to 902 * the empty string. 903 */ 904 const char *sym_expand_string_value(const char *in) 905 { 906 const char *src; 907 char *res; 908 size_t reslen; 909 910 /* 911 * Note: 'in' might come from a token that's about to be 912 * freed, so make sure to always allocate a new string 913 */ 914 reslen = strlen(in) + 1; 915 res = xmalloc(reslen); 916 res[0] = '\0'; 917 918 while ((src = strchr(in, '$'))) { 919 char *p, name[SYMBOL_MAXLENGTH]; 920 const char *symval = ""; 921 struct symbol *sym; 922 size_t newlen; 923 924 strncat(res, in, src - in); 925 src++; 926 927 p = name; 928 while (isalnum(*src) || *src == '_') 929 *p++ = *src++; 930 *p = '\0'; 931 932 sym = sym_find(name); 933 if (sym != NULL) { 934 sym_calc_value(sym); 935 symval = sym_get_string_value(sym); 936 } 937 938 newlen = strlen(res) + strlen(symval) + strlen(src) + 1; 939 if (newlen > reslen) { 940 reslen = newlen; 941 res = realloc(res, reslen); 942 } 943 944 strcat(res, symval); 945 in = src; 946 } 947 strcat(res, in); 948 949 return res; 950 } 951 952 const char *sym_escape_string_value(const char *in) 953 { 954 const char *p; 955 size_t reslen; 956 char *res; 957 size_t l; 958 959 reslen = strlen(in) + strlen("\"\"") + 1; 960 961 p = in; 962 for (;;) { 963 l = strcspn(p, "\"\\"); 964 p += l; 965 966 if (p[0] == '\0') 967 break; 968 969 reslen++; 970 p++; 971 } 972 973 res = xmalloc(reslen); 974 res[0] = '\0'; 975 976 strcat(res, "\""); 977 978 p = in; 979 for (;;) { 980 l = strcspn(p, "\"\\"); 981 strncat(res, p, l); 982 p += l; 983 984 if (p[0] == '\0') 985 break; 986 987 strcat(res, "\\"); 988 strncat(res, p++, 1); 989 } 990 991 strcat(res, "\""); 992 return res; 993 } 994 995 struct sym_match { 996 struct symbol *sym; 997 off_t so, eo; 998 }; 999 1000 /* Compare matched symbols as thus: 1001 * - first, symbols that match exactly 1002 * - then, alphabetical sort 1003 */ 1004 static int sym_rel_comp(const void *sym1, const void *sym2) 1005 { 1006 const struct sym_match *s1 = sym1; 1007 const struct sym_match *s2 = sym2; 1008 int exact1, exact2; 1009 1010 /* Exact match: 1011 * - if matched length on symbol s1 is the length of that symbol, 1012 * then this symbol should come first; 1013 * - if matched length on symbol s2 is the length of that symbol, 1014 * then this symbol should come first. 1015 * Note: since the search can be a regexp, both symbols may match 1016 * exactly; if this is the case, we can't decide which comes first, 1017 * and we fallback to sorting alphabetically. 1018 */ 1019 exact1 = (s1->eo - s1->so) == strlen(s1->sym->name); 1020 exact2 = (s2->eo - s2->so) == strlen(s2->sym->name); 1021 if (exact1 && !exact2) 1022 return -1; 1023 if (!exact1 && exact2) 1024 return 1; 1025 1026 /* As a fallback, sort symbols alphabetically */ 1027 return strcmp(s1->sym->name, s2->sym->name); 1028 } 1029 1030 struct symbol **sym_re_search(const char *pattern) 1031 { 1032 struct symbol *sym, **sym_arr = NULL; 1033 struct sym_match *sym_match_arr = NULL; 1034 int i, cnt, size; 1035 regex_t re; 1036 regmatch_t match[1]; 1037 1038 cnt = size = 0; 1039 /* Skip if empty */ 1040 if (strlen(pattern) == 0) 1041 return NULL; 1042 if (regcomp(&re, pattern, REG_EXTENDED|REG_ICASE)) 1043 return NULL; 1044 1045 for_all_symbols(i, sym) { 1046 if (sym->flags & SYMBOL_CONST || !sym->name) 1047 continue; 1048 if (regexec(&re, sym->name, 1, match, 0)) 1049 continue; 1050 if (cnt >= size) { 1051 void *tmp; 1052 size += 16; 1053 tmp = realloc(sym_match_arr, size * sizeof(struct sym_match)); 1054 if (!tmp) 1055 goto sym_re_search_free; 1056 sym_match_arr = tmp; 1057 } 1058 sym_calc_value(sym); 1059 /* As regexec returned 0, we know we have a match, so 1060 * we can use match[0].rm_[se]o without further checks 1061 */ 1062 sym_match_arr[cnt].so = match[0].rm_so; 1063 sym_match_arr[cnt].eo = match[0].rm_eo; 1064 sym_match_arr[cnt++].sym = sym; 1065 } 1066 if (sym_match_arr) { 1067 qsort(sym_match_arr, cnt, sizeof(struct sym_match), sym_rel_comp); 1068 sym_arr = malloc((cnt+1) * sizeof(struct symbol *)); 1069 if (!sym_arr) 1070 goto sym_re_search_free; 1071 for (i = 0; i < cnt; i++) 1072 sym_arr[i] = sym_match_arr[i].sym; 1073 sym_arr[cnt] = NULL; 1074 } 1075 sym_re_search_free: 1076 /* sym_match_arr can be NULL if no match, but free(NULL) is OK */ 1077 free(sym_match_arr); 1078 regfree(&re); 1079 1080 return sym_arr; 1081 } 1082 1083 /* 1084 * When we check for recursive dependencies we use a stack to save 1085 * current state so we can print out relevant info to user. 1086 * The entries are located on the call stack so no need to free memory. 1087 * Note insert() remove() must always match to properly clear the stack. 1088 */ 1089 static struct dep_stack { 1090 struct dep_stack *prev, *next; 1091 struct symbol *sym; 1092 struct property *prop; 1093 struct expr *expr; 1094 } *check_top; 1095 1096 static void dep_stack_insert(struct dep_stack *stack, struct symbol *sym) 1097 { 1098 memset(stack, 0, sizeof(*stack)); 1099 if (check_top) 1100 check_top->next = stack; 1101 stack->prev = check_top; 1102 stack->sym = sym; 1103 check_top = stack; 1104 } 1105 1106 static void dep_stack_remove(void) 1107 { 1108 check_top = check_top->prev; 1109 if (check_top) 1110 check_top->next = NULL; 1111 } 1112 1113 /* 1114 * Called when we have detected a recursive dependency. 1115 * check_top point to the top of the stact so we use 1116 * the ->prev pointer to locate the bottom of the stack. 1117 */ 1118 static void sym_check_print_recursive(struct symbol *last_sym) 1119 { 1120 struct dep_stack *stack; 1121 struct symbol *sym, *next_sym; 1122 struct menu *menu = NULL; 1123 struct property *prop; 1124 struct dep_stack cv_stack; 1125 1126 if (sym_is_choice_value(last_sym)) { 1127 dep_stack_insert(&cv_stack, last_sym); 1128 last_sym = prop_get_symbol(sym_get_choice_prop(last_sym)); 1129 } 1130 1131 for (stack = check_top; stack != NULL; stack = stack->prev) 1132 if (stack->sym == last_sym) 1133 break; 1134 if (!stack) { 1135 fprintf(stderr, "unexpected recursive dependency error\n"); 1136 return; 1137 } 1138 1139 for (; stack; stack = stack->next) { 1140 sym = stack->sym; 1141 next_sym = stack->next ? stack->next->sym : last_sym; 1142 prop = stack->prop; 1143 if (prop == NULL) 1144 prop = stack->sym->prop; 1145 1146 /* for choice values find the menu entry (used below) */ 1147 if (sym_is_choice(sym) || sym_is_choice_value(sym)) { 1148 for (prop = sym->prop; prop; prop = prop->next) { 1149 menu = prop->menu; 1150 if (prop->menu) 1151 break; 1152 } 1153 } 1154 if (stack->sym == last_sym) 1155 fprintf(stderr, "%s:%d:error: recursive dependency detected!\n", 1156 prop->file->name, prop->lineno); 1157 1158 if (stack->expr) { 1159 fprintf(stderr, "%s:%d:\tsymbol %s %s value contains %s\n", 1160 prop->file->name, prop->lineno, 1161 sym->name ? sym->name : "<choice>", 1162 prop_get_type_name(prop->type), 1163 next_sym->name ? next_sym->name : "<choice>"); 1164 } else if (stack->prop) { 1165 fprintf(stderr, "%s:%d:\tsymbol %s depends on %s\n", 1166 prop->file->name, prop->lineno, 1167 sym->name ? sym->name : "<choice>", 1168 next_sym->name ? next_sym->name : "<choice>"); 1169 } else if (sym_is_choice(sym)) { 1170 fprintf(stderr, "%s:%d:\tchoice %s contains symbol %s\n", 1171 menu->file->name, menu->lineno, 1172 sym->name ? sym->name : "<choice>", 1173 next_sym->name ? next_sym->name : "<choice>"); 1174 } else if (sym_is_choice_value(sym)) { 1175 fprintf(stderr, "%s:%d:\tsymbol %s is part of choice %s\n", 1176 menu->file->name, menu->lineno, 1177 sym->name ? sym->name : "<choice>", 1178 next_sym->name ? next_sym->name : "<choice>"); 1179 } else { 1180 fprintf(stderr, "%s:%d:\tsymbol %s is selected by %s\n", 1181 prop->file->name, prop->lineno, 1182 sym->name ? sym->name : "<choice>", 1183 next_sym->name ? next_sym->name : "<choice>"); 1184 } 1185 } 1186 1187 fprintf(stderr, 1188 "For a resolution refer to Documentation/kbuild/kconfig-language.txt\n" 1189 "subsection \"Kconfig recursive dependency limitations\"\n" 1190 "\n"); 1191 1192 if (check_top == &cv_stack) 1193 dep_stack_remove(); 1194 } 1195 1196 static struct symbol *sym_check_expr_deps(struct expr *e) 1197 { 1198 struct symbol *sym; 1199 1200 if (!e) 1201 return NULL; 1202 switch (e->type) { 1203 case E_OR: 1204 case E_AND: 1205 sym = sym_check_expr_deps(e->left.expr); 1206 if (sym) 1207 return sym; 1208 return sym_check_expr_deps(e->right.expr); 1209 case E_NOT: 1210 return sym_check_expr_deps(e->left.expr); 1211 case E_EQUAL: 1212 case E_GEQ: 1213 case E_GTH: 1214 case E_LEQ: 1215 case E_LTH: 1216 case E_UNEQUAL: 1217 sym = sym_check_deps(e->left.sym); 1218 if (sym) 1219 return sym; 1220 return sym_check_deps(e->right.sym); 1221 case E_SYMBOL: 1222 return sym_check_deps(e->left.sym); 1223 default: 1224 break; 1225 } 1226 printf("Oops! How to check %d?\n", e->type); 1227 return NULL; 1228 } 1229 1230 /* return NULL when dependencies are OK */ 1231 static struct symbol *sym_check_sym_deps(struct symbol *sym) 1232 { 1233 struct symbol *sym2; 1234 struct property *prop; 1235 struct dep_stack stack; 1236 1237 dep_stack_insert(&stack, sym); 1238 1239 sym2 = sym_check_expr_deps(sym->rev_dep.expr); 1240 if (sym2) 1241 goto out; 1242 1243 for (prop = sym->prop; prop; prop = prop->next) { 1244 if (prop->type == P_CHOICE || prop->type == P_SELECT) 1245 continue; 1246 stack.prop = prop; 1247 sym2 = sym_check_expr_deps(prop->visible.expr); 1248 if (sym2) 1249 break; 1250 if (prop->type != P_DEFAULT || sym_is_choice(sym)) 1251 continue; 1252 stack.expr = prop->expr; 1253 sym2 = sym_check_expr_deps(prop->expr); 1254 if (sym2) 1255 break; 1256 stack.expr = NULL; 1257 } 1258 1259 out: 1260 dep_stack_remove(); 1261 1262 return sym2; 1263 } 1264 1265 static struct symbol *sym_check_choice_deps(struct symbol *choice) 1266 { 1267 struct symbol *sym, *sym2; 1268 struct property *prop; 1269 struct expr *e; 1270 struct dep_stack stack; 1271 1272 dep_stack_insert(&stack, choice); 1273 1274 prop = sym_get_choice_prop(choice); 1275 expr_list_for_each_sym(prop->expr, e, sym) 1276 sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); 1277 1278 choice->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); 1279 sym2 = sym_check_sym_deps(choice); 1280 choice->flags &= ~SYMBOL_CHECK; 1281 if (sym2) 1282 goto out; 1283 1284 expr_list_for_each_sym(prop->expr, e, sym) { 1285 sym2 = sym_check_sym_deps(sym); 1286 if (sym2) 1287 break; 1288 } 1289 out: 1290 expr_list_for_each_sym(prop->expr, e, sym) 1291 sym->flags &= ~SYMBOL_CHECK; 1292 1293 if (sym2 && sym_is_choice_value(sym2) && 1294 prop_get_symbol(sym_get_choice_prop(sym2)) == choice) 1295 sym2 = choice; 1296 1297 dep_stack_remove(); 1298 1299 return sym2; 1300 } 1301 1302 struct symbol *sym_check_deps(struct symbol *sym) 1303 { 1304 struct symbol *sym2; 1305 struct property *prop; 1306 1307 if (sym->flags & SYMBOL_CHECK) { 1308 sym_check_print_recursive(sym); 1309 return sym; 1310 } 1311 if (sym->flags & SYMBOL_CHECKED) 1312 return NULL; 1313 1314 if (sym_is_choice_value(sym)) { 1315 struct dep_stack stack; 1316 1317 /* for choice groups start the check with main choice symbol */ 1318 dep_stack_insert(&stack, sym); 1319 prop = sym_get_choice_prop(sym); 1320 sym2 = sym_check_deps(prop_get_symbol(prop)); 1321 dep_stack_remove(); 1322 } else if (sym_is_choice(sym)) { 1323 sym2 = sym_check_choice_deps(sym); 1324 } else { 1325 sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); 1326 sym2 = sym_check_sym_deps(sym); 1327 sym->flags &= ~SYMBOL_CHECK; 1328 } 1329 1330 if (sym2 && sym2 == sym) 1331 sym2 = NULL; 1332 1333 return sym2; 1334 } 1335 1336 struct property *prop_alloc(enum prop_type type, struct symbol *sym) 1337 { 1338 struct property *prop; 1339 struct property **propp; 1340 1341 prop = xmalloc(sizeof(*prop)); 1342 memset(prop, 0, sizeof(*prop)); 1343 prop->type = type; 1344 prop->sym = sym; 1345 prop->file = current_file; 1346 prop->lineno = zconf_lineno(); 1347 1348 /* append property to the prop list of symbol */ 1349 if (sym) { 1350 for (propp = &sym->prop; *propp; propp = &(*propp)->next) 1351 ; 1352 *propp = prop; 1353 } 1354 1355 return prop; 1356 } 1357 1358 struct symbol *prop_get_symbol(struct property *prop) 1359 { 1360 if (prop->expr && (prop->expr->type == E_SYMBOL || 1361 prop->expr->type == E_LIST)) 1362 return prop->expr->left.sym; 1363 return NULL; 1364 } 1365 1366 const char *prop_get_type_name(enum prop_type type) 1367 { 1368 switch (type) { 1369 case P_PROMPT: 1370 return "prompt"; 1371 case P_ENV: 1372 return "env"; 1373 case P_COMMENT: 1374 return "comment"; 1375 case P_MENU: 1376 return "menu"; 1377 case P_DEFAULT: 1378 return "default"; 1379 case P_CHOICE: 1380 return "choice"; 1381 case P_SELECT: 1382 return "select"; 1383 case P_IMPLY: 1384 return "imply"; 1385 case P_RANGE: 1386 return "range"; 1387 case P_SYMBOL: 1388 return "symbol"; 1389 case P_UNKNOWN: 1390 break; 1391 } 1392 return "unknown"; 1393 } 1394 1395 static void prop_add_env(const char *env) 1396 { 1397 struct symbol *sym, *sym2; 1398 struct property *prop; 1399 char *p; 1400 1401 sym = current_entry->sym; 1402 sym->flags |= SYMBOL_AUTO; 1403 for_all_properties(sym, prop, P_ENV) { 1404 sym2 = prop_get_symbol(prop); 1405 if (strcmp(sym2->name, env)) 1406 menu_warn(current_entry, "redefining environment symbol from %s", 1407 sym2->name); 1408 return; 1409 } 1410 1411 prop = prop_alloc(P_ENV, sym); 1412 prop->expr = expr_alloc_symbol(sym_lookup(env, SYMBOL_CONST)); 1413 1414 sym_env_list = expr_alloc_one(E_LIST, sym_env_list); 1415 sym_env_list->right.sym = sym; 1416 1417 p = getenv(env); 1418 if (p) 1419 sym_add_default(sym, p); 1420 else 1421 menu_warn(current_entry, "environment variable %s undefined", env); 1422 } 1423