1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
21 /* return true if 'path' exists, false otherwise */
22 static bool is_present(const char *path
)
26 return !stat(path
, &st
);
29 /* return true if 'path' exists and it is a directory, false otherwise */
30 static bool is_dir(const char *path
)
37 return S_ISDIR(st
.st_mode
);
40 /* return true if the given two files are the same, false otherwise */
41 static bool is_same(const char *file1
, const char *file2
)
48 fd1
= open(file1
, O_RDONLY
);
52 fd2
= open(file2
, O_RDONLY
);
56 ret
= fstat(fd1
, &st1
);
59 ret
= fstat(fd2
, &st2
);
63 if (st1
.st_size
!= st2
.st_size
)
66 map1
= mmap(NULL
, st1
.st_size
, PROT_READ
, MAP_PRIVATE
, fd1
, 0);
67 if (map1
== MAP_FAILED
)
70 map2
= mmap(NULL
, st2
.st_size
, PROT_READ
, MAP_PRIVATE
, fd2
, 0);
71 if (map2
== MAP_FAILED
)
74 if (bcmp(map1
, map2
, st1
.st_size
))
87 * Create the parent directory of the given path.
89 * For example, if 'include/config/auto.conf' is given, create 'include/config'.
91 static int make_parent_dir(const char *path
)
93 char tmp
[PATH_MAX
+ 1];
96 strncpy(tmp
, path
, sizeof(tmp
));
97 tmp
[sizeof(tmp
) - 1] = 0;
99 /* Remove the base name. Just return if nothing is left */
100 p
= strrchr(tmp
, '/');
105 /* Just in case it is an absolute path */
110 while ((p
= strchr(p
, '/'))) {
113 /* skip if the directory exists */
114 if (!is_dir(tmp
) && mkdir(tmp
, 0755))
125 static char depfile_path
[PATH_MAX
];
126 static size_t depfile_prefix_len
;
128 /* touch depfile for symbol 'name' */
129 static int conf_touch_dep(const char *name
)
135 /* check overflow: prefix + name + ".h" + '\0' must fit in buffer. */
136 if (depfile_prefix_len
+ strlen(name
) + 3 > sizeof(depfile_path
))
139 d
= depfile_path
+ depfile_prefix_len
;
143 *d
++ = (c
== '_') ? '/' : tolower(c
);
146 /* Assume directory path already exists. */
147 fd
= open(depfile_path
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0644);
152 ret
= make_parent_dir(depfile_path
);
157 fd
= open(depfile_path
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0644);
166 struct conf_printer
{
167 void (*print_symbol
)(FILE *, struct symbol
*, const char *, void *);
168 void (*print_comment
)(FILE *, const char *, void *);
171 static void conf_warning(const char *fmt
, ...)
172 __attribute__ ((format (printf
, 1, 2)));
174 static void conf_message(const char *fmt
, ...)
175 __attribute__ ((format (printf
, 1, 2)));
177 static const char *conf_filename
;
178 static int conf_lineno
, conf_warnings
;
180 const char conf_defname
[] = "arch/$(ARCH)/defconfig";
182 static void conf_warning(const char *fmt
, ...)
186 fprintf(stderr
, "%s:%d:warning: ", conf_filename
, conf_lineno
);
187 vfprintf(stderr
, fmt
, ap
);
188 fprintf(stderr
, "\n");
193 static void conf_default_message_callback(const char *s
)
200 static void (*conf_message_callback
)(const char *s
) =
201 conf_default_message_callback
;
202 void conf_set_message_callback(void (*fn
)(const char *s
))
204 conf_message_callback
= fn
;
207 static void conf_message(const char *fmt
, ...)
212 if (!conf_message_callback
)
217 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
218 conf_message_callback(buf
);
222 const char *conf_get_configname(void)
224 char *name
= getenv("KCONFIG_CONFIG");
226 return name
? name
: ".config";
229 static const char *conf_get_autoconfig_name(void)
231 char *name
= getenv("KCONFIG_AUTOCONFIG");
233 return name
? name
: "include/config/auto.conf";
236 char *conf_get_default_confname(void)
238 static char fullname
[PATH_MAX
+1];
241 name
= expand_string(conf_defname
);
242 env
= getenv(SRCTREE
);
244 snprintf(fullname
, sizeof(fullname
), "%s/%s", env
, name
);
245 if (is_present(fullname
))
251 static int conf_set_sym_val(struct symbol
*sym
, int def
, int def_flags
, char *p
)
258 sym
->def
[def
].tri
= mod
;
259 sym
->flags
|= def_flags
;
265 sym
->def
[def
].tri
= yes
;
266 sym
->flags
|= def_flags
;
270 sym
->def
[def
].tri
= no
;
271 sym
->flags
|= def_flags
;
274 if (def
!= S_DEF_AUTO
)
275 conf_warning("symbol value '%s' invalid for %s",
281 for (p2
= p
; (p2
= strpbrk(p2
, "\"\\")); p2
++) {
286 memmove(p2
, p2
+ 1, strlen(p2
));
289 if (def
!= S_DEF_AUTO
)
290 conf_warning("invalid string found");
296 if (sym_string_valid(sym
, p
)) {
297 sym
->def
[def
].val
= xstrdup(p
);
298 sym
->flags
|= def_flags
;
300 if (def
!= S_DEF_AUTO
)
301 conf_warning("symbol value '%s' invalid for %s",
312 #define LINE_GROWTH 16
313 static int add_byte(int c
, char **lineptr
, size_t slen
, size_t *n
)
316 size_t new_size
= slen
+ 1;
318 new_size
+= LINE_GROWTH
- 1;
320 nline
= xrealloc(*lineptr
, new_size
);
328 (*lineptr
)[slen
] = c
;
333 static ssize_t
compat_getline(char **lineptr
, size_t *n
, FILE *stream
)
335 char *line
= *lineptr
;
339 int c
= getc(stream
);
343 if (add_byte(c
, &line
, slen
, n
) < 0)
348 if (add_byte('\0', &line
, slen
, n
) < 0)
355 if (add_byte(c
, &line
, slen
, n
) < 0)
367 int conf_read_simple(const char *name
, int def
)
371 size_t line_asize
= 0;
377 in
= zconf_fopen(name
);
379 struct property
*prop
;
381 name
= conf_get_configname();
382 in
= zconf_fopen(name
);
385 sym_add_change_count(1);
386 if (!sym_defconfig_list
)
389 for_all_defaults(sym_defconfig_list
, prop
) {
390 if (expr_calc_value(prop
->visible
.expr
) == no
||
391 prop
->expr
->type
!= E_SYMBOL
)
393 sym_calc_value(prop
->expr
->left
.sym
);
394 name
= sym_get_string_value(prop
->expr
->left
.sym
);
395 in
= zconf_fopen(name
);
397 conf_message("using defaults found in %s",
407 conf_filename
= name
;
411 def_flags
= SYMBOL_DEF
<< def
;
412 for_all_symbols(i
, sym
) {
413 sym
->flags
|= SYMBOL_CHANGED
;
414 sym
->flags
&= ~(def_flags
|SYMBOL_VALID
);
415 if (sym_is_choice(sym
))
416 sym
->flags
|= def_flags
;
421 if (sym
->def
[def
].val
)
422 free(sym
->def
[def
].val
);
425 sym
->def
[def
].val
= NULL
;
426 sym
->def
[def
].tri
= no
;
430 while (compat_getline(&line
, &line_asize
, in
) != -1) {
433 if (line
[0] == '#') {
434 if (memcmp(line
+ 2, CONFIG_
, strlen(CONFIG_
)))
436 p
= strchr(line
+ 2 + strlen(CONFIG_
), ' ');
440 if (strncmp(p
, "is not set", 10))
442 if (def
== S_DEF_USER
) {
443 sym
= sym_find(line
+ 2 + strlen(CONFIG_
));
445 sym_add_change_count(1);
449 sym
= sym_lookup(line
+ 2 + strlen(CONFIG_
), 0);
450 if (sym
->type
== S_UNKNOWN
)
451 sym
->type
= S_BOOLEAN
;
453 if (sym
->flags
& def_flags
) {
454 conf_warning("override: reassigning to symbol %s", sym
->name
);
459 sym
->def
[def
].tri
= no
;
460 sym
->flags
|= def_flags
;
465 } else if (memcmp(line
, CONFIG_
, strlen(CONFIG_
)) == 0) {
466 p
= strchr(line
+ strlen(CONFIG_
), '=');
470 p2
= strchr(p
, '\n');
477 sym
= sym_find(line
+ strlen(CONFIG_
));
479 if (def
== S_DEF_AUTO
)
481 * Reading from include/config/auto.conf
482 * If CONFIG_FOO previously existed in
483 * auto.conf but it is missing now,
484 * include/config/foo.h must be touched.
486 conf_touch_dep(line
+ strlen(CONFIG_
));
488 sym_add_change_count(1);
492 if (sym
->flags
& def_flags
) {
493 conf_warning("override: reassigning to symbol %s", sym
->name
);
495 if (conf_set_sym_val(sym
, def
, def_flags
, p
))
498 if (line
[0] != '\r' && line
[0] != '\n')
499 conf_warning("unexpected data: %.*s",
500 (int)strcspn(line
, "\r\n"), line
);
505 if (sym
&& sym_is_choice_value(sym
)) {
506 struct symbol
*cs
= prop_get_symbol(sym_get_choice_prop(sym
));
507 switch (sym
->def
[def
].tri
) {
511 if (cs
->def
[def
].tri
== yes
) {
512 conf_warning("%s creates inconsistent choice state", sym
->name
);
513 cs
->flags
&= ~def_flags
;
517 if (cs
->def
[def
].tri
!= no
)
518 conf_warning("override: %s changes choice state", sym
->name
);
519 cs
->def
[def
].val
= sym
;
522 cs
->def
[def
].tri
= EXPR_OR(cs
->def
[def
].tri
, sym
->def
[def
].tri
);
530 int conf_read(const char *name
)
533 int conf_unsaved
= 0;
536 sym_set_change_count(0);
538 if (conf_read_simple(name
, S_DEF_USER
)) {
539 sym_calc_value(modules_sym
);
543 sym_calc_value(modules_sym
);
545 for_all_symbols(i
, sym
) {
547 if (sym_is_choice(sym
) || (sym
->flags
& SYMBOL_NO_WRITE
))
549 if (sym_has_value(sym
) && (sym
->flags
& SYMBOL_WRITE
)) {
550 /* check that calculated value agrees with saved value */
554 if (sym
->def
[S_DEF_USER
].tri
!= sym_get_tristate_value(sym
))
556 if (!sym_is_choice(sym
))
560 if (!strcmp(sym
->curr
.val
, sym
->def
[S_DEF_USER
].val
))
564 } else if (!sym_has_value(sym
) && !(sym
->flags
& SYMBOL_WRITE
))
565 /* no previous value and not saved */
568 /* maybe print value in verbose mode... */
571 for_all_symbols(i
, sym
) {
572 if (sym_has_value(sym
) && !sym_is_choice_value(sym
)) {
573 /* Reset values of generates values, so they'll appear
574 * as new, if they should become visible, but that
575 * doesn't quite work if the Kconfig and the saved
576 * configuration disagree.
578 if (sym
->visible
== no
&& !conf_unsaved
)
579 sym
->flags
&= ~SYMBOL_DEF_USER
;
584 /* Reset a string value if it's out of range */
585 if (sym_string_within_range(sym
, sym
->def
[S_DEF_USER
].val
))
587 sym
->flags
&= ~(SYMBOL_VALID
|SYMBOL_DEF_USER
);
596 sym_add_change_count(conf_warnings
|| conf_unsaved
);
602 * Kconfig configuration printer
604 * This printer is used when generating the resulting configuration after
605 * kconfig invocation and `defconfig' files. Unset symbol might be omitted by
606 * passing a non-NULL argument to the printer.
610 kconfig_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
617 bool skip_unset
= (arg
!= NULL
);
620 fprintf(fp
, "# %s%s is not set\n",
629 fprintf(fp
, "%s%s=%s\n", CONFIG_
, sym
->name
, value
);
633 kconfig_print_comment(FILE *fp
, const char *value
, void *arg
)
635 const char *p
= value
;
639 l
= strcspn(p
, "\n");
643 xfwrite(p
, l
, 1, fp
);
652 static struct conf_printer kconfig_printer_cb
=
654 .print_symbol
= kconfig_print_symbol
,
655 .print_comment
= kconfig_print_comment
,
661 * This printer is used when generating the `include/generated/autoconf.h' file.
664 header_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
670 const char *suffix
= "";
679 fprintf(fp
, "#define %s%s%s 1\n",
680 CONFIG_
, sym
->name
, suffix
);
685 const char *prefix
= "";
687 if (value
[0] != '0' || (value
[1] != 'x' && value
[1] != 'X'))
689 fprintf(fp
, "#define %s%s %s%s\n",
690 CONFIG_
, sym
->name
, prefix
, value
);
695 fprintf(fp
, "#define %s%s %s\n",
696 CONFIG_
, sym
->name
, value
);
705 header_print_comment(FILE *fp
, const char *value
, void *arg
)
707 const char *p
= value
;
712 l
= strcspn(p
, "\n");
716 xfwrite(p
, l
, 1, fp
);
723 fprintf(fp
, " */\n");
726 static struct conf_printer header_printer_cb
=
728 .print_symbol
= header_print_symbol
,
729 .print_comment
= header_print_comment
,
735 * This printer is used when generating the `include/config/tristate.conf' file.
738 tristate_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
741 if (sym
->type
== S_TRISTATE
&& *value
!= 'n')
742 fprintf(fp
, "%s%s=%c\n", CONFIG_
, sym
->name
, (char)toupper(*value
));
745 static struct conf_printer tristate_printer_cb
=
747 .print_symbol
= tristate_print_symbol
,
748 .print_comment
= kconfig_print_comment
,
751 static void conf_write_symbol(FILE *fp
, struct symbol
*sym
,
752 struct conf_printer
*printer
, void *printer_arg
)
760 str
= sym_get_string_value(sym
);
761 str
= sym_escape_string_value(str
);
762 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
766 str
= sym_get_string_value(sym
);
767 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
772 conf_write_heading(FILE *fp
, struct conf_printer
*printer
, void *printer_arg
)
776 snprintf(buf
, sizeof(buf
),
778 "Automatically generated file; DO NOT EDIT.\n"
780 rootmenu
.prompt
->text
);
782 printer
->print_comment(fp
, buf
, printer_arg
);
786 * Write out a minimal config.
787 * All values that has default values are skipped as this is redundant.
789 int conf_write_defconfig(const char *filename
)
795 out
= fopen(filename
, "w");
799 sym_clear_all_valid();
801 /* Traverse all menus to find all relevant symbols */
802 menu
= rootmenu
.list
;
808 if (!menu_is_visible(menu
))
810 } else if (!sym_is_choice(sym
)) {
812 if (!(sym
->flags
& SYMBOL_WRITE
))
814 sym
->flags
&= ~SYMBOL_WRITE
;
815 /* If we cannot change the symbol - skip */
816 if (!sym_is_changable(sym
))
818 /* If symbol equals to default value - skip */
819 if (strcmp(sym_get_string_value(sym
), sym_get_string_default(sym
)) == 0)
823 * If symbol is a choice value and equals to the
824 * default for a choice - skip.
825 * But only if value is bool and equal to "y" and
826 * choice is not "optional".
827 * (If choice is "optional" then all values can be "n")
829 if (sym_is_choice_value(sym
)) {
833 cs
= prop_get_symbol(sym_get_choice_prop(sym
));
834 ds
= sym_choice_default(cs
);
835 if (!sym_is_optional(cs
) && sym
== ds
) {
836 if ((sym
->type
== S_BOOLEAN
) &&
837 sym_get_tristate_value(sym
) == yes
)
841 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
844 if (menu
->list
!= NULL
) {
847 else if (menu
->next
!= NULL
) {
850 while ((menu
= menu
->parent
)) {
851 if (menu
->next
!= NULL
) {
862 int conf_write(const char *name
)
868 char tmpname
[PATH_MAX
+ 1], oldname
[PATH_MAX
+ 1];
870 bool need_newline
= false;
873 name
= conf_get_configname();
876 fprintf(stderr
, "config name is empty\n");
881 fprintf(stderr
, "%s: Is a directory\n", name
);
885 if (make_parent_dir(name
))
888 env
= getenv("KCONFIG_OVERWRITECONFIG");
891 out
= fopen(name
, "w");
893 snprintf(tmpname
, sizeof(tmpname
), "%s.%d.tmp",
894 name
, (int)getpid());
895 out
= fopen(tmpname
, "w");
900 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
902 if (!conf_get_changed())
903 sym_clear_all_valid();
905 menu
= rootmenu
.list
;
909 if (!menu_is_visible(menu
))
911 str
= menu_get_prompt(menu
);
916 need_newline
= false;
917 } else if (!(sym
->flags
& SYMBOL_CHOICE
)) {
919 if (!(sym
->flags
& SYMBOL_WRITE
))
923 need_newline
= false;
925 sym
->flags
&= ~SYMBOL_WRITE
;
926 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
936 else while ((menu
= menu
->parent
)) {
937 if (!menu
->sym
&& menu_is_visible(menu
) &&
939 str
= menu_get_prompt(menu
);
940 fprintf(out
, "# end of %s\n", str
);
952 if (is_same(name
, tmpname
)) {
953 conf_message("No change to %s", name
);
955 sym_set_change_count(0);
959 snprintf(oldname
, sizeof(oldname
), "%s.old", name
);
960 rename(name
, oldname
);
961 if (rename(tmpname
, name
))
965 conf_message("configuration written to %s", name
);
967 sym_set_change_count(0);
972 /* write a dependency file as used by kbuild to track dependencies */
973 static int conf_write_dep(const char *name
)
978 out
= fopen("..config.tmp", "w");
981 fprintf(out
, "deps_config := \\\n");
982 for (file
= file_list
; file
; file
= file
->next
) {
984 fprintf(out
, "\t%s \\\n", file
->name
);
986 fprintf(out
, "\t%s\n", file
->name
);
988 fprintf(out
, "\n%s: \\\n"
989 "\t$(deps_config)\n\n", conf_get_autoconfig_name());
991 env_write_dep(out
, conf_get_autoconfig_name());
993 fprintf(out
, "\n$(deps_config): ;\n");
996 if (make_parent_dir(name
))
998 rename("..config.tmp", name
);
1002 static int conf_touch_deps(void)
1008 strcpy(depfile_path
, "include/config/");
1009 depfile_prefix_len
= strlen(depfile_path
);
1011 name
= conf_get_autoconfig_name();
1012 conf_read_simple(name
, S_DEF_AUTO
);
1013 sym_calc_value(modules_sym
);
1015 for_all_symbols(i
, sym
) {
1016 sym_calc_value(sym
);
1017 if ((sym
->flags
& SYMBOL_NO_WRITE
) || !sym
->name
)
1019 if (sym
->flags
& SYMBOL_WRITE
) {
1020 if (sym
->flags
& SYMBOL_DEF_AUTO
) {
1022 * symbol has old and new value,
1023 * so compare them...
1025 switch (sym
->type
) {
1028 if (sym_get_tristate_value(sym
) ==
1029 sym
->def
[S_DEF_AUTO
].tri
)
1035 if (!strcmp(sym_get_string_value(sym
),
1036 sym
->def
[S_DEF_AUTO
].val
))
1044 * If there is no old value, only 'no' (unset)
1045 * is allowed as new value.
1047 switch (sym
->type
) {
1050 if (sym_get_tristate_value(sym
) == no
)
1057 } else if (!(sym
->flags
& SYMBOL_DEF_AUTO
))
1058 /* There is neither an old nor a new value. */
1061 * There is an old value, but no new value ('no' (unset)
1062 * isn't saved in auto.conf, so the old value is always
1063 * different from 'no').
1066 res
= conf_touch_dep(sym
->name
);
1074 int conf_write_autoconf(int overwrite
)
1078 const char *autoconf_name
= conf_get_autoconfig_name();
1079 FILE *out
, *tristate
, *out_h
;
1082 if (!overwrite
&& is_present(autoconf_name
))
1085 sym_clear_all_valid();
1087 conf_write_dep("include/config/auto.conf.cmd");
1089 if (conf_touch_deps())
1092 out
= fopen(".tmpconfig", "w");
1096 tristate
= fopen(".tmpconfig_tristate", "w");
1102 out_h
= fopen(".tmpconfig.h", "w");
1109 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
1111 conf_write_heading(tristate
, &tristate_printer_cb
, NULL
);
1113 conf_write_heading(out_h
, &header_printer_cb
, NULL
);
1115 for_all_symbols(i
, sym
) {
1116 sym_calc_value(sym
);
1117 if (!(sym
->flags
& SYMBOL_WRITE
) || !sym
->name
)
1120 /* write symbol to auto.conf, tristate and header files */
1121 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, (void *)1);
1123 conf_write_symbol(tristate
, sym
, &tristate_printer_cb
, (void *)1);
1125 conf_write_symbol(out_h
, sym
, &header_printer_cb
, NULL
);
1131 name
= getenv("KCONFIG_AUTOHEADER");
1133 name
= "include/generated/autoconf.h";
1134 if (make_parent_dir(name
))
1136 if (rename(".tmpconfig.h", name
))
1139 name
= getenv("KCONFIG_TRISTATE");
1141 name
= "include/config/tristate.conf";
1142 if (make_parent_dir(name
))
1144 if (rename(".tmpconfig_tristate", name
))
1147 if (make_parent_dir(autoconf_name
))
1150 * This must be the last step, kbuild has a dependency on auto.conf
1151 * and this marks the successful completion of the previous steps.
1153 if (rename(".tmpconfig", autoconf_name
))
1159 static int sym_change_count
;
1160 static void (*conf_changed_callback
)(void);
1162 void sym_set_change_count(int count
)
1164 int _sym_change_count
= sym_change_count
;
1165 sym_change_count
= count
;
1166 if (conf_changed_callback
&&
1167 (bool)_sym_change_count
!= (bool)count
)
1168 conf_changed_callback();
1171 void sym_add_change_count(int count
)
1173 sym_set_change_count(count
+ sym_change_count
);
1176 bool conf_get_changed(void)
1178 return sym_change_count
;
1181 void conf_set_changed_callback(void (*fn
)(void))
1183 conf_changed_callback
= fn
;
1186 static bool randomize_choice_values(struct symbol
*csym
)
1188 struct property
*prop
;
1194 * If choice is mod then we may have more items selected
1195 * and if no then no-one.
1196 * In both cases stop.
1198 if (csym
->curr
.tri
!= yes
)
1201 prop
= sym_get_choice_prop(csym
);
1203 /* count entries in choice block */
1205 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1209 * find a random value and set it to yes,
1210 * set the rest to no so we have only one set
1212 def
= (rand() % cnt
);
1215 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1217 sym
->def
[S_DEF_USER
].tri
= yes
;
1218 csym
->def
[S_DEF_USER
].val
= sym
;
1221 sym
->def
[S_DEF_USER
].tri
= no
;
1223 sym
->flags
|= SYMBOL_DEF_USER
;
1224 /* clear VALID to get value calculated */
1225 sym
->flags
&= ~SYMBOL_VALID
;
1227 csym
->flags
|= SYMBOL_DEF_USER
;
1228 /* clear VALID to get value calculated */
1229 csym
->flags
&= ~(SYMBOL_VALID
);
1234 void set_all_choice_values(struct symbol
*csym
)
1236 struct property
*prop
;
1240 prop
= sym_get_choice_prop(csym
);
1243 * Set all non-assinged choice values to no
1245 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1246 if (!sym_has_value(sym
))
1247 sym
->def
[S_DEF_USER
].tri
= no
;
1249 csym
->flags
|= SYMBOL_DEF_USER
;
1250 /* clear VALID to get value calculated */
1251 csym
->flags
&= ~(SYMBOL_VALID
| SYMBOL_NEED_SET_CHOICE_VALUES
);
1254 bool conf_set_all_new_symbols(enum conf_def_mode mode
)
1256 struct symbol
*sym
, *csym
;
1257 int i
, cnt
, pby
, pty
, ptm
; /* pby: probability of bool = y
1258 * pty: probability of tristate = y
1259 * ptm: probability of tristate = m
1262 pby
= 50; pty
= ptm
= 33; /* can't go as the default in switch-case
1263 * below, otherwise gcc whines about
1264 * -Wmaybe-uninitialized */
1265 if (mode
== def_random
) {
1267 char *env
= getenv("KCONFIG_PROBABILITY");
1269 while( env
&& *env
) {
1271 int tmp
= strtol( env
, &endp
, 10 );
1272 if( tmp
>= 0 && tmp
<= 100 ) {
1276 perror( "KCONFIG_PROBABILITY" );
1279 env
= (*endp
== ':') ? endp
+1 : endp
;
1286 pby
= p
[0]; ptm
= pby
/2; pty
= pby
-ptm
;
1289 pty
= p
[0]; ptm
= p
[1]; pby
= pty
+ ptm
;
1292 pby
= p
[0]; pty
= p
[1]; ptm
= p
[2];
1296 if( pty
+ptm
> 100 ) {
1298 perror( "KCONFIG_PROBABILITY" );
1302 bool has_changed
= false;
1304 for_all_symbols(i
, sym
) {
1305 if (sym_has_value(sym
) || (sym
->flags
& SYMBOL_VALID
))
1307 switch (sym_get_type(sym
)) {
1313 sym
->def
[S_DEF_USER
].tri
= yes
;
1316 sym
->def
[S_DEF_USER
].tri
= mod
;
1319 if (sym
->flags
& SYMBOL_ALLNOCONFIG_Y
)
1320 sym
->def
[S_DEF_USER
].tri
= yes
;
1322 sym
->def
[S_DEF_USER
].tri
= no
;
1325 sym
->def
[S_DEF_USER
].tri
= no
;
1327 if (sym
->type
== S_TRISTATE
) {
1329 sym
->def
[S_DEF_USER
].tri
= yes
;
1330 else if (cnt
< (pty
+ptm
))
1331 sym
->def
[S_DEF_USER
].tri
= mod
;
1332 } else if (cnt
< pby
)
1333 sym
->def
[S_DEF_USER
].tri
= yes
;
1338 if (!(sym_is_choice(sym
) && mode
== def_random
))
1339 sym
->flags
|= SYMBOL_DEF_USER
;
1347 sym_clear_all_valid();
1350 * We have different type of choice blocks.
1351 * If curr.tri equals to mod then we can select several
1352 * choice symbols in one block.
1353 * In this case we do nothing.
1354 * If curr.tri equals yes then only one symbol can be
1355 * selected in a choice block and we set it to yes,
1356 * and the rest to no.
1358 if (mode
!= def_random
) {
1359 for_all_symbols(i
, csym
) {
1360 if ((sym_is_choice(csym
) && !sym_has_value(csym
)) ||
1361 sym_is_choice_value(csym
))
1362 csym
->flags
|= SYMBOL_NEED_SET_CHOICE_VALUES
;
1366 for_all_symbols(i
, csym
) {
1367 if (sym_has_value(csym
) || !sym_is_choice(csym
))
1370 sym_calc_value(csym
);
1371 if (mode
== def_random
)
1372 has_changed
= randomize_choice_values(csym
);
1374 set_all_choice_values(csym
);