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