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