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 tmpname[PATH_MAX+1], newname[PATH_MAX+1];
738 char *env, *dirname = NULL;
739
740 if (name && name[0]) {
741 struct stat st;
742 char *slash;
743
744 if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
745 dirname = strndup(name, strlen(name) + 1);
746 strcat(dirname, "/");
747 basename = conf_get_configname();
748 } else if ((slash = strrchr(name, '/'))) {
749 int size = slash - name + 1;
750 dirname = strndup(name, size);
751 if (slash[1])
752 basename = slash + 1;
753 else
754 basename = conf_get_configname();
755 } else
756 basename = name;
757 } else {
758 dirname = strdup(conf_get_configname());
759 basename = strdup(base_name(dirname));
760 dirname = dir_name(dirname);
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 free(dirname);
772 if (!out)
773 return 1;
774
775 conf_write_heading(out, &kconfig_printer_cb, NULL);
776
777 if (!conf_get_changed())
778 sym_clear_all_valid();
779
780 menu = rootmenu.list;
781 while (menu) {
782 sym = menu->sym;
783 if (!sym) {
784 if (!menu_is_visible(menu))
785 goto next;
786 str = menu_get_prompt(menu);
787 fprintf(out, "\n"
788 "#\n"
789 "# %s\n"
790 "#\n", str);
791 } else if (!(sym->flags & SYMBOL_CHOICE)) {
792 sym_calc_value(sym);
793 if (!(sym->flags & SYMBOL_WRITE))
794 goto next;
795 sym->flags &= ~SYMBOL_WRITE;
796
797 conf_write_symbol(out, sym, &kconfig_printer_cb, NULL);
798 }
799
800 next:
801 if (menu->list) {
802 menu = menu->list;
803 continue;
804 }
805 if (menu->next)
806 menu = menu->next;
807 else while ((menu = menu->parent)) {
808 if (menu->next) {
809 menu = menu->next;
810 break;
811 }
812 }
813 }
814 fclose(out);
815
816 if (*tmpname) {
817 dirname = strndup(basename, strlen(basename) + 4);
818 strcat(dirname, ".old");
819 rename(newname, dirname);
820 free(dirname);
821 if (rename(tmpname, newname))
822 return 1;
823 }
824
825 conf_message(_("configuration written to %s"), newname);
826
827 sym_set_change_count(0);
828
829 return 0;
830 }
831
conf_split_config(void)832 static int conf_split_config(void)
833 {
834 const char *name;
835 char path[PATH_MAX+1], opwd[PATH_MAX+1];
836 char *s, *d, c;
837 struct symbol *sym;
838 struct stat sb;
839 int res, i, fd;
840
841 if (getcwd(opwd, sizeof(opwd)) == NULL)
842 return 1;
843 name = conf_get_autoconfig_name();
844 conf_read_simple(name, S_DEF_AUTO);
845
846 strcpy(path, name);
847 dir_name(path);
848
849 if (chdir(path))
850 return 1;
851
852 res = 0;
853 for_all_symbols(i, sym) {
854 sym_calc_value(sym);
855 if ((sym->flags & SYMBOL_AUTO) || !sym->name)
856 continue;
857 if (sym->flags & SYMBOL_WRITE) {
858 if (sym->flags & SYMBOL_DEF_AUTO) {
859 /*
860 * symbol has old and new value,
861 * so compare them...
862 */
863 switch (sym->type) {
864 case S_BOOLEAN:
865 case S_TRISTATE:
866 if (sym_get_tristate_value(sym) ==
867 sym->def[S_DEF_AUTO].tri)
868 continue;
869 break;
870 case S_STRING:
871 case S_HEX:
872 case S_INT:
873 if (!strcmp(sym_get_string_value(sym),
874 sym->def[S_DEF_AUTO].val))
875 continue;
876 break;
877 default:
878 break;
879 }
880 } else {
881 /*
882 * If there is no old value, only 'no' (unset)
883 * is allowed as new value.
884 */
885 switch (sym->type) {
886 case S_BOOLEAN:
887 case S_TRISTATE:
888 if (sym_get_tristate_value(sym) == no)
889 continue;
890 break;
891 default:
892 break;
893 }
894 }
895 } else if (!(sym->flags & SYMBOL_DEF_AUTO))
896 /* There is neither an old nor a new value. */
897 continue;
898 /* else
899 * There is an old value, but no new value ('no' (unset)
900 * isn't saved in auto.conf, so the old value is always
901 * different from 'no').
902 */
903
904 /* Replace all '_' and append ".h" */
905 s = sym->name;
906 d = path;
907 while ((c = *s++)) {
908 c = tolower(c);
909 *d++ = (c == '_') ? '/' : c;
910 }
911 strcpy(d, ".h");
912
913 /* Assume directory path already exists. */
914 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
915 if (fd == -1) {
916 if (errno != ENOENT) {
917 res = 1;
918 break;
919 }
920 /*
921 * Create directory components,
922 * unless they exist already.
923 */
924 d = path;
925 while ((d = strchr(d, '/'))) {
926 *d = 0;
927 if (stat(path, &sb) && mkdir(path, 0755)) {
928 res = 1;
929 goto out;
930 }
931 *d++ = '/';
932 }
933 /* Try it again. */
934 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
935 if (fd == -1) {
936 res = 1;
937 break;
938 }
939 }
940 close(fd);
941 }
942 out:
943 if (chdir(opwd))
944 return 1;
945
946 return res;
947 }
948
conf_write_autoconf(void)949 int conf_write_autoconf(void)
950 {
951 struct symbol *sym;
952 const char *name;
953 char cfg_fname[PATH_MAX+1], tristate_fname[PATH_MAX+1],
954 cfgh_fname[PATH_MAX+1];
955 char *dirname;
956 FILE *out, *tristate, *out_h;
957 int i;
958
959 sym_clear_all_valid();
960
961 sprintf(cfg_fname, "%s.cmd", conf_get_autoconfig_name());
962 file_write_dep(cfg_fname);
963
964 if (conf_split_config())
965 return 1;
966
967 dirname = dir_name(strdup(conf_get_configname()));
968 sprintf(cfg_fname, "%s.tmpconfig", dirname);
969 sprintf(tristate_fname, "%s.tmpconfig_tristate", dirname);
970 sprintf(cfgh_fname, "%s.tmpconfig.h", dirname);
971 free(dirname);
972
973 out = fopen(cfg_fname, "w");
974 if (!out)
975 return 1;
976
977 tristate = fopen(tristate_fname, "w");
978 if (!tristate) {
979 fclose(out);
980 return 1;
981 }
982
983 out_h = fopen(cfgh_fname, "w");
984 if (!out_h) {
985 fclose(out);
986 fclose(tristate);
987 return 1;
988 }
989
990 conf_write_heading(out, &kconfig_printer_cb, NULL);
991
992 conf_write_heading(tristate, &tristate_printer_cb, NULL);
993
994 conf_write_heading(out_h, &header_printer_cb, NULL);
995
996 for_all_symbols(i, sym) {
997 sym_calc_value(sym);
998 if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
999 continue;
1000
1001 /* write symbol to auto.conf, tristate and header files */
1002 conf_write_symbol(out, sym, &kconfig_printer_cb, (void *)1);
1003
1004 conf_write_symbol(tristate, sym, &tristate_printer_cb, (void *)1);
1005
1006 conf_write_symbol(out_h, sym, &header_printer_cb, NULL);
1007 }
1008 fclose(out);
1009 fclose(tristate);
1010 fclose(out_h);
1011
1012 name = getenv("KCONFIG_AUTOHEADER");
1013 if (!name)
1014 name = "include/generated/autoconf.h";
1015 if (rename(cfgh_fname, name))
1016 return 1;
1017 name = getenv("KCONFIG_TRISTATE");
1018 if (!name)
1019 name = "include/config/tristate.conf";
1020 if (rename(tristate_fname, name))
1021 return 1;
1022 name = conf_get_autoconfig_name();
1023 /*
1024 * This must be the last step, kbuild has a dependency on auto.conf
1025 * and this marks the successful completion of the previous steps.
1026 */
1027 if (rename(cfg_fname, name))
1028 return 1;
1029
1030 return 0;
1031 }
1032
1033 static int sym_change_count;
1034 static void (*conf_changed_callback)(void);
1035
sym_set_change_count(int count)1036 void sym_set_change_count(int count)
1037 {
1038 int _sym_change_count = sym_change_count;
1039 sym_change_count = count;
1040 if (conf_changed_callback &&
1041 (bool)_sym_change_count != (bool)count)
1042 conf_changed_callback();
1043 }
1044
sym_add_change_count(int count)1045 void sym_add_change_count(int count)
1046 {
1047 sym_set_change_count(count + sym_change_count);
1048 }
1049
conf_get_changed(void)1050 bool conf_get_changed(void)
1051 {
1052 return sym_change_count;
1053 }
1054
conf_set_changed_callback(void (* fn)(void))1055 void conf_set_changed_callback(void (*fn)(void))
1056 {
1057 conf_changed_callback = fn;
1058 }
1059
randomize_choice_values(struct symbol * csym)1060 static bool randomize_choice_values(struct symbol *csym)
1061 {
1062 struct property *prop;
1063 struct symbol *sym;
1064 struct expr *e;
1065 int cnt, def;
1066
1067 /*
1068 * If choice is mod then we may have more items selected
1069 * and if no then no-one.
1070 * In both cases stop.
1071 */
1072 if (csym->curr.tri != yes)
1073 return false;
1074
1075 prop = sym_get_choice_prop(csym);
1076
1077 /* count entries in choice block */
1078 cnt = 0;
1079 expr_list_for_each_sym(prop->expr, e, sym)
1080 cnt++;
1081
1082 /*
1083 * find a random value and set it to yes,
1084 * set the rest to no so we have only one set
1085 */
1086 def = (rand() % cnt);
1087
1088 cnt = 0;
1089 expr_list_for_each_sym(prop->expr, e, sym) {
1090 if (def == cnt++) {
1091 sym->def[S_DEF_USER].tri = yes;
1092 csym->def[S_DEF_USER].val = sym;
1093 }
1094 else {
1095 sym->def[S_DEF_USER].tri = no;
1096 }
1097 sym->flags |= SYMBOL_DEF_USER;
1098 /* clear VALID to get value calculated */
1099 sym->flags &= ~SYMBOL_VALID;
1100 }
1101 csym->flags |= SYMBOL_DEF_USER;
1102 /* clear VALID to get value calculated */
1103 csym->flags &= ~(SYMBOL_VALID);
1104
1105 return true;
1106 }
1107
set_all_choice_values(struct symbol * csym)1108 void set_all_choice_values(struct symbol *csym)
1109 {
1110 struct property *prop;
1111 struct symbol *sym;
1112 struct expr *e;
1113
1114 prop = sym_get_choice_prop(csym);
1115
1116 /*
1117 * Set all non-assinged choice values to no
1118 */
1119 expr_list_for_each_sym(prop->expr, e, sym) {
1120 if (!sym_has_value(sym))
1121 sym->def[S_DEF_USER].tri = no;
1122 }
1123 csym->flags |= SYMBOL_DEF_USER;
1124 /* clear VALID to get value calculated */
1125 csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES);
1126 }
1127
conf_set_all_new_symbols(enum conf_def_mode mode)1128 bool conf_set_all_new_symbols(enum conf_def_mode mode)
1129 {
1130 struct symbol *sym, *csym;
1131 int i, cnt, pby, pty, ptm; /* pby: probability of boolean = y
1132 * pty: probability of tristate = y
1133 * ptm: probability of tristate = m
1134 */
1135
1136 pby = 50; pty = ptm = 33; /* can't go as the default in switch-case
1137 * below, otherwise gcc whines about
1138 * -Wmaybe-uninitialized */
1139 if (mode == def_random) {
1140 int n, p[3];
1141 char *env = getenv("KCONFIG_PROBABILITY");
1142 n = 0;
1143 while( env && *env ) {
1144 char *endp;
1145 int tmp = strtol( env, &endp, 10 );
1146 if( tmp >= 0 && tmp <= 100 ) {
1147 p[n++] = tmp;
1148 } else {
1149 errno = ERANGE;
1150 perror( "KCONFIG_PROBABILITY" );
1151 exit( 1 );
1152 }
1153 env = (*endp == ':') ? endp+1 : endp;
1154 if( n >=3 ) {
1155 break;
1156 }
1157 }
1158 switch( n ) {
1159 case 1:
1160 pby = p[0]; ptm = pby/2; pty = pby-ptm;
1161 break;
1162 case 2:
1163 pty = p[0]; ptm = p[1]; pby = pty + ptm;
1164 break;
1165 case 3:
1166 pby = p[0]; pty = p[1]; ptm = p[2];
1167 break;
1168 }
1169
1170 if( pty+ptm > 100 ) {
1171 errno = ERANGE;
1172 perror( "KCONFIG_PROBABILITY" );
1173 exit( 1 );
1174 }
1175 }
1176 bool has_changed = false;
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 sym->def[S_DEF_USER].tri = no;
1194 break;
1195 case def_random:
1196 sym->def[S_DEF_USER].tri = no;
1197 cnt = rand() % 100;
1198 if (sym->type == S_TRISTATE) {
1199 if (cnt < pty)
1200 sym->def[S_DEF_USER].tri = yes;
1201 else if (cnt < (pty+ptm))
1202 sym->def[S_DEF_USER].tri = mod;
1203 } else if (cnt < pby)
1204 sym->def[S_DEF_USER].tri = yes;
1205 break;
1206 default:
1207 continue;
1208 }
1209 if (!(sym_is_choice(sym) && mode == def_random))
1210 sym->flags |= SYMBOL_DEF_USER;
1211 break;
1212 default:
1213 break;
1214 }
1215
1216 }
1217
1218 sym_clear_all_valid();
1219
1220 /*
1221 * We have different type of choice blocks.
1222 * If curr.tri equals to mod then we can select several
1223 * choice symbols in one block.
1224 * In this case we do nothing.
1225 * If curr.tri equals yes then only one symbol can be
1226 * selected in a choice block and we set it to yes,
1227 * and the rest to no.
1228 */
1229 if (mode != def_random) {
1230 for_all_symbols(i, csym) {
1231 if ((sym_is_choice(csym) && !sym_has_value(csym)) ||
1232 sym_is_choice_value(csym))
1233 csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES;
1234 }
1235 }
1236
1237 for_all_symbols(i, csym) {
1238 if (sym_has_value(csym) || !sym_is_choice(csym))
1239 continue;
1240
1241 sym_calc_value(csym);
1242 if (mode == def_random)
1243 has_changed = randomize_choice_values(csym);
1244 else {
1245 set_all_choice_values(csym);
1246 has_changed = true;
1247 }
1248 }
1249
1250 return has_changed;
1251 }
1252