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