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