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