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 <sys/stat.h> 7 #include <ctype.h> 8 #include <errno.h> 9 #include <fcntl.h> 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <string.h> 13 #include <time.h> 14 #include <unistd.h> 15 16 #define LKC_DIRECT_LINK 17 #include "lkc.h" 18 19 static void conf_warning(const char *fmt, ...) 20 __attribute__ ((format (printf, 1, 2))); 21 22 static void conf_message(const char *fmt, ...) 23 __attribute__ ((format (printf, 1, 2))); 24 25 static const char *conf_filename; 26 static int conf_lineno, conf_warnings, conf_unsaved; 27 28 const char conf_defname[] = "arch/$ARCH/defconfig"; 29 30 static void conf_warning(const char *fmt, ...) 31 { 32 va_list ap; 33 va_start(ap, fmt); 34 fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno); 35 vfprintf(stderr, fmt, ap); 36 fprintf(stderr, "\n"); 37 va_end(ap); 38 conf_warnings++; 39 } 40 41 static void conf_default_message_callback(const char *fmt, va_list ap) 42 { 43 printf("#\n# "); 44 vprintf(fmt, ap); 45 printf("\n#\n"); 46 } 47 48 static void (*conf_message_callback) (const char *fmt, va_list ap) = 49 conf_default_message_callback; 50 void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap)) 51 { 52 conf_message_callback = fn; 53 } 54 55 static void conf_message(const char *fmt, ...) 56 { 57 va_list ap; 58 59 va_start(ap, fmt); 60 if (conf_message_callback) 61 conf_message_callback(fmt, ap); 62 } 63 64 const char *conf_get_configname(void) 65 { 66 char *name = getenv("KCONFIG_CONFIG"); 67 68 return name ? name : ".config"; 69 } 70 71 const char *conf_get_autoconfig_name(void) 72 { 73 char *name = getenv("KCONFIG_AUTOCONFIG"); 74 75 return name ? name : "include/config/auto.conf"; 76 } 77 78 static char *conf_expand_value(const char *in) 79 { 80 struct symbol *sym; 81 const char *src; 82 static char res_value[SYMBOL_MAXLENGTH]; 83 char *dst, name[SYMBOL_MAXLENGTH]; 84 85 res_value[0] = 0; 86 dst = name; 87 while ((src = strchr(in, '$'))) { 88 strncat(res_value, in, src - in); 89 src++; 90 dst = name; 91 while (isalnum(*src) || *src == '_') 92 *dst++ = *src++; 93 *dst = 0; 94 sym = sym_lookup(name, 0); 95 sym_calc_value(sym); 96 strcat(res_value, sym_get_string_value(sym)); 97 in = src; 98 } 99 strcat(res_value, in); 100 101 return res_value; 102 } 103 104 char *conf_get_default_confname(void) 105 { 106 struct stat buf; 107 static char fullname[PATH_MAX+1]; 108 char *env, *name; 109 110 name = conf_expand_value(conf_defname); 111 env = getenv(SRCTREE); 112 if (env) { 113 sprintf(fullname, "%s/%s", env, name); 114 if (!stat(fullname, &buf)) 115 return fullname; 116 } 117 return name; 118 } 119 120 static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p) 121 { 122 char *p2; 123 124 switch (sym->type) { 125 case S_TRISTATE: 126 if (p[0] == 'm') { 127 sym->def[def].tri = mod; 128 sym->flags |= def_flags; 129 break; 130 } 131 case S_BOOLEAN: 132 if (p[0] == 'y') { 133 sym->def[def].tri = yes; 134 sym->flags |= def_flags; 135 break; 136 } 137 if (p[0] == 'n') { 138 sym->def[def].tri = no; 139 sym->flags |= def_flags; 140 break; 141 } 142 conf_warning("symbol value '%s' invalid for %s", p, sym->name); 143 break; 144 case S_OTHER: 145 if (*p != '"') { 146 for (p2 = p; *p2 && !isspace(*p2); p2++) 147 ; 148 sym->type = S_STRING; 149 goto done; 150 } 151 case S_STRING: 152 if (*p++ != '"') 153 break; 154 for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) { 155 if (*p2 == '"') { 156 *p2 = 0; 157 break; 158 } 159 memmove(p2, p2 + 1, strlen(p2)); 160 } 161 if (!p2) { 162 conf_warning("invalid string found"); 163 return 1; 164 } 165 case S_INT: 166 case S_HEX: 167 done: 168 if (sym_string_valid(sym, p)) { 169 sym->def[def].val = strdup(p); 170 sym->flags |= def_flags; 171 } else { 172 conf_warning("symbol value '%s' invalid for %s", p, sym->name); 173 return 1; 174 } 175 break; 176 default: 177 ; 178 } 179 return 0; 180 } 181 182 int conf_read_simple(const char *name, int def) 183 { 184 FILE *in = NULL; 185 char line[1024]; 186 char *p, *p2; 187 struct symbol *sym; 188 int i, def_flags; 189 190 if (name) { 191 in = zconf_fopen(name); 192 } else { 193 struct property *prop; 194 195 name = conf_get_configname(); 196 in = zconf_fopen(name); 197 if (in) 198 goto load; 199 sym_add_change_count(1); 200 if (!sym_defconfig_list) { 201 if (modules_sym) 202 sym_calc_value(modules_sym); 203 return 1; 204 } 205 206 for_all_defaults(sym_defconfig_list, prop) { 207 if (expr_calc_value(prop->visible.expr) == no || 208 prop->expr->type != E_SYMBOL) 209 continue; 210 name = conf_expand_value(prop->expr->left.sym->name); 211 in = zconf_fopen(name); 212 if (in) { 213 conf_message(_("using defaults found in %s"), 214 name); 215 goto load; 216 } 217 } 218 } 219 if (!in) 220 return 1; 221 222 load: 223 conf_filename = name; 224 conf_lineno = 0; 225 conf_warnings = 0; 226 conf_unsaved = 0; 227 228 def_flags = SYMBOL_DEF << def; 229 for_all_symbols(i, sym) { 230 sym->flags |= SYMBOL_CHANGED; 231 sym->flags &= ~(def_flags|SYMBOL_VALID); 232 if (sym_is_choice(sym)) 233 sym->flags |= def_flags; 234 switch (sym->type) { 235 case S_INT: 236 case S_HEX: 237 case S_STRING: 238 if (sym->def[def].val) 239 free(sym->def[def].val); 240 default: 241 sym->def[def].val = NULL; 242 sym->def[def].tri = no; 243 } 244 } 245 246 while (fgets(line, sizeof(line), in)) { 247 conf_lineno++; 248 sym = NULL; 249 if (line[0] == '#') { 250 if (memcmp(line + 2, CONFIG_, strlen(CONFIG_))) 251 continue; 252 p = strchr(line + 2 + strlen(CONFIG_), ' '); 253 if (!p) 254 continue; 255 *p++ = 0; 256 if (strncmp(p, "is not set", 10)) 257 continue; 258 if (def == S_DEF_USER) { 259 sym = sym_find(line + 2 + strlen(CONFIG_)); 260 if (!sym) { 261 sym_add_change_count(1); 262 goto setsym; 263 } 264 } else { 265 sym = sym_lookup(line + 2 + strlen(CONFIG_), 0); 266 if (sym->type == S_UNKNOWN) 267 sym->type = S_BOOLEAN; 268 } 269 if (sym->flags & def_flags) { 270 conf_warning("override: reassigning to symbol %s", sym->name); 271 } 272 switch (sym->type) { 273 case S_BOOLEAN: 274 case S_TRISTATE: 275 sym->def[def].tri = no; 276 sym->flags |= def_flags; 277 break; 278 default: 279 ; 280 } 281 } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) { 282 p = strchr(line + strlen(CONFIG_), '='); 283 if (!p) 284 continue; 285 *p++ = 0; 286 p2 = strchr(p, '\n'); 287 if (p2) { 288 *p2-- = 0; 289 if (*p2 == '\r') 290 *p2 = 0; 291 } 292 if (def == S_DEF_USER) { 293 sym = sym_find(line + strlen(CONFIG_)); 294 if (!sym) { 295 sym_add_change_count(1); 296 goto setsym; 297 } 298 } else { 299 sym = sym_lookup(line + strlen(CONFIG_), 0); 300 if (sym->type == S_UNKNOWN) 301 sym->type = S_OTHER; 302 } 303 if (sym->flags & def_flags) { 304 conf_warning("override: reassigning to symbol %s", sym->name); 305 } 306 if (conf_set_sym_val(sym, def, def_flags, p)) 307 continue; 308 } else { 309 if (line[0] != '\r' && line[0] != '\n') 310 conf_warning("unexpected data"); 311 continue; 312 } 313 setsym: 314 if (sym && sym_is_choice_value(sym)) { 315 struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); 316 switch (sym->def[def].tri) { 317 case no: 318 break; 319 case mod: 320 if (cs->def[def].tri == yes) { 321 conf_warning("%s creates inconsistent choice state", sym->name); 322 cs->flags &= ~def_flags; 323 } 324 break; 325 case yes: 326 if (cs->def[def].tri != no) 327 conf_warning("override: %s changes choice state", sym->name); 328 cs->def[def].val = sym; 329 break; 330 } 331 cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri); 332 } 333 } 334 fclose(in); 335 336 if (modules_sym) 337 sym_calc_value(modules_sym); 338 return 0; 339 } 340 341 int conf_read(const char *name) 342 { 343 struct symbol *sym, *choice_sym; 344 struct property *prop; 345 struct expr *e; 346 int i, flags; 347 348 sym_set_change_count(0); 349 350 if (conf_read_simple(name, S_DEF_USER)) 351 return 1; 352 353 for_all_symbols(i, sym) { 354 sym_calc_value(sym); 355 if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO)) 356 goto sym_ok; 357 if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) { 358 /* check that calculated value agrees with saved value */ 359 switch (sym->type) { 360 case S_BOOLEAN: 361 case S_TRISTATE: 362 if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym)) 363 break; 364 if (!sym_is_choice(sym)) 365 goto sym_ok; 366 default: 367 if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val)) 368 goto sym_ok; 369 break; 370 } 371 } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE)) 372 /* no previous value and not saved */ 373 goto sym_ok; 374 conf_unsaved++; 375 /* maybe print value in verbose mode... */ 376 sym_ok: 377 if (!sym_is_choice(sym)) 378 continue; 379 /* The choice symbol only has a set value (and thus is not new) 380 * if all its visible childs have values. 381 */ 382 prop = sym_get_choice_prop(sym); 383 flags = sym->flags; 384 expr_list_for_each_sym(prop->expr, e, choice_sym) 385 if (choice_sym->visible != no) 386 flags &= choice_sym->flags; 387 sym->flags &= flags | ~SYMBOL_DEF_USER; 388 } 389 390 for_all_symbols(i, sym) { 391 if (sym_has_value(sym) && !sym_is_choice_value(sym)) { 392 /* Reset values of generates values, so they'll appear 393 * as new, if they should become visible, but that 394 * doesn't quite work if the Kconfig and the saved 395 * configuration disagree. 396 */ 397 if (sym->visible == no && !conf_unsaved) 398 sym->flags &= ~SYMBOL_DEF_USER; 399 switch (sym->type) { 400 case S_STRING: 401 case S_INT: 402 case S_HEX: 403 /* Reset a string value if it's out of range */ 404 if (sym_string_within_range(sym, sym->def[S_DEF_USER].val)) 405 break; 406 sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER); 407 conf_unsaved++; 408 break; 409 default: 410 break; 411 } 412 } 413 } 414 415 sym_add_change_count(conf_warnings || conf_unsaved); 416 417 return 0; 418 } 419 420 /* Write a S_STRING */ 421 static void conf_write_string(bool headerfile, const char *name, 422 const char *str, FILE *out) 423 { 424 int l; 425 if (headerfile) 426 fprintf(out, "#define %s%s \"", CONFIG_, name); 427 else 428 fprintf(out, "%s%s=\"", CONFIG_, name); 429 430 while (1) { 431 l = strcspn(str, "\"\\"); 432 if (l) { 433 xfwrite(str, l, 1, out); 434 str += l; 435 } 436 if (!*str) 437 break; 438 fprintf(out, "\\%c", *str++); 439 } 440 fputs("\"\n", out); 441 } 442 443 static void conf_write_symbol(struct symbol *sym, enum symbol_type type, 444 FILE *out, bool write_no) 445 { 446 const char *str; 447 448 switch (type) { 449 case S_BOOLEAN: 450 case S_TRISTATE: 451 switch (sym_get_tristate_value(sym)) { 452 case no: 453 if (write_no) 454 fprintf(out, "# %s%s is not set\n", 455 CONFIG_, sym->name); 456 break; 457 case mod: 458 fprintf(out, "%s%s=m\n", CONFIG_, sym->name); 459 break; 460 case yes: 461 fprintf(out, "%s%s=y\n", CONFIG_, sym->name); 462 break; 463 } 464 break; 465 case S_STRING: 466 conf_write_string(false, sym->name, sym_get_string_value(sym), out); 467 break; 468 case S_HEX: 469 case S_INT: 470 str = sym_get_string_value(sym); 471 fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str); 472 break; 473 case S_OTHER: 474 case S_UNKNOWN: 475 break; 476 } 477 } 478 479 /* 480 * Write out a minimal config. 481 * All values that has default values are skipped as this is redundant. 482 */ 483 int conf_write_defconfig(const char *filename) 484 { 485 struct symbol *sym; 486 struct menu *menu; 487 FILE *out; 488 489 out = fopen(filename, "w"); 490 if (!out) 491 return 1; 492 493 sym_clear_all_valid(); 494 495 /* Traverse all menus to find all relevant symbols */ 496 menu = rootmenu.list; 497 498 while (menu != NULL) 499 { 500 sym = menu->sym; 501 if (sym == NULL) { 502 if (!menu_is_visible(menu)) 503 goto next_menu; 504 } else if (!sym_is_choice(sym)) { 505 sym_calc_value(sym); 506 if (!(sym->flags & SYMBOL_WRITE)) 507 goto next_menu; 508 sym->flags &= ~SYMBOL_WRITE; 509 /* If we cannot change the symbol - skip */ 510 if (!sym_is_changable(sym)) 511 goto next_menu; 512 /* If symbol equals to default value - skip */ 513 if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0) 514 goto next_menu; 515 516 /* 517 * If symbol is a choice value and equals to the 518 * default for a choice - skip. 519 * But only if value is bool and equal to "y" and 520 * choice is not "optional". 521 * (If choice is "optional" then all values can be "n") 522 */ 523 if (sym_is_choice_value(sym)) { 524 struct symbol *cs; 525 struct symbol *ds; 526 527 cs = prop_get_symbol(sym_get_choice_prop(sym)); 528 ds = sym_choice_default(cs); 529 if (!sym_is_optional(cs) && sym == ds) { 530 if ((sym->type == S_BOOLEAN) && 531 sym_get_tristate_value(sym) == yes) 532 goto next_menu; 533 } 534 } 535 conf_write_symbol(sym, sym->type, out, true); 536 } 537 next_menu: 538 if (menu->list != NULL) { 539 menu = menu->list; 540 } 541 else if (menu->next != NULL) { 542 menu = menu->next; 543 } else { 544 while ((menu = menu->parent)) { 545 if (menu->next != NULL) { 546 menu = menu->next; 547 break; 548 } 549 } 550 } 551 } 552 fclose(out); 553 return 0; 554 } 555 556 int conf_write(const char *name) 557 { 558 FILE *out; 559 struct symbol *sym; 560 struct menu *menu; 561 const char *basename; 562 const char *str; 563 char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1]; 564 enum symbol_type type; 565 time_t now; 566 int use_timestamp = 1; 567 char *env; 568 569 dirname[0] = 0; 570 if (name && name[0]) { 571 struct stat st; 572 char *slash; 573 574 if (!stat(name, &st) && S_ISDIR(st.st_mode)) { 575 strcpy(dirname, name); 576 strcat(dirname, "/"); 577 basename = conf_get_configname(); 578 } else if ((slash = strrchr(name, '/'))) { 579 int size = slash - name + 1; 580 memcpy(dirname, name, size); 581 dirname[size] = 0; 582 if (slash[1]) 583 basename = slash + 1; 584 else 585 basename = conf_get_configname(); 586 } else 587 basename = name; 588 } else 589 basename = conf_get_configname(); 590 591 sprintf(newname, "%s%s", dirname, basename); 592 env = getenv("KCONFIG_OVERWRITECONFIG"); 593 if (!env || !*env) { 594 sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid()); 595 out = fopen(tmpname, "w"); 596 } else { 597 *tmpname = 0; 598 out = fopen(newname, "w"); 599 } 600 if (!out) 601 return 1; 602 603 time(&now); 604 env = getenv("KCONFIG_NOTIMESTAMP"); 605 if (env && *env) 606 use_timestamp = 0; 607 608 fprintf(out, _("#\n" 609 "# Automatically generated make config: don't edit\n" 610 "# %s\n" 611 "%s%s" 612 "#\n"), 613 rootmenu.prompt->text, 614 use_timestamp ? "# " : "", 615 use_timestamp ? ctime(&now) : ""); 616 617 if (!conf_get_changed()) 618 sym_clear_all_valid(); 619 620 menu = rootmenu.list; 621 while (menu) { 622 sym = menu->sym; 623 if (!sym) { 624 if (!menu_is_visible(menu)) 625 goto next; 626 str = menu_get_prompt(menu); 627 fprintf(out, "\n" 628 "#\n" 629 "# %s\n" 630 "#\n", str); 631 } else if (!(sym->flags & SYMBOL_CHOICE)) { 632 sym_calc_value(sym); 633 if (!(sym->flags & SYMBOL_WRITE)) 634 goto next; 635 sym->flags &= ~SYMBOL_WRITE; 636 type = sym->type; 637 if (type == S_TRISTATE) { 638 sym_calc_value(modules_sym); 639 if (modules_sym->curr.tri == no) 640 type = S_BOOLEAN; 641 } 642 /* Write config symbol to file */ 643 conf_write_symbol(sym, type, out, true); 644 } 645 646 next: 647 if (menu->list) { 648 menu = menu->list; 649 continue; 650 } 651 if (menu->next) 652 menu = menu->next; 653 else while ((menu = menu->parent)) { 654 if (menu->next) { 655 menu = menu->next; 656 break; 657 } 658 } 659 } 660 fclose(out); 661 662 if (*tmpname) { 663 strcat(dirname, basename); 664 strcat(dirname, ".old"); 665 rename(newname, dirname); 666 if (rename(tmpname, newname)) 667 return 1; 668 } 669 670 conf_message(_("configuration written to %s"), newname); 671 672 sym_set_change_count(0); 673 674 return 0; 675 } 676 677 static int conf_split_config(void) 678 { 679 const char *name; 680 char path[PATH_MAX+1]; 681 char *s, *d, c; 682 struct symbol *sym; 683 struct stat sb; 684 int res, i, fd; 685 686 name = conf_get_autoconfig_name(); 687 conf_read_simple(name, S_DEF_AUTO); 688 689 if (chdir("include/config")) 690 return 1; 691 692 res = 0; 693 for_all_symbols(i, sym) { 694 sym_calc_value(sym); 695 if ((sym->flags & SYMBOL_AUTO) || !sym->name) 696 continue; 697 if (sym->flags & SYMBOL_WRITE) { 698 if (sym->flags & SYMBOL_DEF_AUTO) { 699 /* 700 * symbol has old and new value, 701 * so compare them... 702 */ 703 switch (sym->type) { 704 case S_BOOLEAN: 705 case S_TRISTATE: 706 if (sym_get_tristate_value(sym) == 707 sym->def[S_DEF_AUTO].tri) 708 continue; 709 break; 710 case S_STRING: 711 case S_HEX: 712 case S_INT: 713 if (!strcmp(sym_get_string_value(sym), 714 sym->def[S_DEF_AUTO].val)) 715 continue; 716 break; 717 default: 718 break; 719 } 720 } else { 721 /* 722 * If there is no old value, only 'no' (unset) 723 * is allowed as new value. 724 */ 725 switch (sym->type) { 726 case S_BOOLEAN: 727 case S_TRISTATE: 728 if (sym_get_tristate_value(sym) == no) 729 continue; 730 break; 731 default: 732 break; 733 } 734 } 735 } else if (!(sym->flags & SYMBOL_DEF_AUTO)) 736 /* There is neither an old nor a new value. */ 737 continue; 738 /* else 739 * There is an old value, but no new value ('no' (unset) 740 * isn't saved in auto.conf, so the old value is always 741 * different from 'no'). 742 */ 743 744 /* Replace all '_' and append ".h" */ 745 s = sym->name; 746 d = path; 747 while ((c = *s++)) { 748 c = tolower(c); 749 *d++ = (c == '_') ? '/' : c; 750 } 751 strcpy(d, ".h"); 752 753 /* Assume directory path already exists. */ 754 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644); 755 if (fd == -1) { 756 if (errno != ENOENT) { 757 res = 1; 758 break; 759 } 760 /* 761 * Create directory components, 762 * unless they exist already. 763 */ 764 d = path; 765 while ((d = strchr(d, '/'))) { 766 *d = 0; 767 if (stat(path, &sb) && mkdir(path, 0755)) { 768 res = 1; 769 goto out; 770 } 771 *d++ = '/'; 772 } 773 /* Try it again. */ 774 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644); 775 if (fd == -1) { 776 res = 1; 777 break; 778 } 779 } 780 close(fd); 781 } 782 out: 783 if (chdir("../..")) 784 return 1; 785 786 return res; 787 } 788 789 int conf_write_autoconf(void) 790 { 791 struct symbol *sym; 792 const char *str; 793 const char *name; 794 FILE *out, *tristate, *out_h; 795 time_t now; 796 int i; 797 798 sym_clear_all_valid(); 799 800 file_write_dep("include/config/auto.conf.cmd"); 801 802 if (conf_split_config()) 803 return 1; 804 805 out = fopen(".tmpconfig", "w"); 806 if (!out) 807 return 1; 808 809 tristate = fopen(".tmpconfig_tristate", "w"); 810 if (!tristate) { 811 fclose(out); 812 return 1; 813 } 814 815 out_h = fopen(".tmpconfig.h", "w"); 816 if (!out_h) { 817 fclose(out); 818 fclose(tristate); 819 return 1; 820 } 821 822 time(&now); 823 fprintf(out, "#\n" 824 "# Automatically generated make config: don't edit\n" 825 "# %s\n" 826 "# %s" 827 "#\n", 828 rootmenu.prompt->text, ctime(&now)); 829 fprintf(tristate, "#\n" 830 "# Automatically generated - do not edit\n" 831 "\n"); 832 fprintf(out_h, "/*\n" 833 " * Automatically generated C config: don't edit\n" 834 " * %s\n" 835 " * %s" 836 " */\n" 837 "#define AUTOCONF_INCLUDED\n", 838 rootmenu.prompt->text, ctime(&now)); 839 840 for_all_symbols(i, sym) { 841 sym_calc_value(sym); 842 if (!(sym->flags & SYMBOL_WRITE) || !sym->name) 843 continue; 844 845 /* write symbol to config file */ 846 conf_write_symbol(sym, sym->type, out, false); 847 848 /* update autoconf and tristate files */ 849 switch (sym->type) { 850 case S_BOOLEAN: 851 case S_TRISTATE: 852 switch (sym_get_tristate_value(sym)) { 853 case no: 854 break; 855 case mod: 856 fprintf(tristate, "%s%s=M\n", 857 CONFIG_, sym->name); 858 fprintf(out_h, "#define %s%s_MODULE 1\n", 859 CONFIG_, sym->name); 860 break; 861 case yes: 862 if (sym->type == S_TRISTATE) 863 fprintf(tristate,"%s%s=Y\n", 864 CONFIG_, sym->name); 865 fprintf(out_h, "#define %s%s 1\n", 866 CONFIG_, sym->name); 867 break; 868 } 869 break; 870 case S_STRING: 871 conf_write_string(true, sym->name, sym_get_string_value(sym), out_h); 872 break; 873 case S_HEX: 874 str = sym_get_string_value(sym); 875 if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) { 876 fprintf(out_h, "#define %s%s 0x%s\n", 877 CONFIG_, sym->name, str); 878 break; 879 } 880 case S_INT: 881 str = sym_get_string_value(sym); 882 fprintf(out_h, "#define %s%s %s\n", 883 CONFIG_, sym->name, str); 884 break; 885 default: 886 break; 887 } 888 } 889 fclose(out); 890 fclose(tristate); 891 fclose(out_h); 892 893 name = getenv("KCONFIG_AUTOHEADER"); 894 if (!name) 895 name = "include/generated/autoconf.h"; 896 if (rename(".tmpconfig.h", name)) 897 return 1; 898 name = getenv("KCONFIG_TRISTATE"); 899 if (!name) 900 name = "include/config/tristate.conf"; 901 if (rename(".tmpconfig_tristate", name)) 902 return 1; 903 name = conf_get_autoconfig_name(); 904 /* 905 * This must be the last step, kbuild has a dependency on auto.conf 906 * and this marks the successful completion of the previous steps. 907 */ 908 if (rename(".tmpconfig", name)) 909 return 1; 910 911 return 0; 912 } 913 914 static int sym_change_count; 915 static void (*conf_changed_callback)(void); 916 917 void sym_set_change_count(int count) 918 { 919 int _sym_change_count = sym_change_count; 920 sym_change_count = count; 921 if (conf_changed_callback && 922 (bool)_sym_change_count != (bool)count) 923 conf_changed_callback(); 924 } 925 926 void sym_add_change_count(int count) 927 { 928 sym_set_change_count(count + sym_change_count); 929 } 930 931 bool conf_get_changed(void) 932 { 933 return sym_change_count; 934 } 935 936 void conf_set_changed_callback(void (*fn)(void)) 937 { 938 conf_changed_callback = fn; 939 } 940 941 static void randomize_choice_values(struct symbol *csym) 942 { 943 struct property *prop; 944 struct symbol *sym; 945 struct expr *e; 946 int cnt, def; 947 948 /* 949 * If choice is mod then we may have more items slected 950 * and if no then no-one. 951 * In both cases stop. 952 */ 953 if (csym->curr.tri != yes) 954 return; 955 956 prop = sym_get_choice_prop(csym); 957 958 /* count entries in choice block */ 959 cnt = 0; 960 expr_list_for_each_sym(prop->expr, e, sym) 961 cnt++; 962 963 /* 964 * find a random value and set it to yes, 965 * set the rest to no so we have only one set 966 */ 967 def = (rand() % cnt); 968 969 cnt = 0; 970 expr_list_for_each_sym(prop->expr, e, sym) { 971 if (def == cnt++) { 972 sym->def[S_DEF_USER].tri = yes; 973 csym->def[S_DEF_USER].val = sym; 974 } 975 else { 976 sym->def[S_DEF_USER].tri = no; 977 } 978 } 979 csym->flags |= SYMBOL_DEF_USER; 980 /* clear VALID to get value calculated */ 981 csym->flags &= ~(SYMBOL_VALID); 982 } 983 984 static void set_all_choice_values(struct symbol *csym) 985 { 986 struct property *prop; 987 struct symbol *sym; 988 struct expr *e; 989 990 prop = sym_get_choice_prop(csym); 991 992 /* 993 * Set all non-assinged choice values to no 994 */ 995 expr_list_for_each_sym(prop->expr, e, sym) { 996 if (!sym_has_value(sym)) 997 sym->def[S_DEF_USER].tri = no; 998 } 999 csym->flags |= SYMBOL_DEF_USER; 1000 /* clear VALID to get value calculated */ 1001 csym->flags &= ~(SYMBOL_VALID); 1002 } 1003 1004 void conf_set_all_new_symbols(enum conf_def_mode mode) 1005 { 1006 struct symbol *sym, *csym; 1007 int i, cnt; 1008 1009 for_all_symbols(i, sym) { 1010 if (sym_has_value(sym)) 1011 continue; 1012 switch (sym_get_type(sym)) { 1013 case S_BOOLEAN: 1014 case S_TRISTATE: 1015 switch (mode) { 1016 case def_yes: 1017 sym->def[S_DEF_USER].tri = yes; 1018 break; 1019 case def_mod: 1020 sym->def[S_DEF_USER].tri = mod; 1021 break; 1022 case def_no: 1023 sym->def[S_DEF_USER].tri = no; 1024 break; 1025 case def_random: 1026 cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2; 1027 sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt); 1028 break; 1029 default: 1030 continue; 1031 } 1032 if (!(sym_is_choice(sym) && mode == def_random)) 1033 sym->flags |= SYMBOL_DEF_USER; 1034 break; 1035 default: 1036 break; 1037 } 1038 1039 } 1040 1041 sym_clear_all_valid(); 1042 1043 /* 1044 * We have different type of choice blocks. 1045 * If curr.tri equal to mod then we can select several 1046 * choice symbols in one block. 1047 * In this case we do nothing. 1048 * If curr.tri equal yes then only one symbol can be 1049 * selected in a choice block and we set it to yes, 1050 * and the rest to no. 1051 */ 1052 for_all_symbols(i, csym) { 1053 if (sym_has_value(csym) || !sym_is_choice(csym)) 1054 continue; 1055 1056 sym_calc_value(csym); 1057 if (mode == def_random) 1058 randomize_choice_values(csym); 1059 else 1060 set_all_choice_values(csym); 1061 } 1062 } 1063