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 "boolean"; 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 reslen = strlen(in) + 1; 911 res = xmalloc(reslen); 912 res[0] = '\0'; 913 914 while ((src = strchr(in, '$'))) { 915 char *p, name[SYMBOL_MAXLENGTH]; 916 const char *symval = ""; 917 struct symbol *sym; 918 size_t newlen; 919 920 strncat(res, in, src - in); 921 src++; 922 923 p = name; 924 while (isalnum(*src) || *src == '_') 925 *p++ = *src++; 926 *p = '\0'; 927 928 sym = sym_find(name); 929 if (sym != NULL) { 930 sym_calc_value(sym); 931 symval = sym_get_string_value(sym); 932 } 933 934 newlen = strlen(res) + strlen(symval) + strlen(src) + 1; 935 if (newlen > reslen) { 936 reslen = newlen; 937 res = realloc(res, reslen); 938 } 939 940 strcat(res, symval); 941 in = src; 942 } 943 strcat(res, in); 944 945 return res; 946 } 947 948 const char *sym_escape_string_value(const char *in) 949 { 950 const char *p; 951 size_t reslen; 952 char *res; 953 size_t l; 954 955 reslen = strlen(in) + strlen("\"\"") + 1; 956 957 p = in; 958 for (;;) { 959 l = strcspn(p, "\"\\"); 960 p += l; 961 962 if (p[0] == '\0') 963 break; 964 965 reslen++; 966 p++; 967 } 968 969 res = xmalloc(reslen); 970 res[0] = '\0'; 971 972 strcat(res, "\""); 973 974 p = in; 975 for (;;) { 976 l = strcspn(p, "\"\\"); 977 strncat(res, p, l); 978 p += l; 979 980 if (p[0] == '\0') 981 break; 982 983 strcat(res, "\\"); 984 strncat(res, p++, 1); 985 } 986 987 strcat(res, "\""); 988 return res; 989 } 990 991 struct sym_match { 992 struct symbol *sym; 993 off_t so, eo; 994 }; 995 996 /* Compare matched symbols as thus: 997 * - first, symbols that match exactly 998 * - then, alphabetical sort 999 */ 1000 static int sym_rel_comp(const void *sym1, const void *sym2) 1001 { 1002 const struct sym_match *s1 = sym1; 1003 const struct sym_match *s2 = sym2; 1004 int exact1, exact2; 1005 1006 /* Exact match: 1007 * - if matched length on symbol s1 is the length of that symbol, 1008 * then this symbol should come first; 1009 * - if matched length on symbol s2 is the length of that symbol, 1010 * then this symbol should come first. 1011 * Note: since the search can be a regexp, both symbols may match 1012 * exactly; if this is the case, we can't decide which comes first, 1013 * and we fallback to sorting alphabetically. 1014 */ 1015 exact1 = (s1->eo - s1->so) == strlen(s1->sym->name); 1016 exact2 = (s2->eo - s2->so) == strlen(s2->sym->name); 1017 if (exact1 && !exact2) 1018 return -1; 1019 if (!exact1 && exact2) 1020 return 1; 1021 1022 /* As a fallback, sort symbols alphabetically */ 1023 return strcmp(s1->sym->name, s2->sym->name); 1024 } 1025 1026 struct symbol **sym_re_search(const char *pattern) 1027 { 1028 struct symbol *sym, **sym_arr = NULL; 1029 struct sym_match *sym_match_arr = NULL; 1030 int i, cnt, size; 1031 regex_t re; 1032 regmatch_t match[1]; 1033 1034 cnt = size = 0; 1035 /* Skip if empty */ 1036 if (strlen(pattern) == 0) 1037 return NULL; 1038 if (regcomp(&re, pattern, REG_EXTENDED|REG_ICASE)) 1039 return NULL; 1040 1041 for_all_symbols(i, sym) { 1042 if (sym->flags & SYMBOL_CONST || !sym->name) 1043 continue; 1044 if (regexec(&re, sym->name, 1, match, 0)) 1045 continue; 1046 if (cnt >= size) { 1047 void *tmp; 1048 size += 16; 1049 tmp = realloc(sym_match_arr, size * sizeof(struct sym_match)); 1050 if (!tmp) 1051 goto sym_re_search_free; 1052 sym_match_arr = tmp; 1053 } 1054 sym_calc_value(sym); 1055 /* As regexec returned 0, we know we have a match, so 1056 * we can use match[0].rm_[se]o without further checks 1057 */ 1058 sym_match_arr[cnt].so = match[0].rm_so; 1059 sym_match_arr[cnt].eo = match[0].rm_eo; 1060 sym_match_arr[cnt++].sym = sym; 1061 } 1062 if (sym_match_arr) { 1063 qsort(sym_match_arr, cnt, sizeof(struct sym_match), sym_rel_comp); 1064 sym_arr = malloc((cnt+1) * sizeof(struct symbol)); 1065 if (!sym_arr) 1066 goto sym_re_search_free; 1067 for (i = 0; i < cnt; i++) 1068 sym_arr[i] = sym_match_arr[i].sym; 1069 sym_arr[cnt] = NULL; 1070 } 1071 sym_re_search_free: 1072 /* sym_match_arr can be NULL if no match, but free(NULL) is OK */ 1073 free(sym_match_arr); 1074 regfree(&re); 1075 1076 return sym_arr; 1077 } 1078 1079 /* 1080 * When we check for recursive dependencies we use a stack to save 1081 * current state so we can print out relevant info to user. 1082 * The entries are located on the call stack so no need to free memory. 1083 * Note insert() remove() must always match to properly clear the stack. 1084 */ 1085 static struct dep_stack { 1086 struct dep_stack *prev, *next; 1087 struct symbol *sym; 1088 struct property *prop; 1089 struct expr *expr; 1090 } *check_top; 1091 1092 static void dep_stack_insert(struct dep_stack *stack, struct symbol *sym) 1093 { 1094 memset(stack, 0, sizeof(*stack)); 1095 if (check_top) 1096 check_top->next = stack; 1097 stack->prev = check_top; 1098 stack->sym = sym; 1099 check_top = stack; 1100 } 1101 1102 static void dep_stack_remove(void) 1103 { 1104 check_top = check_top->prev; 1105 if (check_top) 1106 check_top->next = NULL; 1107 } 1108 1109 /* 1110 * Called when we have detected a recursive dependency. 1111 * check_top point to the top of the stact so we use 1112 * the ->prev pointer to locate the bottom of the stack. 1113 */ 1114 static void sym_check_print_recursive(struct symbol *last_sym) 1115 { 1116 struct dep_stack *stack; 1117 struct symbol *sym, *next_sym; 1118 struct menu *menu = NULL; 1119 struct property *prop; 1120 struct dep_stack cv_stack; 1121 1122 if (sym_is_choice_value(last_sym)) { 1123 dep_stack_insert(&cv_stack, last_sym); 1124 last_sym = prop_get_symbol(sym_get_choice_prop(last_sym)); 1125 } 1126 1127 for (stack = check_top; stack != NULL; stack = stack->prev) 1128 if (stack->sym == last_sym) 1129 break; 1130 if (!stack) { 1131 fprintf(stderr, "unexpected recursive dependency error\n"); 1132 return; 1133 } 1134 1135 for (; stack; stack = stack->next) { 1136 sym = stack->sym; 1137 next_sym = stack->next ? stack->next->sym : last_sym; 1138 prop = stack->prop; 1139 if (prop == NULL) 1140 prop = stack->sym->prop; 1141 1142 /* for choice values find the menu entry (used below) */ 1143 if (sym_is_choice(sym) || sym_is_choice_value(sym)) { 1144 for (prop = sym->prop; prop; prop = prop->next) { 1145 menu = prop->menu; 1146 if (prop->menu) 1147 break; 1148 } 1149 } 1150 if (stack->sym == last_sym) 1151 fprintf(stderr, "%s:%d:error: recursive dependency detected!\n", 1152 prop->file->name, prop->lineno); 1153 fprintf(stderr, "For a resolution refer to Documentation/kbuild/kconfig-language.txt\n"); 1154 fprintf(stderr, "subsection \"Kconfig recursive dependency limitations\"\n"); 1155 if (stack->expr) { 1156 fprintf(stderr, "%s:%d:\tsymbol %s %s value contains %s\n", 1157 prop->file->name, prop->lineno, 1158 sym->name ? sym->name : "<choice>", 1159 prop_get_type_name(prop->type), 1160 next_sym->name ? next_sym->name : "<choice>"); 1161 } else if (stack->prop) { 1162 fprintf(stderr, "%s:%d:\tsymbol %s depends on %s\n", 1163 prop->file->name, prop->lineno, 1164 sym->name ? sym->name : "<choice>", 1165 next_sym->name ? next_sym->name : "<choice>"); 1166 } else if (sym_is_choice(sym)) { 1167 fprintf(stderr, "%s:%d:\tchoice %s contains symbol %s\n", 1168 menu->file->name, menu->lineno, 1169 sym->name ? sym->name : "<choice>", 1170 next_sym->name ? next_sym->name : "<choice>"); 1171 } else if (sym_is_choice_value(sym)) { 1172 fprintf(stderr, "%s:%d:\tsymbol %s is part of choice %s\n", 1173 menu->file->name, menu->lineno, 1174 sym->name ? sym->name : "<choice>", 1175 next_sym->name ? next_sym->name : "<choice>"); 1176 } else { 1177 fprintf(stderr, "%s:%d:\tsymbol %s is selected by %s\n", 1178 prop->file->name, prop->lineno, 1179 sym->name ? sym->name : "<choice>", 1180 next_sym->name ? next_sym->name : "<choice>"); 1181 } 1182 } 1183 1184 if (check_top == &cv_stack) 1185 dep_stack_remove(); 1186 } 1187 1188 static struct symbol *sym_check_expr_deps(struct expr *e) 1189 { 1190 struct symbol *sym; 1191 1192 if (!e) 1193 return NULL; 1194 switch (e->type) { 1195 case E_OR: 1196 case E_AND: 1197 sym = sym_check_expr_deps(e->left.expr); 1198 if (sym) 1199 return sym; 1200 return sym_check_expr_deps(e->right.expr); 1201 case E_NOT: 1202 return sym_check_expr_deps(e->left.expr); 1203 case E_EQUAL: 1204 case E_GEQ: 1205 case E_GTH: 1206 case E_LEQ: 1207 case E_LTH: 1208 case E_UNEQUAL: 1209 sym = sym_check_deps(e->left.sym); 1210 if (sym) 1211 return sym; 1212 return sym_check_deps(e->right.sym); 1213 case E_SYMBOL: 1214 return sym_check_deps(e->left.sym); 1215 default: 1216 break; 1217 } 1218 printf("Oops! How to check %d?\n", e->type); 1219 return NULL; 1220 } 1221 1222 /* return NULL when dependencies are OK */ 1223 static struct symbol *sym_check_sym_deps(struct symbol *sym) 1224 { 1225 struct symbol *sym2; 1226 struct property *prop; 1227 struct dep_stack stack; 1228 1229 dep_stack_insert(&stack, sym); 1230 1231 sym2 = sym_check_expr_deps(sym->rev_dep.expr); 1232 if (sym2) 1233 goto out; 1234 1235 for (prop = sym->prop; prop; prop = prop->next) { 1236 if (prop->type == P_CHOICE || prop->type == P_SELECT) 1237 continue; 1238 stack.prop = prop; 1239 sym2 = sym_check_expr_deps(prop->visible.expr); 1240 if (sym2) 1241 break; 1242 if (prop->type != P_DEFAULT || sym_is_choice(sym)) 1243 continue; 1244 stack.expr = prop->expr; 1245 sym2 = sym_check_expr_deps(prop->expr); 1246 if (sym2) 1247 break; 1248 stack.expr = NULL; 1249 } 1250 1251 out: 1252 dep_stack_remove(); 1253 1254 return sym2; 1255 } 1256 1257 static struct symbol *sym_check_choice_deps(struct symbol *choice) 1258 { 1259 struct symbol *sym, *sym2; 1260 struct property *prop; 1261 struct expr *e; 1262 struct dep_stack stack; 1263 1264 dep_stack_insert(&stack, choice); 1265 1266 prop = sym_get_choice_prop(choice); 1267 expr_list_for_each_sym(prop->expr, e, sym) 1268 sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); 1269 1270 choice->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); 1271 sym2 = sym_check_sym_deps(choice); 1272 choice->flags &= ~SYMBOL_CHECK; 1273 if (sym2) 1274 goto out; 1275 1276 expr_list_for_each_sym(prop->expr, e, sym) { 1277 sym2 = sym_check_sym_deps(sym); 1278 if (sym2) 1279 break; 1280 } 1281 out: 1282 expr_list_for_each_sym(prop->expr, e, sym) 1283 sym->flags &= ~SYMBOL_CHECK; 1284 1285 if (sym2 && sym_is_choice_value(sym2) && 1286 prop_get_symbol(sym_get_choice_prop(sym2)) == choice) 1287 sym2 = choice; 1288 1289 dep_stack_remove(); 1290 1291 return sym2; 1292 } 1293 1294 struct symbol *sym_check_deps(struct symbol *sym) 1295 { 1296 struct symbol *sym2; 1297 struct property *prop; 1298 1299 if (sym->flags & SYMBOL_CHECK) { 1300 sym_check_print_recursive(sym); 1301 return sym; 1302 } 1303 if (sym->flags & SYMBOL_CHECKED) 1304 return NULL; 1305 1306 if (sym_is_choice_value(sym)) { 1307 struct dep_stack stack; 1308 1309 /* for choice groups start the check with main choice symbol */ 1310 dep_stack_insert(&stack, sym); 1311 prop = sym_get_choice_prop(sym); 1312 sym2 = sym_check_deps(prop_get_symbol(prop)); 1313 dep_stack_remove(); 1314 } else if (sym_is_choice(sym)) { 1315 sym2 = sym_check_choice_deps(sym); 1316 } else { 1317 sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); 1318 sym2 = sym_check_sym_deps(sym); 1319 sym->flags &= ~SYMBOL_CHECK; 1320 } 1321 1322 if (sym2 && sym2 == sym) 1323 sym2 = NULL; 1324 1325 return sym2; 1326 } 1327 1328 struct property *prop_alloc(enum prop_type type, struct symbol *sym) 1329 { 1330 struct property *prop; 1331 struct property **propp; 1332 1333 prop = xmalloc(sizeof(*prop)); 1334 memset(prop, 0, sizeof(*prop)); 1335 prop->type = type; 1336 prop->sym = sym; 1337 prop->file = current_file; 1338 prop->lineno = zconf_lineno(); 1339 1340 /* append property to the prop list of symbol */ 1341 if (sym) { 1342 for (propp = &sym->prop; *propp; propp = &(*propp)->next) 1343 ; 1344 *propp = prop; 1345 } 1346 1347 return prop; 1348 } 1349 1350 struct symbol *prop_get_symbol(struct property *prop) 1351 { 1352 if (prop->expr && (prop->expr->type == E_SYMBOL || 1353 prop->expr->type == E_LIST)) 1354 return prop->expr->left.sym; 1355 return NULL; 1356 } 1357 1358 const char *prop_get_type_name(enum prop_type type) 1359 { 1360 switch (type) { 1361 case P_PROMPT: 1362 return "prompt"; 1363 case P_ENV: 1364 return "env"; 1365 case P_COMMENT: 1366 return "comment"; 1367 case P_MENU: 1368 return "menu"; 1369 case P_DEFAULT: 1370 return "default"; 1371 case P_CHOICE: 1372 return "choice"; 1373 case P_SELECT: 1374 return "select"; 1375 case P_IMPLY: 1376 return "imply"; 1377 case P_RANGE: 1378 return "range"; 1379 case P_SYMBOL: 1380 return "symbol"; 1381 case P_UNKNOWN: 1382 break; 1383 } 1384 return "unknown"; 1385 } 1386 1387 static void prop_add_env(const char *env) 1388 { 1389 struct symbol *sym, *sym2; 1390 struct property *prop; 1391 char *p; 1392 1393 sym = current_entry->sym; 1394 sym->flags |= SYMBOL_AUTO; 1395 for_all_properties(sym, prop, P_ENV) { 1396 sym2 = prop_get_symbol(prop); 1397 if (strcmp(sym2->name, env)) 1398 menu_warn(current_entry, "redefining environment symbol from %s", 1399 sym2->name); 1400 return; 1401 } 1402 1403 prop = prop_alloc(P_ENV, sym); 1404 prop->expr = expr_alloc_symbol(sym_lookup(env, SYMBOL_CONST)); 1405 1406 sym_env_list = expr_alloc_one(E_LIST, sym_env_list); 1407 sym_env_list->right.sym = sym; 1408 1409 p = getenv(env); 1410 if (p) 1411 sym_add_default(sym, p); 1412 else 1413 menu_warn(current_entry, "environment variable %s undefined", env); 1414 } 1415