2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
19 static void conf_warning(const char *fmt
, ...)
20 __attribute__ ((format (printf
, 1, 2)));
22 static void conf_message(const char *fmt
, ...)
23 __attribute__ ((format (printf
, 1, 2)));
25 static const char *conf_filename
;
26 static int conf_lineno
, conf_warnings
, conf_unsaved
;
28 const char conf_defname
[] = "arch/$ARCH/defconfig";
30 static void conf_warning(const char *fmt
, ...)
34 fprintf(stderr
, "%s:%d:warning: ", conf_filename
, conf_lineno
);
35 vfprintf(stderr
, fmt
, ap
);
36 fprintf(stderr
, "\n");
41 static void conf_default_message_callback(const char *fmt
, va_list ap
)
48 static void (*conf_message_callback
) (const char *fmt
, va_list ap
) =
49 conf_default_message_callback
;
50 void conf_set_message_callback(void (*fn
) (const char *fmt
, va_list ap
))
52 conf_message_callback
= fn
;
55 static void conf_message(const char *fmt
, ...)
60 if (conf_message_callback
)
61 conf_message_callback(fmt
, ap
);
64 const char *conf_get_configname(void)
66 char *name
= getenv("KCONFIG_CONFIG");
68 return name
? name
: ".config";
71 const char *conf_get_autoconfig_name(void)
73 char *name
= getenv("KCONFIG_AUTOCONFIG");
75 return name
? name
: "include/config/auto.conf";
78 static char *conf_expand_value(const char *in
)
82 static char res_value
[SYMBOL_MAXLENGTH
];
83 char *dst
, name
[SYMBOL_MAXLENGTH
];
87 while ((src
= strchr(in
, '$'))) {
88 strncat(res_value
, in
, src
- in
);
91 while (isalnum(*src
) || *src
== '_')
94 sym
= sym_lookup(name
, 0);
96 strcat(res_value
, sym_get_string_value(sym
));
99 strcat(res_value
, in
);
104 char *conf_get_default_confname(void)
107 static char fullname
[PATH_MAX
+1];
110 name
= conf_expand_value(conf_defname
);
111 env
= getenv(SRCTREE
);
113 sprintf(fullname
, "%s/%s", env
, name
);
114 if (!stat(fullname
, &buf
))
120 static int conf_set_sym_val(struct symbol
*sym
, int def
, int def_flags
, char *p
)
127 sym
->def
[def
].tri
= mod
;
128 sym
->flags
|= def_flags
;
134 sym
->def
[def
].tri
= yes
;
135 sym
->flags
|= def_flags
;
139 sym
->def
[def
].tri
= no
;
140 sym
->flags
|= def_flags
;
143 conf_warning("symbol value '%s' invalid for %s", p
, sym
->name
);
147 for (p2
= p
; *p2
&& !isspace(*p2
); p2
++)
149 sym
->type
= S_STRING
;
156 for (p2
= p
; (p2
= strpbrk(p2
, "\"\\")); p2
++) {
161 memmove(p2
, p2
+ 1, strlen(p2
));
164 conf_warning("invalid string found");
171 if (sym_string_valid(sym
, p
)) {
172 sym
->def
[def
].val
= strdup(p
);
173 sym
->flags
|= def_flags
;
175 conf_warning("symbol value '%s' invalid for %s", p
, sym
->name
);
185 #define LINE_GROWTH 16
186 static int add_byte(int c
, char **lineptr
, size_t slen
, size_t *n
)
189 size_t new_size
= slen
+ 1;
191 new_size
+= LINE_GROWTH
- 1;
193 nline
= realloc(*lineptr
, new_size
);
201 (*lineptr
)[slen
] = c
;
206 static ssize_t
compat_getline(char **lineptr
, size_t *n
, FILE *stream
)
208 char *line
= *lineptr
;
212 int c
= getc(stream
);
216 if (add_byte(c
, &line
, slen
, n
) < 0)
221 if (add_byte('\0', &line
, slen
, n
) < 0)
228 if (add_byte(c
, &line
, slen
, n
) < 0)
240 void conf_reset(int def
)
245 def_flags
= SYMBOL_DEF
<< def
;
246 for_all_symbols(i
, sym
) {
247 sym
->flags
|= SYMBOL_CHANGED
;
248 sym
->flags
&= ~(def_flags
|SYMBOL_VALID
);
249 if (sym_is_choice(sym
))
250 sym
->flags
|= def_flags
;
255 if (sym
->def
[def
].val
)
256 free(sym
->def
[def
].val
);
259 sym
->def
[def
].val
= NULL
;
260 sym
->def
[def
].tri
= no
;
265 int conf_read_simple(const char *name
, int def
)
269 size_t line_asize
= 0;
275 in
= zconf_fopen(name
);
277 struct property
*prop
;
279 name
= conf_get_configname();
280 in
= zconf_fopen(name
);
283 sym_add_change_count(1);
284 if (!sym_defconfig_list
) {
286 sym_calc_value(modules_sym
);
290 for_all_defaults(sym_defconfig_list
, prop
) {
291 if (expr_calc_value(prop
->visible
.expr
) == no
||
292 prop
->expr
->type
!= E_SYMBOL
)
294 name
= conf_expand_value(prop
->expr
->left
.sym
->name
);
295 in
= zconf_fopen(name
);
297 conf_message(_("using defaults found in %s"),
307 conf_filename
= name
;
312 def_flags
= SYMBOL_DEF
<< def
;
315 while (compat_getline(&line
, &line_asize
, in
) != -1) {
318 if (line
[0] == '#') {
319 if (memcmp(line
+ 2, CONFIG_
, strlen(CONFIG_
)))
321 p
= strchr(line
+ 2 + strlen(CONFIG_
), ' ');
325 if (strncmp(p
, "is not set", 10))
327 if (def
== S_DEF_USER
) {
328 sym
= sym_find(line
+ 2 + strlen(CONFIG_
));
330 sym_add_change_count(1);
334 sym
= sym_lookup(line
+ 2 + strlen(CONFIG_
), 0);
335 if (sym
->type
== S_UNKNOWN
)
336 sym
->type
= S_BOOLEAN
;
341 sym
->def
[def
].tri
= no
;
342 sym
->flags
|= def_flags
;
347 } else if (memcmp(line
, CONFIG_
, strlen(CONFIG_
)) == 0) {
348 p
= strchr(line
+ strlen(CONFIG_
), '=');
352 p2
= strchr(p
, '\n');
358 if (def
== S_DEF_USER
) {
359 sym
= sym_find(line
+ strlen(CONFIG_
));
361 sym_add_change_count(1);
365 sym
= sym_lookup(line
+ strlen(CONFIG_
), 0);
366 if (sym
->type
== S_UNKNOWN
)
369 if (conf_set_sym_val(sym
, def
, def_flags
, p
))
372 if (line
[0] != '\r' && line
[0] != '\n')
373 conf_warning("unexpected data");
377 if (sym
&& sym_is_choice_value(sym
)) {
378 struct symbol
*cs
= prop_get_symbol(sym_get_choice_prop(sym
));
379 switch (sym
->def
[def
].tri
) {
383 if (cs
->def
[def
].tri
== yes
) {
384 conf_warning("%s creates inconsistent choice state", sym
->name
);
385 cs
->flags
&= ~def_flags
;
389 if (cs
->def
[def
].tri
!= no
)
390 conf_warning("override: %s changes choice state", sym
->name
);
391 cs
->def
[def
].val
= sym
;
394 cs
->def
[def
].tri
= EXPR_OR(cs
->def
[def
].tri
, sym
->def
[def
].tri
);
401 sym_calc_value(modules_sym
);
405 int conf_read(const char *name
)
410 sym_set_change_count(0);
412 if (conf_read_simple(name
, S_DEF_USER
))
415 for_all_symbols(i
, sym
) {
417 if (sym_is_choice(sym
) || (sym
->flags
& SYMBOL_AUTO
))
419 if (sym_has_value(sym
) && (sym
->flags
& SYMBOL_WRITE
)) {
420 /* check that calculated value agrees with saved value */
424 if (sym
->def
[S_DEF_USER
].tri
!= sym_get_tristate_value(sym
))
426 if (!sym_is_choice(sym
))
430 if (!strcmp(sym
->curr
.val
, sym
->def
[S_DEF_USER
].val
))
434 } else if (!sym_has_value(sym
) && !(sym
->flags
& SYMBOL_WRITE
))
435 /* no previous value and not saved */
438 /* maybe print value in verbose mode... */
441 for_all_symbols(i
, sym
) {
442 if (sym_has_value(sym
) && !sym_is_choice_value(sym
)) {
443 /* Reset values of generates values, so they'll appear
444 * as new, if they should become visible, but that
445 * doesn't quite work if the Kconfig and the saved
446 * configuration disagree.
448 if (sym
->visible
== no
&& !conf_unsaved
)
449 sym
->flags
&= ~SYMBOL_DEF_USER
;
454 /* Reset a string value if it's out of range */
455 if (sym_string_within_range(sym
, sym
->def
[S_DEF_USER
].val
))
457 sym
->flags
&= ~(SYMBOL_VALID
|SYMBOL_DEF_USER
);
466 sym_add_change_count(conf_warnings
|| conf_unsaved
);
472 * Kconfig configuration printer
474 * This printer is used when generating the resulting configuration after
475 * kconfig invocation and `defconfig' files. Unset symbol might be omitted by
476 * passing a non-NULL argument to the printer.
480 kconfig_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
487 bool skip_unset
= (arg
!= NULL
);
490 fprintf(fp
, "# %s%s is not set\n",
499 fprintf(fp
, "%s%s=%s\n", CONFIG_
, sym
->name
, value
);
503 kconfig_print_comment(FILE *fp
, const char *value
, void *arg
)
505 const char *p
= value
;
509 l
= strcspn(p
, "\n");
513 xfwrite(p
, l
, 1, fp
);
522 static struct conf_printer kconfig_printer_cb
=
524 .print_symbol
= kconfig_print_symbol
,
525 .print_comment
= kconfig_print_comment
,
531 * This printer is used when generating the `include/generated/autoconf.h' file.
534 header_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
540 const char *suffix
= "";
549 fprintf(fp
, "#define %s%s%s 1\n",
550 CONFIG_
, sym
->name
, suffix
);
555 const char *prefix
= "";
557 if (value
[0] != '0' || (value
[1] != 'x' && value
[1] != 'X'))
559 fprintf(fp
, "#define %s%s %s%s\n",
560 CONFIG_
, sym
->name
, prefix
, value
);
565 fprintf(fp
, "#define %s%s %s\n",
566 CONFIG_
, sym
->name
, value
);
575 header_print_comment(FILE *fp
, const char *value
, void *arg
)
577 const char *p
= value
;
582 l
= strcspn(p
, "\n");
586 xfwrite(p
, l
, 1, fp
);
593 fprintf(fp
, " */\n");
596 static struct conf_printer header_printer_cb
=
598 .print_symbol
= header_print_symbol
,
599 .print_comment
= header_print_comment
,
605 * This printer is used when generating the `include/config/tristate.conf' file.
608 tristate_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
611 if (sym
->type
== S_TRISTATE
&& *value
!= 'n')
612 fprintf(fp
, "%s%s=%c\n", CONFIG_
, sym
->name
, (char)toupper(*value
));
615 static struct conf_printer tristate_printer_cb
=
617 .print_symbol
= tristate_print_symbol
,
618 .print_comment
= kconfig_print_comment
,
621 static void conf_write_symbol(FILE *fp
, struct symbol
*sym
,
622 struct conf_printer
*printer
, void *printer_arg
)
631 str
= sym_get_string_value(sym
);
632 str
= sym_escape_string_value(str
);
633 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
637 str
= sym_get_string_value(sym
);
638 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
643 conf_write_heading(FILE *fp
, struct conf_printer
*printer
, void *printer_arg
)
647 snprintf(buf
, sizeof(buf
),
649 "Automatically generated file; DO NOT EDIT.\n"
651 rootmenu
.prompt
->text
);
653 printer
->print_comment(fp
, buf
, printer_arg
);
657 * Write out a minimal config.
658 * All values that has default values are skipped as this is redundant.
660 int conf_write_defconfig(const char *filename
)
666 out
= fopen(filename
, "w");
670 sym_clear_all_valid();
672 /* Traverse all menus to find all relevant symbols */
673 menu
= rootmenu
.list
;
679 if (!menu_is_visible(menu
))
681 } else if (!sym_is_choice(sym
)) {
683 if (!(sym
->flags
& SYMBOL_WRITE
))
685 sym
->flags
&= ~SYMBOL_WRITE
;
686 /* If we cannot change the symbol - skip */
687 if (!sym_is_changable(sym
))
689 /* If symbol equals to default value - skip */
690 if (strcmp(sym_get_string_value(sym
), sym_get_string_default(sym
)) == 0)
694 * If symbol is a choice value and equals to the
695 * default for a choice - skip.
696 * But only if value is bool and equal to "y" and
697 * choice is not "optional".
698 * (If choice is "optional" then all values can be "n")
700 if (sym_is_choice_value(sym
)) {
704 cs
= prop_get_symbol(sym_get_choice_prop(sym
));
705 ds
= sym_choice_default(cs
);
706 if (!sym_is_optional(cs
) && sym
== ds
) {
707 if ((sym
->type
== S_BOOLEAN
) &&
708 sym_get_tristate_value(sym
) == yes
)
712 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
715 if (menu
->list
!= NULL
) {
718 else if (menu
->next
!= NULL
) {
721 while ((menu
= menu
->parent
)) {
722 if (menu
->next
!= NULL
) {
733 int conf_write(const char *name
)
738 const char *basename
;
740 char dirname
[PATH_MAX
+1], tmpname
[PATH_MAX
+1], newname
[PATH_MAX
+1];
744 if (name
&& name
[0]) {
748 if (!stat(name
, &st
) && S_ISDIR(st
.st_mode
)) {
749 strcpy(dirname
, name
);
750 strcat(dirname
, "/");
751 basename
= conf_get_configname();
752 } else if ((slash
= strrchr(name
, '/'))) {
753 int size
= slash
- name
+ 1;
754 memcpy(dirname
, name
, size
);
757 basename
= slash
+ 1;
759 basename
= conf_get_configname();
763 basename
= conf_get_configname();
765 sprintf(newname
, "%s%s", dirname
, basename
);
766 env
= getenv("KCONFIG_OVERWRITECONFIG");
768 sprintf(tmpname
, "%s.tmpconfig.%d", dirname
, (int)getpid());
769 out
= fopen(tmpname
, "w");
772 out
= fopen(newname
, "w");
777 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
779 if (!conf_get_changed())
780 sym_clear_all_valid();
782 menu
= rootmenu
.list
;
786 if (!menu_is_visible(menu
))
788 str
= menu_get_prompt(menu
);
793 } else if (!(sym
->flags
& SYMBOL_CHOICE
)) {
795 if (!(sym
->flags
& SYMBOL_WRITE
))
797 sym
->flags
&= ~SYMBOL_WRITE
;
799 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
809 else while ((menu
= menu
->parent
)) {
819 strcat(dirname
, basename
);
820 strcat(dirname
, ".old");
821 rename(newname
, dirname
);
822 if (rename(tmpname
, newname
))
826 conf_message(_("configuration written to %s"), newname
);
828 sym_set_change_count(0);
833 static int conf_split_config(void)
836 char path
[PATH_MAX
+1];
842 name
= conf_get_autoconfig_name();
843 conf_read_simple(name
, S_DEF_AUTO
);
845 if (chdir("include/config"))
849 for_all_symbols(i
, sym
) {
851 if ((sym
->flags
& SYMBOL_AUTO
) || !sym
->name
)
853 if (sym
->flags
& SYMBOL_WRITE
) {
854 if (sym
->flags
& SYMBOL_DEF_AUTO
) {
856 * symbol has old and new value,
862 if (sym_get_tristate_value(sym
) ==
863 sym
->def
[S_DEF_AUTO
].tri
)
869 if (!strcmp(sym_get_string_value(sym
),
870 sym
->def
[S_DEF_AUTO
].val
))
878 * If there is no old value, only 'no' (unset)
879 * is allowed as new value.
884 if (sym_get_tristate_value(sym
) == no
)
891 } else if (!(sym
->flags
& SYMBOL_DEF_AUTO
))
892 /* There is neither an old nor a new value. */
895 * There is an old value, but no new value ('no' (unset)
896 * isn't saved in auto.conf, so the old value is always
897 * different from 'no').
900 /* Replace all '_' and append ".h" */
905 *d
++ = (c
== '_') ? '/' : c
;
909 /* Assume directory path already exists. */
910 fd
= open(path
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0644);
912 if (errno
!= ENOENT
) {
917 * Create directory components,
918 * unless they exist already.
921 while ((d
= strchr(d
, '/'))) {
923 if (stat(path
, &sb
) && mkdir(path
, 0755)) {
930 fd
= open(path
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0644);
945 int conf_write_autoconf(void)
949 FILE *out
, *tristate
, *out_h
;
952 sym_clear_all_valid();
954 file_write_dep("include/config/auto.conf.cmd");
956 if (conf_split_config())
959 out
= fopen(".tmpconfig", "w");
963 tristate
= fopen(".tmpconfig_tristate", "w");
969 out_h
= fopen(".tmpconfig.h", "w");
976 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
978 conf_write_heading(tristate
, &tristate_printer_cb
, NULL
);
980 conf_write_heading(out_h
, &header_printer_cb
, NULL
);
982 for_all_symbols(i
, sym
) {
984 if (!(sym
->flags
& SYMBOL_WRITE
) || !sym
->name
)
987 /* write symbol to auto.conf, tristate and header files */
988 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, (void *)1);
990 conf_write_symbol(tristate
, sym
, &tristate_printer_cb
, (void *)1);
992 conf_write_symbol(out_h
, sym
, &header_printer_cb
, NULL
);
998 name
= getenv("KCONFIG_AUTOHEADER");
1000 name
= "include/generated/autoconf.h";
1001 if (rename(".tmpconfig.h", name
))
1003 name
= getenv("KCONFIG_TRISTATE");
1005 name
= "include/config/tristate.conf";
1006 if (rename(".tmpconfig_tristate", name
))
1008 name
= conf_get_autoconfig_name();
1010 * This must be the last step, kbuild has a dependency on auto.conf
1011 * and this marks the successful completion of the previous steps.
1013 if (rename(".tmpconfig", name
))
1019 static int sym_change_count
;
1020 static void (*conf_changed_callback
)(void);
1022 void sym_set_change_count(int count
)
1024 int _sym_change_count
= sym_change_count
;
1025 sym_change_count
= count
;
1026 if (conf_changed_callback
&&
1027 (bool)_sym_change_count
!= (bool)count
)
1028 conf_changed_callback();
1031 void sym_add_change_count(int count
)
1033 sym_set_change_count(count
+ sym_change_count
);
1036 bool conf_get_changed(void)
1038 return sym_change_count
;
1041 void conf_set_changed_callback(void (*fn
)(void))
1043 conf_changed_callback
= fn
;
1046 static void randomize_choice_values(struct symbol
*csym
)
1048 struct property
*prop
;
1054 * If choice is mod then we may have more items selected
1055 * and if no then no-one.
1056 * In both cases stop.
1058 if (csym
->curr
.tri
!= yes
)
1061 prop
= sym_get_choice_prop(csym
);
1063 /* count entries in choice block */
1065 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1069 * find a random value and set it to yes,
1070 * set the rest to no so we have only one set
1072 def
= (rand() % cnt
);
1075 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1077 sym
->def
[S_DEF_USER
].tri
= yes
;
1078 csym
->def
[S_DEF_USER
].val
= sym
;
1081 sym
->def
[S_DEF_USER
].tri
= no
;
1084 csym
->flags
|= SYMBOL_DEF_USER
;
1085 /* clear VALID to get value calculated */
1086 csym
->flags
&= ~(SYMBOL_VALID
);
1089 static void set_all_choice_values(struct symbol
*csym
)
1091 struct property
*prop
;
1095 prop
= sym_get_choice_prop(csym
);
1098 * Set all non-assinged choice values to no
1100 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1101 if (!sym_has_value(sym
))
1102 sym
->def
[S_DEF_USER
].tri
= no
;
1104 csym
->flags
|= SYMBOL_DEF_USER
;
1105 /* clear VALID to get value calculated */
1106 csym
->flags
&= ~(SYMBOL_VALID
);
1109 void conf_set_all_new_symbols(enum conf_def_mode mode
)
1111 struct symbol
*sym
, *csym
;
1114 for_all_symbols(i
, sym
) {
1115 if (sym_has_value(sym
))
1117 switch (sym_get_type(sym
)) {
1122 sym
->def
[S_DEF_USER
].tri
= yes
;
1125 sym
->def
[S_DEF_USER
].tri
= mod
;
1128 sym
->def
[S_DEF_USER
].tri
= no
;
1131 cnt
= sym_get_type(sym
) == S_TRISTATE
? 3 : 2;
1132 sym
->def
[S_DEF_USER
].tri
= (tristate
)(rand() % cnt
);
1137 if (!(sym_is_choice(sym
) && mode
== def_random
))
1138 sym
->flags
|= SYMBOL_DEF_USER
;
1146 sym_clear_all_valid();
1149 * We have different type of choice blocks.
1150 * If curr.tri equals to mod then we can select several
1151 * choice symbols in one block.
1152 * In this case we do nothing.
1153 * If curr.tri equals yes then only one symbol can be
1154 * selected in a choice block and we set it to yes,
1155 * and the rest to no.
1157 for_all_symbols(i
, csym
) {
1158 if (sym_has_value(csym
) || !sym_is_choice(csym
))
1161 sym_calc_value(csym
);
1162 if (mode
== def_random
)
1163 randomize_choice_values(csym
);
1165 set_all_choice_values(csym
);