scripts/kconfig/conf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
   4  */
   5
   6 #include <ctype.h>
   7 #include <limits.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <time.h>
  12 #include <unistd.h>
  13 #include <getopt.h>
  14 #include <sys/time.h>
  15 #include <errno.h>
  16
  17 #include "internal.h"
  18 #include "lkc.h"
  19
  20 static void conf(struct menu *menu);
  21 static void check_conf(struct menu *menu);
  22
  23 enum input_mode {
  24         oldaskconfig,
  25         syncconfig,
  26         oldconfig,
  27         allnoconfig,
  28         allyesconfig,
  29         allmodconfig,
  30         alldefconfig,
  31         randconfig,
  32         defconfig,
  33         savedefconfig,
  34         listnewconfig,
  35         helpnewconfig,
  36         olddefconfig,
  37         yes2modconfig,
  38         mod2yesconfig,
  39         mod2noconfig,
  40 };
  41 static enum input_mode input_mode = oldaskconfig;
  42 static int input_mode_opt;
  43 static int indent = 1;
  44 static int tty_stdio;
  45 static int sync_kconfig;
  46 static int conf_cnt;
  47 static char line[PATH_MAX];
  48 static struct menu *rootEntry;
  49
  50 static void print_help(struct menu *menu)
  51 {
  52         struct gstr help = str_new();
  53
  54         menu_get_ext_help(menu, &help);
  55
  56         printf("\n%s\n", str_get(&help));
  57         str_free(&help);
  58 }
  59
  60 static void strip(char *str)
  61 {
  62         char *p = str;
  63         int l;
  64
  65         while ((isspace(*p)))
  66                 p++;
  67         l = strlen(p);
  68         if (p != str)
  69                 memmove(str, p, l + 1);
  70         if (!l)
  71                 return;
  72         p = str + l - 1;
  73         while ((isspace(*p)))
  74                 *p-- = 0;
  75 }
  76
  77 /* Helper function to facilitate fgets() by Jean Sacren. */
  78 static void xfgets(char *str, int size, FILE *in)
  79 {
  80         if (!fgets(str, size, in))
  81                 fprintf(stderr, "\nError in reading or end of file.\n");
  82
  83         if (!tty_stdio)
  84                 printf("%s", str);
  85 }
  86
  87 static void set_randconfig_seed(void)
  88 {
  89         unsigned int seed;
  90         char *env;
  91         bool seed_set = false;
  92
  93         env = getenv("KCONFIG_SEED");
  94         if (env && *env) {
  95                 char *endp;
  96
  97                 seed = strtol(env, &endp, 0);
  98                 if (*endp == '\0')
  99                         seed_set = true;
 100         }
 101
 102         if (!seed_set) {
 103                 struct timeval now;
 104
 105                 /*
 106                  * Use microseconds derived seed, compensate for systems where it may
 107                  * be zero.
 108                  */
 109                 gettimeofday(&now, NULL);
 110                 seed = (now.tv_sec + 1) * (now.tv_usec + 1);
 111         }
 112
 113         printf("KCONFIG_SEED=0x%X\n", seed);
 114         srand(seed);
 115 }
 116
 117 /**
 118  * randomize_choice_values - randomize choice block
 119  *
 120  * @choice: menu entry for the choice
 121  */
 122 static void randomize_choice_values(struct menu *choice)
 123 {
 124         struct menu *menu;
 125         int x;
 126         int cnt = 0;
 127
 128         /*
 129          * First, count the number of symbols to randomize. If sym_has_value()
 130          * is true, it was specified by KCONFIG_ALLCONFIG. It needs to be
 131          * respected.
 132          */
 133         menu_for_each_sub_entry(menu, choice) {
 134                 struct symbol *sym = menu->sym;
 135
 136                 if (sym && !sym_has_value(sym))
 137                         cnt++;
 138         }
 139
 140         while (cnt > 0) {
 141                 x = rand() % cnt;
 142
 143                 menu_for_each_sub_entry(menu, choice) {
 144                         struct symbol *sym = menu->sym;
 145
 146                         if (sym && !sym_has_value(sym))
 147                                 x--;
 148
 149                         if (x < 0) {
 150                                 sym->def[S_DEF_USER].tri = yes;
 151                                 sym->flags |= SYMBOL_DEF_USER;
 152                                 /*
 153                                  * Move the selected item to the _tail_ because
 154                                  * this needs to have a lower priority than the
 155                                  * user input from KCONFIG_ALLCONFIG.
 156                                  */
 157                                 list_move_tail(&sym->choice_link,
 158                                                &choice->choice_members);
 159
 160                                 break;
 161                         }
 162                 }
 163                 cnt--;
 164         }
 165 }
 166
 167 enum conf_def_mode {
 168         def_default,
 169         def_yes,
 170         def_mod,
 171         def_no,
 172         def_random
 173 };
 174
 175 static void conf_set_all_new_symbols(enum conf_def_mode mode)
 176 {
 177         struct menu *menu;
 178         int cnt;
 179         /*
 180          * can't go as the default in switch-case below, otherwise gcc whines
 181          * about -Wmaybe-uninitialized
 182          */
 183         int pby = 50; /* probability of bool     = y */
 184         int pty = 33; /* probability of tristate = y */
 185         int ptm = 33; /* probability of tristate = m */
 186
 187         if (mode == def_random) {
 188                 int n, p[3];
 189                 char *env = getenv("KCONFIG_PROBABILITY");
 190
 191                 n = 0;
 192                 while (env && *env) {
 193                         char *endp;
 194                         int tmp = strtol(env, &endp, 10);
 195
 196                         if (tmp >= 0 && tmp <= 100) {
 197                                 p[n++] = tmp;
 198                         } else {
 199                                 errno = ERANGE;
 200                                 perror("KCONFIG_PROBABILITY");
 201                                 exit(1);
 202                         }
 203                         env = (*endp == ':') ? endp + 1 : endp;
 204                         if (n >= 3)
 205                                 break;
 206                 }
 207                 switch (n) {
 208                 case 1:
 209                         pby = p[0];
 210                         ptm = pby / 2;
 211                         pty = pby - ptm;
 212                         break;
 213                 case 2:
 214                         pty = p[0];
 215                         ptm = p[1];
 216                         pby = pty + ptm;
 217                         break;
 218                 case 3:
 219                         pby = p[0];
 220                         pty = p[1];
 221                         ptm = p[2];
 222                         break;
 223                 }
 224
 225                 if (pty + ptm > 100) {
 226                         errno = ERANGE;
 227                         perror("KCONFIG_PROBABILITY");
 228                         exit(1);
 229                 }
 230         }
 231
 232         menu_for_each_entry(menu) {
 233                 struct symbol *sym = menu->sym;
 234                 tristate val;
 235
 236                 if (!sym || !menu->prompt || sym_has_value(sym) ||
 237                     (sym->type != S_BOOLEAN && sym->type != S_TRISTATE) ||
 238                     sym_is_choice_value(sym))
 239                         continue;
 240
 241                 if (sym_is_choice(sym)) {
 242                         if (mode == def_random)
 243                                 randomize_choice_values(menu);
 244                         continue;
 245                 }
 246
 247                 switch (mode) {
 248                 case def_yes:
 249                         val = yes;
 250                         break;
 251                 case def_mod:
 252                         val = mod;
 253                         break;
 254                 case def_no:
 255                         val = no;
 256                         break;
 257                 case def_random:
 258                         val = no;
 259                         cnt = rand() % 100;
 260                         if (sym->type == S_TRISTATE) {
 261                                 if (cnt < pty)
 262                                         val = yes;
 263                                 else if (cnt < pty + ptm)
 264                                         val = mod;
 265                         } else if (cnt < pby) {
 266                                 val = yes;
 267                         }
 268                         break;
 269                 default:
 270                         continue;
 271                 }
 272                 sym->def[S_DEF_USER].tri = val;
 273                 sym->flags |= SYMBOL_DEF_USER;
 274         }
 275
 276         sym_clear_all_valid();
 277 }
 278
 279 static void conf_rewrite_tristates(tristate old_val, tristate new_val)
 280 {
 281         struct symbol *sym;
 282
 283         for_all_symbols(sym) {
 284                 if (sym_get_type(sym) == S_TRISTATE &&
 285                     sym->def[S_DEF_USER].tri == old_val)
 286                         sym->def[S_DEF_USER].tri = new_val;
 287         }
 288         sym_clear_all_valid();
 289 }
 290
 291 static int conf_askvalue(struct symbol *sym, const char *def)
 292 {
 293         if (!sym_has_value(sym))
 294                 printf("(NEW) ");
 295
 296         line[0] = '\n';
 297         line[1] = 0;
 298
 299         if (!sym_is_changeable(sym)) {
 300                 printf("%s\n", def);
 301                 line[0] = '\n';
 302                 line[1] = 0;
 303                 return 0;
 304         }
 305
 306         switch (input_mode) {
 307         case oldconfig:
 308         case syncconfig:
 309                 if (sym_has_value(sym)) {
 310                         printf("%s\n", def);
 311                         return 0;
 312                 }
 313                 /* fall through */
 314         default:
 315                 fflush(stdout);
 316                 xfgets(line, sizeof(line), stdin);
 317                 break;
 318         }
 319
 320         return 1;
 321 }
 322
 323 static int conf_string(struct menu *menu)
 324 {
 325         struct symbol *sym = menu->sym;
 326         const char *def;
 327
 328         while (1) {
 329                 printf("%*s%s ", indent - 1, "", menu->prompt->text);
 330                 printf("(%s) ", sym->name);
 331                 def = sym_get_string_value(sym);
 332                 if (def)
 333                         printf("[%s] ", def);
 334                 if (!conf_askvalue(sym, def))
 335                         return 0;
 336                 switch (line[0]) {
 337                 case '\n':
 338                         break;
 339                 case '?':
 340                         /* print help */
 341                         if (line[1] == '\n') {
 342                                 print_help(menu);
 343                                 def = NULL;
 344                                 break;
 345                         }
 346                         /* fall through */
 347                 default:
 348                         line[strlen(line)-1] = 0;
 349                         def = line;
 350                 }
 351                 if (def && sym_set_string_value(sym, def))
 352                         return 0;
 353         }
 354 }
 355
 356 static int conf_sym(struct menu *menu)
 357 {
 358         struct symbol *sym = menu->sym;
 359         tristate oldval, newval;
 360
 361         while (1) {
 362                 printf("%*s%s ", indent - 1, "", menu->prompt->text);
 363                 if (sym->name)
 364                         printf("(%s) ", sym->name);
 365                 putchar('[');
 366                 oldval = sym_get_tristate_value(sym);
 367                 switch (oldval) {
 368                 case no:
 369                         putchar('N');
 370                         break;
 371                 case mod:
 372                         putchar('M');
 373                         break;
 374                 case yes:
 375                         putchar('Y');
 376                         break;
 377                 }
 378                 if (oldval != no && sym_tristate_within_range(sym, no))
 379                         printf("/n");
 380                 if (oldval != mod && sym_tristate_within_range(sym, mod))
 381                         printf("/m");
 382                 if (oldval != yes && sym_tristate_within_range(sym, yes))
 383                         printf("/y");
 384                 printf("/?] ");
 385                 if (!conf_askvalue(sym, sym_get_string_value(sym)))
 386                         return 0;
 387                 strip(line);
 388
 389                 switch (line[0]) {
 390                 case 'n':
 391                 case 'N':
 392                         newval = no;
 393                         if (!line[1] || !strcmp(&line[1], "o"))
 394                                 break;
 395                         continue;
 396                 case 'm':
 397                 case 'M':
 398                         newval = mod;
 399                         if (!line[1])
 400                                 break;
 401                         continue;
 402                 case 'y':
 403                 case 'Y':
 404                         newval = yes;
 405                         if (!line[1] || !strcmp(&line[1], "es"))
 406                                 break;
 407                         continue;
 408                 case 0:
 409                         newval = oldval;
 410                         break;
 411                 case '?':
 412                         goto help;
 413                 default:
 414                         continue;
 415                 }
 416                 if (sym_set_tristate_value(sym, newval))
 417                         return 0;
 418 help:
 419                 print_help(menu);
 420         }
 421 }
 422
 423 static void conf_choice(struct menu *menu)
 424 {
 425         struct symbol *def_sym;
 426         struct menu *child;
 427         bool is_new = false;
 428
 429         while (1) {
 430                 int cnt, def;
 431
 432                 printf("%*s%s\n", indent - 1, "", menu_get_prompt(menu));
 433                 def_sym = sym_calc_choice(menu);
 434                 cnt = def = 0;
 435                 line[0] = 0;
 436                 for (child = menu->list; child; child = child->next) {
 437                         if (!menu_is_visible(child))
 438                                 continue;
 439                         if (!child->sym) {
 440                                 printf("%*c %s\n", indent, '*', menu_get_prompt(child));
 441                                 continue;
 442                         }
 443                         cnt++;
 444                         if (child->sym == def_sym) {
 445                                 def = cnt;
 446                                 printf("%*c", indent, '>');
 447                         } else
 448                                 printf("%*c", indent, ' ');
 449                         printf(" %d. %s (%s)", cnt, menu_get_prompt(child),
 450                                child->sym->name);
 451                         if (!sym_has_value(child->sym)) {
 452                                 is_new = true;
 453                                 printf(" (NEW)");
 454                         }
 455                         printf("\n");
 456                 }
 457                 printf("%*schoice", indent - 1, "");
 458                 if (cnt == 1) {
 459                         printf("[1]: 1\n");
 460                         goto conf_childs;
 461                 }
 462                 printf("[1-%d?]: ", cnt);
 463                 switch (input_mode) {
 464                 case oldconfig:
 465                 case syncconfig:
 466                         if (!is_new) {
 467                                 cnt = def;
 468                                 printf("%d\n", cnt);
 469                                 break;
 470                         }
 471                         /* fall through */
 472                 case oldaskconfig:
 473                         fflush(stdout);
 474                         xfgets(line, sizeof(line), stdin);
 475                         strip(line);
 476                         if (line[0] == '?') {
 477                                 print_help(menu);
 478                                 continue;
 479                         }
 480                         if (!line[0])
 481                                 cnt = def;
 482                         else if (isdigit(line[0]))
 483                                 cnt = atoi(line);
 484                         else
 485                                 continue;
 486                         break;
 487                 default:
 488                         break;
 489                 }
 490
 491         conf_childs:
 492                 for (child = menu->list; child; child = child->next) {
 493                         if (!child->sym || !menu_is_visible(child))
 494                                 continue;
 495                         if (!--cnt)
 496                                 break;
 497                 }
 498                 if (!child)
 499                         continue;
 500                 if (line[0] && line[strlen(line) - 1] == '?') {
 501                         print_help(child);
 502                         continue;
 503                 }
 504                 choice_set_value(menu, child->sym);
 505                 return;
 506         }
 507 }
 508
 509 static void conf(struct menu *menu)
 510 {
 511         struct symbol *sym;
 512         struct property *prop;
 513         struct menu *child;
 514
 515         if (!menu_is_visible(menu))
 516                 return;
 517
 518         sym = menu->sym;
 519         prop = menu->prompt;
 520         if (prop) {
 521                 const char *prompt;
 522
 523                 switch (prop->type) {
 524                 case P_MENU:
 525                         /*
 526                          * Except in oldaskconfig mode, we show only menus that
 527                          * contain new symbols.
 528                          */
 529                         if (input_mode != oldaskconfig && rootEntry != menu) {
 530                                 check_conf(menu);
 531                                 return;
 532                         }
 533                         /* fall through */
 534                 case P_COMMENT:
 535                         prompt = menu_get_prompt(menu);
 536                         if (prompt)
 537                                 printf("%*c\n%*c %s\n%*c\n",
 538                                         indent, '*',
 539                                         indent, '*', prompt,
 540                                         indent, '*');
 541                 default:
 542                         ;
 543                 }
 544         }
 545
 546         if (!sym)
 547                 goto conf_childs;
 548
 549         if (sym_is_choice(sym)) {
 550                 conf_choice(menu);
 551                 return;
 552         }
 553
 554         switch (sym->type) {
 555         case S_INT:
 556         case S_HEX:
 557         case S_STRING:
 558                 conf_string(menu);
 559                 break;
 560         default:
 561                 conf_sym(menu);
 562                 break;
 563         }
 564
 565 conf_childs:
 566         if (sym)
 567                 indent += 2;
 568         for (child = menu->list; child; child = child->next)
 569                 conf(child);
 570         if (sym)
 571                 indent -= 2;
 572 }
 573
 574 static void check_conf(struct menu *menu)
 575 {
 576         struct symbol *sym;
 577         struct menu *child;
 578
 579         if (!menu_is_visible(menu))
 580                 return;
 581
 582         sym = menu->sym;
 583         if (sym && !sym_has_value(sym) && sym_is_changeable(sym)) {
 584                 switch (input_mode) {
 585                 case listnewconfig:
 586                         if (sym->name)
 587                                 print_symbol_for_listconfig(sym);
 588                         break;
 589                 case helpnewconfig:
 590                         printf("-----\n");
 591                         print_help(menu);
 592                         printf("-----\n");
 593                         break;
 594                 default:
 595                         if (!conf_cnt++)
 596                                 printf("*\n* Restart config...\n*\n");
 597                         rootEntry = menu_get_parent_menu(menu);
 598                         conf(rootEntry);
 599                         break;
 600                 }
 601         }
 602
 603         for (child = menu->list; child; child = child->next)
 604                 check_conf(child);
 605 }
 606
 607 static const struct option long_opts[] = {
 608         {"help",          no_argument,       NULL,            'h'},
 609         {"silent",        no_argument,       NULL,            's'},
 610         {"oldaskconfig",  no_argument,       &input_mode_opt, oldaskconfig},
 611         {"oldconfig",     no_argument,       &input_mode_opt, oldconfig},
 612         {"syncconfig",    no_argument,       &input_mode_opt, syncconfig},
 613         {"defconfig",     required_argument, &input_mode_opt, defconfig},
 614         {"savedefconfig", required_argument, &input_mode_opt, savedefconfig},
 615         {"allnoconfig",   no_argument,       &input_mode_opt, allnoconfig},
 616         {"allyesconfig",  no_argument,       &input_mode_opt, allyesconfig},
 617         {"allmodconfig",  no_argument,       &input_mode_opt, allmodconfig},
 618         {"alldefconfig",  no_argument,       &input_mode_opt, alldefconfig},
 619         {"randconfig",    no_argument,       &input_mode_opt, randconfig},
 620         {"listnewconfig", no_argument,       &input_mode_opt, listnewconfig},
 621         {"helpnewconfig", no_argument,       &input_mode_opt, helpnewconfig},
 622         {"olddefconfig",  no_argument,       &input_mode_opt, olddefconfig},
 623         {"yes2modconfig", no_argument,       &input_mode_opt, yes2modconfig},
 624         {"mod2yesconfig", no_argument,       &input_mode_opt, mod2yesconfig},
 625         {"mod2noconfig",  no_argument,       &input_mode_opt, mod2noconfig},
 626         {NULL, 0, NULL, 0}
 627 };
 628
 629 static void conf_usage(const char *progname)
 630 {
 631         printf("Usage: %s [options] kconfig_file\n", progname);
 632         printf("\n");
 633         printf("Generic options:\n");
 634         printf("  -h, --help              Print this message and exit.\n");
 635         printf("  -s, --silent            Do not print log.\n");
 636         printf("\n");
 637         printf("Mode options:\n");
 638         printf("  --listnewconfig         List new options\n");
 639         printf("  --helpnewconfig         List new options and help text\n");
 640         printf("  --oldaskconfig          Start a new configuration using a line-oriented program\n");
 641         printf("  --oldconfig             Update a configuration using a provided .config as base\n");
 642         printf("  --syncconfig            Similar to oldconfig but generates configuration in\n"
 643                "                          include/{generated/,config/}\n");
 644         printf("  --olddefconfig          Same as oldconfig but sets new symbols to their default value\n");
 645         printf("  --defconfig <file>      New config with default defined in <file>\n");
 646         printf("  --savedefconfig <file>  Save the minimal current configuration to <file>\n");
 647         printf("  --allnoconfig           New config where all options are answered with no\n");
 648         printf("  --allyesconfig          New config where all options are answered with yes\n");
 649         printf("  --allmodconfig          New config where all options are answered with mod\n");
 650         printf("  --alldefconfig          New config with all symbols set to default\n");
 651         printf("  --randconfig            New config with random answer to all options\n");
 652         printf("  --yes2modconfig         Change answers from yes to mod if possible\n");
 653         printf("  --mod2yesconfig         Change answers from mod to yes if possible\n");
 654         printf("  --mod2noconfig          Change answers from mod to no if possible\n");
 655         printf("  (If none of the above is given, --oldaskconfig is the default)\n");
 656         printf("\n");
 657         printf("Arguments:\n");
 658         printf("  kconfig_file            Top-level Kconfig file.\n");
 659 }
 660
 661 int main(int ac, char **av)
 662 {
 663         const char *progname = av[0];
 664         int opt;
 665         const char *name, *defconfig_file = NULL /* gcc uninit */;
 666         int no_conf_write = 0;
 667
 668         tty_stdio = isatty(0) && isatty(1);
 669
 670         while ((opt = getopt_long(ac, av, "hs", long_opts, NULL)) != -1) {
 671                 switch (opt) {
 672                 case 'h':
 673                         conf_usage(progname);
 674                         exit(1);
 675                         break;
 676                 case 's':
 677                         conf_set_message_callback(NULL);
 678                         break;
 679                 case 0:
 680                         input_mode = input_mode_opt;
 681                         switch (input_mode) {
 682                         case syncconfig:
 683                                 /*
 684                                  * syncconfig is invoked during the build stage.
 685                                  * Suppress distracting
 686                                  *   "configuration written to ..."
 687                                  */
 688                                 conf_set_message_callback(NULL);
 689                                 sync_kconfig = 1;
 690                                 break;
 691                         case defconfig:
 692                         case savedefconfig:
 693                                 defconfig_file = optarg;
 694                                 break;
 695                         case randconfig:
 696                                 set_randconfig_seed();
 697                                 break;
 698                         default:
 699                                 break;
 700                         }
 701                 default:
 702                         break;
 703                 }
 704         }
 705         if (ac == optind) {
 706                 fprintf(stderr, "%s: Kconfig file missing\n", av[0]);
 707                 conf_usage(progname);
 708                 exit(1);
 709         }
 710         conf_parse(av[optind]);
 711         //zconfdump(stdout);
 712
 713         switch (input_mode) {
 714         case defconfig:
 715                 if (conf_read(defconfig_file)) {
 716                         fprintf(stderr,
 717                                 "***\n"
 718                                   "*** Can't find default configuration \"%s\"!\n"
 719                                   "***\n",
 720                                 defconfig_file);
 721                         exit(1);
 722                 }
 723                 break;
 724         case savedefconfig:
 725         case syncconfig:
 726         case oldaskconfig:
 727         case oldconfig:
 728         case listnewconfig:
 729         case helpnewconfig:
 730         case olddefconfig:
 731         case yes2modconfig:
 732         case mod2yesconfig:
 733         case mod2noconfig:
 734                 conf_read(NULL);
 735                 break;
 736         case allnoconfig:
 737         case allyesconfig:
 738         case allmodconfig:
 739         case alldefconfig:
 740         case randconfig:
 741                 name = getenv("KCONFIG_ALLCONFIG");
 742                 if (!name)
 743                         break;
 744                 if ((strcmp(name, "") != 0) && (strcmp(name, "1") != 0)) {
 745                         if (conf_read_simple(name, S_DEF_USER)) {
 746                                 fprintf(stderr,
 747                                         "*** Can't read seed configuration \"%s\"!\n",
 748                                         name);
 749                                 exit(1);
 750                         }
 751                         break;
 752                 }
 753                 switch (input_mode) {
 754                 case allnoconfig:       name = "allno.config"; break;
 755                 case allyesconfig:      name = "allyes.config"; break;
 756                 case allmodconfig:      name = "allmod.config"; break;
 757                 case alldefconfig:      name = "alldef.config"; break;
 758                 case randconfig:        name = "allrandom.config"; break;
 759                 default: break;
 760                 }
 761                 if (conf_read_simple(name, S_DEF_USER) &&
 762                     conf_read_simple("all.config", S_DEF_USER)) {
 763                         fprintf(stderr,
 764                                 "*** KCONFIG_ALLCONFIG set, but no \"%s\" or \"all.config\" file found\n",
 765                                 name);
 766                         exit(1);
 767                 }
 768                 break;
 769         default:
 770                 break;
 771         }
 772
 773         if (conf_errors())
 774                 exit(1);
 775
 776         if (sync_kconfig) {
 777                 name = getenv("KCONFIG_NOSILENTUPDATE");
 778                 if (name && *name) {
 779                         if (conf_get_changed()) {
 780                                 fprintf(stderr,
 781                                         "\n*** The configuration requires explicit update.\n\n");
 782                                 return 1;
 783                         }
 784                         no_conf_write = 1;
 785                 }
 786         }
 787
 788         switch (input_mode) {
 789         case allnoconfig:
 790                 conf_set_all_new_symbols(def_no);
 791                 break;
 792         case allyesconfig:
 793                 conf_set_all_new_symbols(def_yes);
 794                 break;
 795         case allmodconfig:
 796                 conf_set_all_new_symbols(def_mod);
 797                 break;
 798         case alldefconfig:
 799                 conf_set_all_new_symbols(def_default);
 800                 break;
 801         case randconfig:
 802                 conf_set_all_new_symbols(def_random);
 803                 break;
 804         case defconfig:
 805                 conf_set_all_new_symbols(def_default);
 806                 break;
 807         case savedefconfig:
 808                 break;
 809         case yes2modconfig:
 810                 conf_rewrite_tristates(yes, mod);
 811                 break;
 812         case mod2yesconfig:
 813                 conf_rewrite_tristates(mod, yes);
 814                 break;
 815         case mod2noconfig:
 816                 conf_rewrite_tristates(mod, no);
 817                 break;
 818         case oldaskconfig:
 819                 rootEntry = &rootmenu;
 820                 conf(&rootmenu);
 821                 input_mode = oldconfig;
 822                 /* fall through */
 823         case oldconfig:
 824         case listnewconfig:
 825         case helpnewconfig:
 826         case syncconfig:
 827                 /* Update until a loop caused no more changes */
 828                 do {
 829                         conf_cnt = 0;
 830                         check_conf(&rootmenu);
 831                 } while (conf_cnt);
 832                 break;
 833         case olddefconfig:
 834         default:
 835                 break;
 836         }
 837
 838         if (sym_dep_errors())
 839                 exit(1);
 840
 841         if (input_mode == savedefconfig) {
 842                 if (conf_write_defconfig(defconfig_file)) {
 843                         fprintf(stderr, "n*** Error while saving defconfig to: %s\n\n",
 844                                 defconfig_file);
 845                         return 1;
 846                 }
 847         } else if (input_mode != listnewconfig && input_mode != helpnewconfig) {
 848                 if (!no_conf_write && conf_write(NULL)) {
 849                         fprintf(stderr, "\n*** Error during writing of the configuration.\n\n");
 850                         exit(1);
 851                 }
 852
 853                 /*
 854                  * Create auto.conf if it does not exist.
 855                  * This prevents GNU Make 4.1 or older from emitting
 856                  * "include/config/auto.conf: No such file or directory"
 857                  * in the top-level Makefile
 858                  *
 859                  * syncconfig always creates or updates auto.conf because it is
 860                  * used during the build.
 861                  */
 862                 if (conf_write_autoconf(sync_kconfig) && sync_kconfig) {
 863                         fprintf(stderr,
 864                                 "\n*** Error during sync of the configuration.\n\n");
 865                         return 1;
 866                 }
 867         }
 868         return 0;
 869 }