util/kconfig/confdata.c

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