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, FILE *out, bool write_no) 444 { 445 const char *str; 446 447 switch (sym->type) { 448 case S_BOOLEAN: 449 case S_TRISTATE: 450 switch (sym_get_tristate_value(sym)) { 451 case no: 452 if (write_no) 453 fprintf(out, "# %s%s is not set\n", 454 CONFIG_, sym->name); 455 break; 456 case mod: 457 fprintf(out, "%s%s=m\n", CONFIG_, sym->name); 458 break; 459 case yes: 460 fprintf(out, "%s%s=y\n", CONFIG_, sym->name); 461 break; 462 } 463 break; 464 case S_STRING: 465 conf_write_string(false, sym->name, sym_get_string_value(sym), out); 466 break; 467 case S_HEX: 468 case S_INT: 469 str = sym_get_string_value(sym); 470 fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str); 471 break; 472 case S_OTHER: 473 case S_UNKNOWN: 474 break; 475 } 476 } 477 478 /* 479 * Write out a minimal config. 480 * All values that has default values are skipped as this is redundant. 481 */ 482 int conf_write_defconfig(const char *filename) 483 { 484 struct symbol *sym; 485 struct menu *menu; 486 FILE *out; 487 488 out = fopen(filename, "w"); 489 if (!out) 490 return 1; 491 492 sym_clear_all_valid(); 493 494 /* Traverse all menus to find all relevant symbols */ 495 menu = rootmenu.list; 496 497 while (menu != NULL) 498 { 499 sym = menu->sym; 500 if (sym == NULL) { 501 if (!menu_is_visible(menu)) 502 goto next_menu; 503 } else if (!sym_is_choice(sym)) { 504 sym_calc_value(sym); 505 if (!(sym->flags & SYMBOL_WRITE)) 506 goto next_menu; 507 sym->flags &= ~SYMBOL_WRITE; 508 /* If we cannot change the symbol - skip */ 509 if (!sym_is_changable(sym)) 510 goto next_menu; 511 /* If symbol equals to default value - skip */ 512 if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0) 513 goto next_menu; 514 515 /* 516 * If symbol is a choice value and equals to the 517 * default for a choice - skip. 518 * But only if value is bool and equal to "y" and 519 * choice is not "optional". 520 * (If choice is "optional" then all values can be "n") 521 */ 522 if (sym_is_choice_value(sym)) { 523 struct symbol *cs; 524 struct symbol *ds; 525 526 cs = prop_get_symbol(sym_get_choice_prop(sym)); 527 ds = sym_choice_default(cs); 528 if (!sym_is_optional(cs) && sym == ds) { 529 if ((sym->type == S_BOOLEAN) && 530 sym_get_tristate_value(sym) == yes) 531 goto next_menu; 532 } 533 } 534 conf_write_symbol(sym, out, true); 535 } 536 next_menu: 537 if (menu->list != NULL) { 538 menu = menu->list; 539 } 540 else if (menu->next != NULL) { 541 menu = menu->next; 542 } else { 543 while ((menu = menu->parent)) { 544 if (menu->next != NULL) { 545 menu = menu->next; 546 break; 547 } 548 } 549 } 550 } 551 fclose(out); 552 return 0; 553 } 554 555 int conf_write(const char *name) 556 { 557 FILE *out; 558 struct symbol *sym; 559 struct menu *menu; 560 const char *basename; 561 const char *str; 562 char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1]; 563 char *env; 564 565 dirname[0] = 0; 566 if (name && name[0]) { 567 struct stat st; 568 char *slash; 569 570 if (!stat(name, &st) && S_ISDIR(st.st_mode)) { 571 strcpy(dirname, name); 572 strcat(dirname, "/"); 573 basename = conf_get_configname(); 574 } else if ((slash = strrchr(name, '/'))) { 575 int size = slash - name + 1; 576 memcpy(dirname, name, size); 577 dirname[size] = 0; 578 if (slash[1]) 579 basename = slash + 1; 580 else 581 basename = conf_get_configname(); 582 } else 583 basename = name; 584 } else 585 basename = conf_get_configname(); 586 587 sprintf(newname, "%s%s", dirname, basename); 588 env = getenv("KCONFIG_OVERWRITECONFIG"); 589 if (!env || !*env) { 590 sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid()); 591 out = fopen(tmpname, "w"); 592 } else { 593 *tmpname = 0; 594 out = fopen(newname, "w"); 595 } 596 if (!out) 597 return 1; 598 599 fprintf(out, _("#\n" 600 "# Automatically generated make config: don't edit\n" 601 "# %s\n" 602 "#\n"), 603 rootmenu.prompt->text); 604 605 if (!conf_get_changed()) 606 sym_clear_all_valid(); 607 608 menu = rootmenu.list; 609 while (menu) { 610 sym = menu->sym; 611 if (!sym) { 612 if (!menu_is_visible(menu)) 613 goto next; 614 str = menu_get_prompt(menu); 615 fprintf(out, "\n" 616 "#\n" 617 "# %s\n" 618 "#\n", str); 619 } else if (!(sym->flags & SYMBOL_CHOICE)) { 620 sym_calc_value(sym); 621 if (!(sym->flags & SYMBOL_WRITE)) 622 goto next; 623 sym->flags &= ~SYMBOL_WRITE; 624 /* Write config symbol to file */ 625 conf_write_symbol(sym, out, true); 626 } 627 628 next: 629 if (menu->list) { 630 menu = menu->list; 631 continue; 632 } 633 if (menu->next) 634 menu = menu->next; 635 else while ((menu = menu->parent)) { 636 if (menu->next) { 637 menu = menu->next; 638 break; 639 } 640 } 641 } 642 fclose(out); 643 644 if (*tmpname) { 645 strcat(dirname, basename); 646 strcat(dirname, ".old"); 647 rename(newname, dirname); 648 if (rename(tmpname, newname)) 649 return 1; 650 } 651 652 conf_message(_("configuration written to %s"), newname); 653 654 sym_set_change_count(0); 655 656 return 0; 657 } 658 659 static int conf_split_config(void) 660 { 661 const char *name; 662 char path[PATH_MAX+1]; 663 char *s, *d, c; 664 struct symbol *sym; 665 struct stat sb; 666 int res, i, fd; 667 668 name = conf_get_autoconfig_name(); 669 conf_read_simple(name, S_DEF_AUTO); 670 671 if (chdir("include/config")) 672 return 1; 673 674 res = 0; 675 for_all_symbols(i, sym) { 676 sym_calc_value(sym); 677 if ((sym->flags & SYMBOL_AUTO) || !sym->name) 678 continue; 679 if (sym->flags & SYMBOL_WRITE) { 680 if (sym->flags & SYMBOL_DEF_AUTO) { 681 /* 682 * symbol has old and new value, 683 * so compare them... 684 */ 685 switch (sym->type) { 686 case S_BOOLEAN: 687 case S_TRISTATE: 688 if (sym_get_tristate_value(sym) == 689 sym->def[S_DEF_AUTO].tri) 690 continue; 691 break; 692 case S_STRING: 693 case S_HEX: 694 case S_INT: 695 if (!strcmp(sym_get_string_value(sym), 696 sym->def[S_DEF_AUTO].val)) 697 continue; 698 break; 699 default: 700 break; 701 } 702 } else { 703 /* 704 * If there is no old value, only 'no' (unset) 705 * is allowed as new value. 706 */ 707 switch (sym->type) { 708 case S_BOOLEAN: 709 case S_TRISTATE: 710 if (sym_get_tristate_value(sym) == no) 711 continue; 712 break; 713 default: 714 break; 715 } 716 } 717 } else if (!(sym->flags & SYMBOL_DEF_AUTO)) 718 /* There is neither an old nor a new value. */ 719 continue; 720 /* else 721 * There is an old value, but no new value ('no' (unset) 722 * isn't saved in auto.conf, so the old value is always 723 * different from 'no'). 724 */ 725 726 /* Replace all '_' and append ".h" */ 727 s = sym->name; 728 d = path; 729 while ((c = *s++)) { 730 c = tolower(c); 731 *d++ = (c == '_') ? '/' : c; 732 } 733 strcpy(d, ".h"); 734 735 /* Assume directory path already exists. */ 736 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644); 737 if (fd == -1) { 738 if (errno != ENOENT) { 739 res = 1; 740 break; 741 } 742 /* 743 * Create directory components, 744 * unless they exist already. 745 */ 746 d = path; 747 while ((d = strchr(d, '/'))) { 748 *d = 0; 749 if (stat(path, &sb) && mkdir(path, 0755)) { 750 res = 1; 751 goto out; 752 } 753 *d++ = '/'; 754 } 755 /* Try it again. */ 756 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644); 757 if (fd == -1) { 758 res = 1; 759 break; 760 } 761 } 762 close(fd); 763 } 764 out: 765 if (chdir("../..")) 766 return 1; 767 768 return res; 769 } 770 771 int conf_write_autoconf(void) 772 { 773 struct symbol *sym; 774 const char *str; 775 const char *name; 776 FILE *out, *tristate, *out_h; 777 int i; 778 779 sym_clear_all_valid(); 780 781 file_write_dep("include/config/auto.conf.cmd"); 782 783 if (conf_split_config()) 784 return 1; 785 786 out = fopen(".tmpconfig", "w"); 787 if (!out) 788 return 1; 789 790 tristate = fopen(".tmpconfig_tristate", "w"); 791 if (!tristate) { 792 fclose(out); 793 return 1; 794 } 795 796 out_h = fopen(".tmpconfig.h", "w"); 797 if (!out_h) { 798 fclose(out); 799 fclose(tristate); 800 return 1; 801 } 802 803 fprintf(out, "#\n" 804 "# Automatically generated make config: don't edit\n" 805 "# %s\n" 806 "#\n", 807 rootmenu.prompt->text); 808 fprintf(tristate, "#\n" 809 "# Automatically generated - do not edit\n" 810 "\n"); 811 fprintf(out_h, "/*\n" 812 " * Automatically generated C config: don't edit\n" 813 " * %s\n" 814 " */\n", 815 rootmenu.prompt->text); 816 817 for_all_symbols(i, sym) { 818 sym_calc_value(sym); 819 if (!(sym->flags & SYMBOL_WRITE) || !sym->name) 820 continue; 821 822 /* write symbol to config file */ 823 conf_write_symbol(sym, out, false); 824 825 /* update autoconf and tristate files */ 826 switch (sym->type) { 827 case S_BOOLEAN: 828 case S_TRISTATE: 829 switch (sym_get_tristate_value(sym)) { 830 case no: 831 break; 832 case mod: 833 fprintf(tristate, "%s%s=M\n", 834 CONFIG_, sym->name); 835 fprintf(out_h, "#define %s%s_MODULE 1\n", 836 CONFIG_, sym->name); 837 break; 838 case yes: 839 if (sym->type == S_TRISTATE) 840 fprintf(tristate,"%s%s=Y\n", 841 CONFIG_, sym->name); 842 fprintf(out_h, "#define %s%s 1\n", 843 CONFIG_, sym->name); 844 break; 845 } 846 break; 847 case S_STRING: 848 conf_write_string(true, sym->name, sym_get_string_value(sym), out_h); 849 break; 850 case S_HEX: 851 str = sym_get_string_value(sym); 852 if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) { 853 fprintf(out_h, "#define %s%s 0x%s\n", 854 CONFIG_, sym->name, str); 855 break; 856 } 857 case S_INT: 858 str = sym_get_string_value(sym); 859 fprintf(out_h, "#define %s%s %s\n", 860 CONFIG_, sym->name, str); 861 break; 862 default: 863 break; 864 } 865 } 866 fclose(out); 867 fclose(tristate); 868 fclose(out_h); 869 870 name = getenv("KCONFIG_AUTOHEADER"); 871 if (!name) 872 name = "include/generated/autoconf.h"; 873 if (rename(".tmpconfig.h", name)) 874 return 1; 875 name = getenv("KCONFIG_TRISTATE"); 876 if (!name) 877 name = "include/config/tristate.conf"; 878 if (rename(".tmpconfig_tristate", name)) 879 return 1; 880 name = conf_get_autoconfig_name(); 881 /* 882 * This must be the last step, kbuild has a dependency on auto.conf 883 * and this marks the successful completion of the previous steps. 884 */ 885 if (rename(".tmpconfig", name)) 886 return 1; 887 888 return 0; 889 } 890 891 static int sym_change_count; 892 static void (*conf_changed_callback)(void); 893 894 void sym_set_change_count(int count) 895 { 896 int _sym_change_count = sym_change_count; 897 sym_change_count = count; 898 if (conf_changed_callback && 899 (bool)_sym_change_count != (bool)count) 900 conf_changed_callback(); 901 } 902 903 void sym_add_change_count(int count) 904 { 905 sym_set_change_count(count + sym_change_count); 906 } 907 908 bool conf_get_changed(void) 909 { 910 return sym_change_count; 911 } 912 913 void conf_set_changed_callback(void (*fn)(void)) 914 { 915 conf_changed_callback = fn; 916 } 917 918 static void randomize_choice_values(struct symbol *csym) 919 { 920 struct property *prop; 921 struct symbol *sym; 922 struct expr *e; 923 int cnt, def; 924 925 /* 926 * If choice is mod then we may have more items selected 927 * and if no then no-one. 928 * In both cases stop. 929 */ 930 if (csym->curr.tri != yes) 931 return; 932 933 prop = sym_get_choice_prop(csym); 934 935 /* count entries in choice block */ 936 cnt = 0; 937 expr_list_for_each_sym(prop->expr, e, sym) 938 cnt++; 939 940 /* 941 * find a random value and set it to yes, 942 * set the rest to no so we have only one set 943 */ 944 def = (rand() % cnt); 945 946 cnt = 0; 947 expr_list_for_each_sym(prop->expr, e, sym) { 948 if (def == cnt++) { 949 sym->def[S_DEF_USER].tri = yes; 950 csym->def[S_DEF_USER].val = sym; 951 } 952 else { 953 sym->def[S_DEF_USER].tri = no; 954 } 955 } 956 csym->flags |= SYMBOL_DEF_USER; 957 /* clear VALID to get value calculated */ 958 csym->flags &= ~(SYMBOL_VALID); 959 } 960 961 static void set_all_choice_values(struct symbol *csym) 962 { 963 struct property *prop; 964 struct symbol *sym; 965 struct expr *e; 966 967 prop = sym_get_choice_prop(csym); 968 969 /* 970 * Set all non-assinged choice values to no 971 */ 972 expr_list_for_each_sym(prop->expr, e, sym) { 973 if (!sym_has_value(sym)) 974 sym->def[S_DEF_USER].tri = no; 975 } 976 csym->flags |= SYMBOL_DEF_USER; 977 /* clear VALID to get value calculated */ 978 csym->flags &= ~(SYMBOL_VALID); 979 } 980 981 void conf_set_all_new_symbols(enum conf_def_mode mode) 982 { 983 struct symbol *sym, *csym; 984 int i, cnt; 985 986 for_all_symbols(i, sym) { 987 if (sym_has_value(sym)) 988 continue; 989 switch (sym_get_type(sym)) { 990 case S_BOOLEAN: 991 case S_TRISTATE: 992 switch (mode) { 993 case def_yes: 994 sym->def[S_DEF_USER].tri = yes; 995 break; 996 case def_mod: 997 sym->def[S_DEF_USER].tri = mod; 998 break; 999 case def_no: 1000 sym->def[S_DEF_USER].tri = no; 1001 break; 1002 case def_random: 1003 cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2; 1004 sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt); 1005 break; 1006 default: 1007 continue; 1008 } 1009 if (!(sym_is_choice(sym) && mode == def_random)) 1010 sym->flags |= SYMBOL_DEF_USER; 1011 break; 1012 default: 1013 break; 1014 } 1015 1016 } 1017 1018 sym_clear_all_valid(); 1019 1020 /* 1021 * We have different type of choice blocks. 1022 * If curr.tri equals to mod then we can select several 1023 * choice symbols in one block. 1024 * In this case we do nothing. 1025 * If curr.tri equals yes then only one symbol can be 1026 * selected in a choice block and we set it to yes, 1027 * and the rest to no. 1028 */ 1029 for_all_symbols(i, csym) { 1030 if (sym_has_value(csym) || !sym_is_choice(csym)) 1031 continue; 1032 1033 sym_calc_value(csym); 1034 if (mode == def_random) 1035 randomize_choice_values(csym); 1036 else 1037 set_all_choice_values(csym); 1038 } 1039 } 1040