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