blob: 452c37595dada9b23558e955b7aa013aa26bfa5a [file] [log] [blame]
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001/*
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>
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -040010#include <stdarg.h>
Kevin O'Connora4c5daf2011-01-24 22:13:58 -050011#include <stdio.h>
12#include <stdlib.h>
13#include <string.h>
14#include <time.h>
15#include <unistd.h>
16
Kevin O'Connora4c5daf2011-01-24 22:13:58 -050017#include "lkc.h"
18
19static void conf_warning(const char *fmt, ...)
20 __attribute__ ((format (printf, 1, 2)));
21
22static void conf_message(const char *fmt, ...)
23 __attribute__ ((format (printf, 1, 2)));
24
25static const char *conf_filename;
26static int conf_lineno, conf_warnings, conf_unsaved;
27
28const char conf_defname[] = "arch/$ARCH/defconfig";
29
30static 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
41static 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
48static void (*conf_message_callback) (const char *fmt, va_list ap) =
49 conf_default_message_callback;
50void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))
51{
52 conf_message_callback = fn;
53}
54
55static 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
64const char *conf_get_configname(void)
65{
66 char *name = getenv("KCONFIG_CONFIG");
67
68 return name ? name : ".config";
69}
70
71const char *conf_get_autoconfig_name(void)
72{
73 char *name = getenv("KCONFIG_AUTOCONFIG");
74
75 return name ? name : "include/config/auto.conf";
76}
77
78static 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
104char *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
120static 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 }
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400131 /* fall through */
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500132 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);
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400144 return 1;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500145 case S_OTHER:
146 if (*p != '"') {
147 for (p2 = p; *p2 && !isspace(*p2); p2++)
148 ;
149 sym->type = S_STRING;
150 goto done;
151 }
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400152 /* fall through */
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500153 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 }
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400167 /* fall through */
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500168 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
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400185#define LINE_GROWTH 16
186static 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
206static 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
234e_out:
235 line[slen-1] = '\0';
236 *lineptr = line;
237 return -1;
238}
239
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500240int conf_read_simple(const char *name, int def)
241{
242 FILE *in = NULL;
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400243 char *line = NULL;
244 size_t line_asize = 0;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500245 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
281load:
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);
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400299 /* fall through */
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500300 default:
301 sym->def[def].val = NULL;
302 sym->def[def].tri = no;
303 }
304 }
305
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400306 while (compat_getline(&line, &line_asize, in) != -1) {
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500307 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 }
373setsym:
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 }
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400394 free(line);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500395 fclose(in);
396
397 if (modules_sym)
398 sym_calc_value(modules_sym);
399 return 0;
400}
401
402int conf_read(const char *name)
403{
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400404 struct symbol *sym;
405 int i;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500406
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))
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400415 continue;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500416 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))
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400424 continue;
425 /* fall through */
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500426 default:
427 if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400428 continue;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500429 break;
430 }
431 } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
432 /* no previous value and not saved */
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400433 continue;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500434 conf_unsaved++;
435 /* maybe print value in verbose mode... */
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500436 }
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
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400468/*
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 */
476static void
477kconfig_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg)
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500478{
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500479
480 switch (sym->type) {
481 case S_BOOLEAN:
482 case S_TRISTATE:
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400483 if (*value == 'n') {
484 bool skip_unset = (arg != NULL);
485
486 if (!skip_unset)
487 fprintf(fp, "# %s%s is not set\n",
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500488 CONFIG_, sym->name);
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400489 return;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500490 }
491 break;
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400492 default:
493 break;
494 }
495
496 fprintf(fp, "%s%s=%s\n", CONFIG_, sym->name, value);
497}
498
499static void
500kconfig_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
519static 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 */
530static void
531header_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 fprintf(fp, "#define %s%s%s 0\n",
542 CONFIG_, sym->name, suffix);
543 break;
544 case 'm':
545 suffix = "_MODULE";
546 /* fall through */
547 default:
548 fprintf(fp, "#define %s%s%s 1\n",
549 CONFIG_, sym->name, suffix);
550 }
551 break;
552 }
553 case S_HEX: {
554 const char *prefix = "";
555
556 if (value[0] != '0' || (value[1] != 'x' && value[1] != 'X'))
557 prefix = "0x";
558 if (!value[0])
559 prefix = "0";
560 fprintf(fp, "#define %s%s %s%s\n",
561 CONFIG_, sym->name, prefix, value);
562 break;
563 }
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500564 case S_STRING:
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500565 case S_INT:
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400566 fprintf(fp, "#define %s%s %s\n",
567 CONFIG_, sym->name, value);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500568 break;
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400569 default:
570 break;
571 }
572
573}
574
575static void
576header_print_comment(FILE *fp, const char *value, void *arg)
577{
578 const char *p = value;
579 size_t l;
580
581 fprintf(fp, "/*\n");
582 for (;;) {
583 l = strcspn(p, "\n");
584 fprintf(fp, " *");
585 if (l) {
586 fprintf(fp, " ");
587 xfwrite(p, l, 1, fp);
588 p += l;
589 }
590 fprintf(fp, "\n");
591 if (*p++ == '\0')
592 break;
593 }
594 fprintf(fp, " */\n");
595}
596
597static struct conf_printer header_printer_cb =
598{
599 .print_symbol = header_print_symbol,
600 .print_comment = header_print_comment,
601};
602
603/*
604 * Tristate printer
605 *
606 * This printer is used when generating the `include/config/tristate.conf' file.
607 */
608static void
609tristate_print_symbol(FILE *fp, struct symbol *sym, const char *value, void *arg)
610{
611
612 if (sym->type == S_TRISTATE && *value != 'n')
613 fprintf(fp, "%s%s=%c\n", CONFIG_, sym->name, (char)toupper(*value));
614}
615
616static struct conf_printer tristate_printer_cb =
617{
618 .print_symbol = tristate_print_symbol,
619 .print_comment = kconfig_print_comment,
620};
621
622static void conf_write_symbol(FILE *fp, struct symbol *sym,
623 struct conf_printer *printer, void *printer_arg)
624{
625 const char *str;
626
627 switch (sym->type) {
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500628 case S_OTHER:
629 case S_UNKNOWN:
630 break;
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400631 case S_STRING:
632 str = sym_get_string_value(sym);
633 str = sym_escape_string_value(str);
634 printer->print_symbol(fp, sym, str, printer_arg);
635 free((void *)str);
636 break;
637 default:
638 str = sym_get_string_value(sym);
639 printer->print_symbol(fp, sym, str, printer_arg);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500640 }
641}
642
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400643static void
644conf_write_heading(FILE *fp, struct conf_printer *printer, void *printer_arg)
645{
646 char buf[256];
647
648 snprintf(buf, sizeof(buf),
649 "\n"
650 "Automatically generated file; DO NOT EDIT.\n"
651 "%s\n",
652 rootmenu.prompt->text);
653
654 printer->print_comment(fp, buf, printer_arg);
655}
656
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500657/*
658 * Write out a minimal config.
659 * All values that has default values are skipped as this is redundant.
660 */
661int conf_write_defconfig(const char *filename)
662{
663 struct symbol *sym;
664 struct menu *menu;
665 FILE *out;
666
667 out = fopen(filename, "w");
668 if (!out)
669 return 1;
670
671 sym_clear_all_valid();
672
673 /* Traverse all menus to find all relevant symbols */
674 menu = rootmenu.list;
675
676 while (menu != NULL)
677 {
678 sym = menu->sym;
679 if (sym == NULL) {
680 if (!menu_is_visible(menu))
681 goto next_menu;
682 } else if (!sym_is_choice(sym)) {
683 sym_calc_value(sym);
684 if (!(sym->flags & SYMBOL_WRITE))
685 goto next_menu;
686 sym->flags &= ~SYMBOL_WRITE;
687 /* If we cannot change the symbol - skip */
688 if (!sym_is_changable(sym))
689 goto next_menu;
690 /* If symbol equals to default value - skip */
691 if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
692 goto next_menu;
693
694 /*
695 * If symbol is a choice value and equals to the
696 * default for a choice - skip.
697 * But only if value is bool and equal to "y" and
698 * choice is not "optional".
699 * (If choice is "optional" then all values can be "n")
700 */
701 if (sym_is_choice_value(sym)) {
702 struct symbol *cs;
703 struct symbol *ds;
704
705 cs = prop_get_symbol(sym_get_choice_prop(sym));
706 ds = sym_choice_default(cs);
707 if (!sym_is_optional(cs) && sym == ds) {
708 if ((sym->type == S_BOOLEAN) &&
709 sym_get_tristate_value(sym) == yes)
710 goto next_menu;
711 }
712 }
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400713 conf_write_symbol(out, sym, &kconfig_printer_cb, NULL);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500714 }
715next_menu:
716 if (menu->list != NULL) {
717 menu = menu->list;
718 }
719 else if (menu->next != NULL) {
720 menu = menu->next;
721 } else {
722 while ((menu = menu->parent)) {
723 if (menu->next != NULL) {
724 menu = menu->next;
725 break;
726 }
727 }
728 }
729 }
730 fclose(out);
731 return 0;
732}
733
734int conf_write(const char *name)
735{
736 FILE *out;
737 struct symbol *sym;
738 struct menu *menu;
739 const char *basename;
740 const char *str;
741 char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500742 char *env;
743
744 dirname[0] = 0;
745 if (name && name[0]) {
746 struct stat st;
747 char *slash;
748
749 if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
750 strcpy(dirname, name);
751 strcat(dirname, "/");
752 basename = conf_get_configname();
753 } else if ((slash = strrchr(name, '/'))) {
754 int size = slash - name + 1;
755 memcpy(dirname, name, size);
756 dirname[size] = 0;
757 if (slash[1])
758 basename = slash + 1;
759 else
760 basename = conf_get_configname();
761 } else
762 basename = name;
763 } else
764 basename = conf_get_configname();
765
766 sprintf(newname, "%s%s", dirname, basename);
767 env = getenv("KCONFIG_OVERWRITECONFIG");
768 if (!env || !*env) {
769 sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
770 out = fopen(tmpname, "w");
771 } else {
772 *tmpname = 0;
773 out = fopen(newname, "w");
774 }
775 if (!out)
776 return 1;
777
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400778 conf_write_heading(out, &kconfig_printer_cb, NULL);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500779
780 if (!conf_get_changed())
781 sym_clear_all_valid();
782
783 menu = rootmenu.list;
784 while (menu) {
785 sym = menu->sym;
786 if (!sym) {
787 if (!menu_is_visible(menu))
788 goto next;
789 str = menu_get_prompt(menu);
790 fprintf(out, "\n"
791 "#\n"
792 "# %s\n"
793 "#\n", str);
794 } else if (!(sym->flags & SYMBOL_CHOICE)) {
795 sym_calc_value(sym);
796 if (!(sym->flags & SYMBOL_WRITE))
797 goto next;
798 sym->flags &= ~SYMBOL_WRITE;
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400799
800 conf_write_symbol(out, sym, &kconfig_printer_cb, NULL);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500801 }
802
803next:
804 if (menu->list) {
805 menu = menu->list;
806 continue;
807 }
808 if (menu->next)
809 menu = menu->next;
810 else while ((menu = menu->parent)) {
811 if (menu->next) {
812 menu = menu->next;
813 break;
814 }
815 }
816 }
817 fclose(out);
818
819 if (*tmpname) {
820 strcat(dirname, basename);
821 strcat(dirname, ".old");
822 rename(newname, dirname);
823 if (rename(tmpname, newname))
824 return 1;
825 }
826
827 conf_message(_("configuration written to %s"), newname);
828
829 sym_set_change_count(0);
830
831 return 0;
832}
833
834static int conf_split_config(void)
835{
836 const char *name;
837 char path[PATH_MAX+1];
838 char *s, *d, c;
839 struct symbol *sym;
840 struct stat sb;
841 int res, i, fd;
842
843 name = conf_get_autoconfig_name();
844 conf_read_simple(name, S_DEF_AUTO);
845
846 if (chdir("include/config"))
847 return 1;
848
849 res = 0;
850 for_all_symbols(i, sym) {
851 sym_calc_value(sym);
852 if ((sym->flags & SYMBOL_AUTO) || !sym->name)
853 continue;
854 if (sym->flags & SYMBOL_WRITE) {
855 if (sym->flags & SYMBOL_DEF_AUTO) {
856 /*
857 * symbol has old and new value,
858 * so compare them...
859 */
860 switch (sym->type) {
861 case S_BOOLEAN:
862 case S_TRISTATE:
863 if (sym_get_tristate_value(sym) ==
864 sym->def[S_DEF_AUTO].tri)
865 continue;
866 break;
867 case S_STRING:
868 case S_HEX:
869 case S_INT:
870 if (!strcmp(sym_get_string_value(sym),
871 sym->def[S_DEF_AUTO].val))
872 continue;
873 break;
874 default:
875 break;
876 }
877 } else {
878 /*
879 * If there is no old value, only 'no' (unset)
880 * is allowed as new value.
881 */
882 switch (sym->type) {
883 case S_BOOLEAN:
884 case S_TRISTATE:
885 if (sym_get_tristate_value(sym) == no)
886 continue;
887 break;
888 default:
889 break;
890 }
891 }
892 } else if (!(sym->flags & SYMBOL_DEF_AUTO))
893 /* There is neither an old nor a new value. */
894 continue;
895 /* else
896 * There is an old value, but no new value ('no' (unset)
897 * isn't saved in auto.conf, so the old value is always
898 * different from 'no').
899 */
900
901 /* Replace all '_' and append ".h" */
902 s = sym->name;
903 d = path;
904 while ((c = *s++)) {
905 c = tolower(c);
906 *d++ = (c == '_') ? '/' : c;
907 }
908 strcpy(d, ".h");
909
910 /* Assume directory path already exists. */
911 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
912 if (fd == -1) {
913 if (errno != ENOENT) {
914 res = 1;
915 break;
916 }
917 /*
918 * Create directory components,
919 * unless they exist already.
920 */
921 d = path;
922 while ((d = strchr(d, '/'))) {
923 *d = 0;
924 if (stat(path, &sb) && mkdir(path, 0755)) {
925 res = 1;
926 goto out;
927 }
928 *d++ = '/';
929 }
930 /* Try it again. */
931 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
932 if (fd == -1) {
933 res = 1;
934 break;
935 }
936 }
937 close(fd);
938 }
939out:
940 if (chdir("../.."))
941 return 1;
942
943 return res;
944}
945
946int conf_write_autoconf(void)
947{
948 struct symbol *sym;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500949 const char *name;
950 FILE *out, *tristate, *out_h;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500951 int i;
952
953 sym_clear_all_valid();
954
955 file_write_dep("include/config/auto.conf.cmd");
956
957 if (conf_split_config())
958 return 1;
959
960 out = fopen(".tmpconfig", "w");
961 if (!out)
962 return 1;
963
964 tristate = fopen(".tmpconfig_tristate", "w");
965 if (!tristate) {
966 fclose(out);
967 return 1;
968 }
969
970 out_h = fopen(".tmpconfig.h", "w");
971 if (!out_h) {
972 fclose(out);
973 fclose(tristate);
974 return 1;
975 }
976
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400977 conf_write_heading(out, &kconfig_printer_cb, NULL);
978
979 conf_write_heading(tristate, &tristate_printer_cb, NULL);
980
981 conf_write_heading(out_h, &header_printer_cb, NULL);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500982
983 for_all_symbols(i, sym) {
984 sym_calc_value(sym);
Kevin O'Connorb623e7c2011-01-26 20:09:39 -0500985 if (!sym->name)
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500986 continue;
Kevin O'Connorb623e7c2011-01-26 20:09:39 -0500987 if (!(sym->flags & SYMBOL_WRITE)) {
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400988 conf_write_symbol(out_h, sym, &header_printer_cb, NULL);
Kevin O'Connorb623e7c2011-01-26 20:09:39 -0500989 continue;
990 }
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500991
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400992 /* write symbol to auto.conf, tristate and header files */
993 conf_write_symbol(out, sym, &kconfig_printer_cb, (void *)1);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500994
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -0400995 conf_write_symbol(tristate, sym, &tristate_printer_cb, (void *)1);
996
997 conf_write_symbol(out_h, sym, &header_printer_cb, NULL);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -0500998 }
999 fclose(out);
1000 fclose(tristate);
1001 fclose(out_h);
1002
1003 name = getenv("KCONFIG_AUTOHEADER");
1004 if (!name)
1005 name = "include/generated/autoconf.h";
1006 if (rename(".tmpconfig.h", name))
1007 return 1;
1008 name = getenv("KCONFIG_TRISTATE");
1009 if (!name)
1010 name = "include/config/tristate.conf";
1011 if (rename(".tmpconfig_tristate", name))
1012 return 1;
1013 name = conf_get_autoconfig_name();
1014 /*
1015 * This must be the last step, kbuild has a dependency on auto.conf
1016 * and this marks the successful completion of the previous steps.
1017 */
1018 if (rename(".tmpconfig", name))
1019 return 1;
1020
1021 return 0;
1022}
1023
1024static int sym_change_count;
1025static void (*conf_changed_callback)(void);
1026
1027void sym_set_change_count(int count)
1028{
1029 int _sym_change_count = sym_change_count;
1030 sym_change_count = count;
1031 if (conf_changed_callback &&
1032 (bool)_sym_change_count != (bool)count)
1033 conf_changed_callback();
1034}
1035
1036void sym_add_change_count(int count)
1037{
1038 sym_set_change_count(count + sym_change_count);
1039}
1040
1041bool conf_get_changed(void)
1042{
1043 return sym_change_count;
1044}
1045
1046void conf_set_changed_callback(void (*fn)(void))
1047{
1048 conf_changed_callback = fn;
1049}
1050
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001051static bool randomize_choice_values(struct symbol *csym)
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001052{
1053 struct property *prop;
1054 struct symbol *sym;
1055 struct expr *e;
1056 int cnt, def;
1057
1058 /*
1059 * If choice is mod then we may have more items selected
1060 * and if no then no-one.
1061 * In both cases stop.
1062 */
1063 if (csym->curr.tri != yes)
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001064 return false;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001065
1066 prop = sym_get_choice_prop(csym);
1067
1068 /* count entries in choice block */
1069 cnt = 0;
1070 expr_list_for_each_sym(prop->expr, e, sym)
1071 cnt++;
1072
1073 /*
1074 * find a random value and set it to yes,
1075 * set the rest to no so we have only one set
1076 */
1077 def = (rand() % cnt);
1078
1079 cnt = 0;
1080 expr_list_for_each_sym(prop->expr, e, sym) {
1081 if (def == cnt++) {
1082 sym->def[S_DEF_USER].tri = yes;
1083 csym->def[S_DEF_USER].val = sym;
1084 }
1085 else {
1086 sym->def[S_DEF_USER].tri = no;
1087 }
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001088 sym->flags |= SYMBOL_DEF_USER;
1089 /* clear VALID to get value calculated */
1090 sym->flags &= ~SYMBOL_VALID;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001091 }
1092 csym->flags |= SYMBOL_DEF_USER;
1093 /* clear VALID to get value calculated */
1094 csym->flags &= ~(SYMBOL_VALID);
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001095
1096 return true;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001097}
1098
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001099void set_all_choice_values(struct symbol *csym)
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001100{
1101 struct property *prop;
1102 struct symbol *sym;
1103 struct expr *e;
1104
1105 prop = sym_get_choice_prop(csym);
1106
1107 /*
1108 * Set all non-assinged choice values to no
1109 */
1110 expr_list_for_each_sym(prop->expr, e, sym) {
1111 if (!sym_has_value(sym))
1112 sym->def[S_DEF_USER].tri = no;
1113 }
1114 csym->flags |= SYMBOL_DEF_USER;
1115 /* clear VALID to get value calculated */
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001116 csym->flags &= ~(SYMBOL_VALID | SYMBOL_NEED_SET_CHOICE_VALUES);
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001117}
1118
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001119bool conf_set_all_new_symbols(enum conf_def_mode mode)
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001120{
1121 struct symbol *sym, *csym;
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001122 int i, cnt, pby, pty, ptm; /* pby: probability of boolean = y
1123 * pty: probability of tristate = y
1124 * ptm: probability of tristate = m
1125 */
1126
1127 pby = 50; pty = ptm = 33; /* can't go as the default in switch-case
1128 * below, otherwise gcc whines about
1129 * -Wmaybe-uninitialized */
1130 if (mode == def_random) {
1131 int n, p[3];
1132 char *env = getenv("KCONFIG_PROBABILITY");
1133 n = 0;
1134 while( env && *env ) {
1135 char *endp;
1136 int tmp = strtol( env, &endp, 10 );
1137 if( tmp >= 0 && tmp <= 100 ) {
1138 p[n++] = tmp;
1139 } else {
1140 errno = ERANGE;
1141 perror( "KCONFIG_PROBABILITY" );
1142 exit( 1 );
1143 }
1144 env = (*endp == ':') ? endp+1 : endp;
1145 if( n >=3 ) {
1146 break;
1147 }
1148 }
1149 switch( n ) {
1150 case 1:
1151 pby = p[0]; ptm = pby/2; pty = pby-ptm;
1152 break;
1153 case 2:
1154 pty = p[0]; ptm = p[1]; pby = pty + ptm;
1155 break;
1156 case 3:
1157 pby = p[0]; pty = p[1]; ptm = p[2];
1158 break;
1159 }
1160
1161 if( pty+ptm > 100 ) {
1162 errno = ERANGE;
1163 perror( "KCONFIG_PROBABILITY" );
1164 exit( 1 );
1165 }
1166 }
1167 bool has_changed = false;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001168
1169 for_all_symbols(i, sym) {
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001170 if (sym_has_value(sym) || (sym->flags & SYMBOL_VALID))
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001171 continue;
1172 switch (sym_get_type(sym)) {
1173 case S_BOOLEAN:
1174 case S_TRISTATE:
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001175 has_changed = true;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001176 switch (mode) {
1177 case def_yes:
1178 sym->def[S_DEF_USER].tri = yes;
1179 break;
1180 case def_mod:
1181 sym->def[S_DEF_USER].tri = mod;
1182 break;
1183 case def_no:
1184 sym->def[S_DEF_USER].tri = no;
1185 break;
1186 case def_random:
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001187 sym->def[S_DEF_USER].tri = no;
1188 cnt = rand() % 100;
1189 if (sym->type == S_TRISTATE) {
1190 if (cnt < pty)
1191 sym->def[S_DEF_USER].tri = yes;
1192 else if (cnt < (pty+ptm))
1193 sym->def[S_DEF_USER].tri = mod;
1194 } else if (cnt < pby)
1195 sym->def[S_DEF_USER].tri = yes;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001196 break;
1197 default:
1198 continue;
1199 }
1200 if (!(sym_is_choice(sym) && mode == def_random))
1201 sym->flags |= SYMBOL_DEF_USER;
1202 break;
1203 default:
1204 break;
1205 }
1206
1207 }
1208
1209 sym_clear_all_valid();
1210
1211 /*
1212 * We have different type of choice blocks.
1213 * If curr.tri equals to mod then we can select several
1214 * choice symbols in one block.
1215 * In this case we do nothing.
1216 * If curr.tri equals yes then only one symbol can be
1217 * selected in a choice block and we set it to yes,
1218 * and the rest to no.
1219 */
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001220 if (mode != def_random) {
1221 for_all_symbols(i, csym) {
1222 if ((sym_is_choice(csym) && !sym_has_value(csym)) ||
1223 sym_is_choice_value(csym))
1224 csym->flags |= SYMBOL_NEED_SET_CHOICE_VALUES;
1225 }
1226 }
1227
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001228 for_all_symbols(i, csym) {
1229 if (sym_has_value(csym) || !sym_is_choice(csym))
1230 continue;
1231
1232 sym_calc_value(csym);
1233 if (mode == def_random)
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001234 has_changed = randomize_choice_values(csym);
1235 else {
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001236 set_all_choice_values(csym);
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001237 has_changed = true;
1238 }
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001239 }
Kevin O'Connor09c1ebb2013-08-24 13:43:09 -04001240
1241 return has_changed;
Kevin O'Connora4c5daf2011-01-24 22:13:58 -05001242}