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