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