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 static void conf_warning(const char *fmt
, ...)
184 fprintf(stderr
, "%s:%d:warning: ", conf_filename
, conf_lineno
);
185 vfprintf(stderr
, fmt
, ap
);
186 fprintf(stderr
, "\n");
191 static void conf_default_message_callback(const char *s
)
198 static void (*conf_message_callback
)(const char *s
) =
199 conf_default_message_callback
;
200 void conf_set_message_callback(void (*fn
)(const char *s
))
202 conf_message_callback
= fn
;
205 static void conf_message(const char *fmt
, ...)
210 if (!conf_message_callback
)
215 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
216 conf_message_callback(buf
);
220 const char *conf_get_configname(void)
222 char *name
= getenv("KCONFIG_CONFIG");
224 return name
? name
: ".config";
227 static const char *conf_get_autoconfig_name(void)
229 char *name
= getenv("KCONFIG_AUTOCONFIG");
231 return name
? name
: "include/config/auto.conf";
234 static int conf_set_sym_val(struct symbol
*sym
, int def
, int def_flags
, char *p
)
241 sym
->def
[def
].tri
= mod
;
242 sym
->flags
|= def_flags
;
248 sym
->def
[def
].tri
= yes
;
249 sym
->flags
|= def_flags
;
253 sym
->def
[def
].tri
= no
;
254 sym
->flags
|= def_flags
;
257 if (def
!= S_DEF_AUTO
)
258 conf_warning("symbol value '%s' invalid for %s",
264 for (p2
= p
; (p2
= strpbrk(p2
, "\"\\")); p2
++) {
269 memmove(p2
, p2
+ 1, strlen(p2
));
272 if (def
!= S_DEF_AUTO
)
273 conf_warning("invalid string found");
279 if (sym_string_valid(sym
, p
)) {
280 sym
->def
[def
].val
= xstrdup(p
);
281 sym
->flags
|= def_flags
;
283 if (def
!= S_DEF_AUTO
)
284 conf_warning("symbol value '%s' invalid for %s",
295 #define LINE_GROWTH 16
296 static int add_byte(int c
, char **lineptr
, size_t slen
, size_t *n
)
299 size_t new_size
= slen
+ 1;
301 new_size
+= LINE_GROWTH
- 1;
303 nline
= xrealloc(*lineptr
, new_size
);
311 (*lineptr
)[slen
] = c
;
316 static ssize_t
compat_getline(char **lineptr
, size_t *n
, FILE *stream
)
318 char *line
= *lineptr
;
322 int c
= getc(stream
);
326 if (add_byte(c
, &line
, slen
, n
) < 0)
331 if (add_byte('\0', &line
, slen
, n
) < 0)
338 if (add_byte(c
, &line
, slen
, n
) < 0)
350 void conf_reset(int def
)
355 def_flags
= SYMBOL_DEF
<< def
;
356 for_all_symbols(i
, sym
) {
357 sym
->flags
|= SYMBOL_CHANGED
;
358 sym
->flags
&= ~(def_flags
|SYMBOL_VALID
);
359 if (sym_is_choice(sym
))
360 sym
->flags
|= def_flags
;
365 if (sym
->def
[def
].val
)
366 free(sym
->def
[def
].val
);
369 sym
->def
[def
].val
= NULL
;
370 sym
->def
[def
].tri
= no
;
375 int conf_read_simple(const char *name
, int def
)
379 size_t line_asize
= 0;
385 in
= zconf_fopen(name
);
387 struct property
*prop
;
389 name
= conf_get_configname();
390 in
= zconf_fopen(name
);
393 sym_add_change_count(1);
394 if (!sym_defconfig_list
)
397 for_all_defaults(sym_defconfig_list
, prop
) {
398 if (expr_calc_value(prop
->visible
.expr
) == no
||
399 prop
->expr
->type
!= E_SYMBOL
)
401 sym_calc_value(prop
->expr
->left
.sym
);
402 name
= sym_get_string_value(prop
->expr
->left
.sym
);
403 in
= zconf_fopen(name
);
405 conf_message("using defaults found in %s",
415 conf_filename
= name
;
419 def_flags
= SYMBOL_DEF
<< def
;
422 while (compat_getline(&line
, &line_asize
, in
) != -1) {
425 if (line
[0] == '#') {
426 if (memcmp(line
+ 2, CONFIG_
, strlen(CONFIG_
)))
428 p
= strchr(line
+ 2 + strlen(CONFIG_
), ' ');
432 if (strncmp(p
, "is not set", 10))
434 if (def
== S_DEF_USER
) {
435 sym
= sym_find(line
+ 2 + strlen(CONFIG_
));
437 sym_add_change_count(1);
441 sym
= sym_lookup(line
+ 2 + strlen(CONFIG_
), 0);
442 if (sym
->type
== S_UNKNOWN
)
443 sym
->type
= S_BOOLEAN
;
448 sym
->def
[def
].tri
= no
;
449 sym
->flags
|= def_flags
;
454 } else if (memcmp(line
, CONFIG_
, strlen(CONFIG_
)) == 0) {
455 p
= strchr(line
+ strlen(CONFIG_
), '=');
459 p2
= strchr(p
, '\n');
466 sym
= sym_find(line
+ strlen(CONFIG_
));
468 if (def
== S_DEF_AUTO
)
470 * Reading from include/config/auto.conf
471 * If CONFIG_FOO previously existed in
472 * auto.conf but it is missing now,
473 * include/config/foo.h must be touched.
475 conf_touch_dep(line
+ strlen(CONFIG_
));
477 sym_add_change_count(1);
481 if (conf_set_sym_val(sym
, def
, def_flags
, p
))
484 if (line
[0] != '\r' && line
[0] != '\n')
485 conf_warning("unexpected data: %.*s",
486 (int)strcspn(line
, "\r\n"), line
);
491 if (sym
&& sym_is_choice_value(sym
)) {
492 struct symbol
*cs
= prop_get_symbol(sym_get_choice_prop(sym
));
493 switch (sym
->def
[def
].tri
) {
497 if (cs
->def
[def
].tri
== yes
) {
498 conf_warning("%s creates inconsistent choice state", sym
->name
);
499 cs
->flags
&= ~def_flags
;
503 if (cs
->def
[def
].tri
!= no
)
504 conf_warning("override: %s changes choice state", sym
->name
);
505 cs
->def
[def
].val
= sym
;
508 cs
->def
[def
].tri
= EXPR_OR(cs
->def
[def
].tri
, sym
->def
[def
].tri
);
516 int conf_read(const char *name
)
519 int conf_unsaved
= 0;
522 sym_set_change_count(0);
524 if (conf_read_simple(name
, S_DEF_USER
)) {
525 sym_calc_value(modules_sym
);
529 sym_calc_value(modules_sym
);
531 for_all_symbols(i
, sym
) {
533 if (sym_is_choice(sym
) || (sym
->flags
& SYMBOL_NO_WRITE
))
535 if (sym_has_value(sym
) && (sym
->flags
& SYMBOL_WRITE
)) {
536 /* check that calculated value agrees with saved value */
540 if (sym
->def
[S_DEF_USER
].tri
== sym_get_tristate_value(sym
))
544 if (!strcmp(sym
->curr
.val
, sym
->def
[S_DEF_USER
].val
))
548 } else if (!sym_has_value(sym
) && !(sym
->flags
& SYMBOL_WRITE
))
549 /* no previous value and not saved */
552 /* maybe print value in verbose mode... */
555 for_all_symbols(i
, sym
) {
556 if (sym_has_value(sym
) && !sym_is_choice_value(sym
)) {
557 /* Reset values of generates values, so they'll appear
558 * as new, if they should become visible, but that
559 * doesn't quite work if the Kconfig and the saved
560 * configuration disagree.
562 if (sym
->visible
== no
&& !conf_unsaved
)
563 sym
->flags
&= ~SYMBOL_DEF_USER
;
568 /* Reset a string value if it's out of range */
569 if (sym_string_within_range(sym
, sym
->def
[S_DEF_USER
].val
))
571 sym
->flags
&= ~(SYMBOL_VALID
|SYMBOL_DEF_USER
);
580 sym_add_change_count(conf_warnings
|| conf_unsaved
);
586 * Kconfig configuration printer
588 * This printer is used when generating the resulting configuration after
589 * kconfig invocation and `defconfig' files. Unset symbol might be omitted by
590 * passing a non-NULL argument to the printer.
594 kconfig_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
601 bool skip_unset
= (arg
!= NULL
);
604 fprintf(fp
, "# %s%s is not set\n",
613 fprintf(fp
, "%s%s=%s\n", CONFIG_
, sym
->name
, value
);
617 kconfig_print_comment(FILE *fp
, const char *value
, void *arg
)
619 const char *p
= value
;
623 l
= strcspn(p
, "\n");
627 xfwrite(p
, l
, 1, fp
);
636 static struct conf_printer kconfig_printer_cb
=
638 .print_symbol
= kconfig_print_symbol
,
639 .print_comment
= kconfig_print_comment
,
645 * This printer is used when generating the `include/generated/autoconf.h' file.
648 header_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
654 const char *suffix
= "";
663 fprintf(fp
, "#define %s%s%s 1\n",
664 CONFIG_
, sym
->name
, suffix
);
669 const char *prefix
= "";
671 if (value
[0] != '0' || (value
[1] != 'x' && value
[1] != 'X'))
673 fprintf(fp
, "#define %s%s %s%s\n",
674 CONFIG_
, sym
->name
, prefix
, value
);
679 fprintf(fp
, "#define %s%s %s\n",
680 CONFIG_
, sym
->name
, value
);
689 header_print_comment(FILE *fp
, const char *value
, void *arg
)
691 const char *p
= value
;
696 l
= strcspn(p
, "\n");
700 xfwrite(p
, l
, 1, fp
);
707 fprintf(fp
, " */\n");
710 static struct conf_printer header_printer_cb
=
712 .print_symbol
= header_print_symbol
,
713 .print_comment
= header_print_comment
,
716 static void conf_write_symbol(FILE *fp
, struct symbol
*sym
,
717 struct conf_printer
*printer
, void *printer_arg
)
725 str
= sym_get_string_value(sym
);
726 str
= sym_escape_string_value(str
);
727 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
731 str
= sym_get_string_value(sym
);
732 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
737 conf_write_heading(FILE *fp
, struct conf_printer
*printer
, void *printer_arg
)
741 snprintf(buf
, sizeof(buf
),
743 "Automatically generated file; DO NOT EDIT.\n"
745 rootmenu
.prompt
->text
);
747 printer
->print_comment(fp
, buf
, printer_arg
);
751 * Write out a minimal config.
752 * All values that has default values are skipped as this is redundant.
754 int conf_write_defconfig(const char *filename
)
760 out
= fopen(filename
, "w");
764 sym_clear_all_valid();
766 /* Traverse all menus to find all relevant symbols */
767 menu
= rootmenu
.list
;
773 if (!menu_is_visible(menu
))
775 } else if (!sym_is_choice(sym
)) {
777 if (!(sym
->flags
& SYMBOL_WRITE
))
779 sym
->flags
&= ~SYMBOL_WRITE
;
780 /* If we cannot change the symbol - skip */
781 if (!sym_is_changeable(sym
))
783 /* If symbol equals to default value - skip */
784 if (strcmp(sym_get_string_value(sym
), sym_get_string_default(sym
)) == 0)
788 * If symbol is a choice value and equals to the
789 * default for a choice - skip.
790 * But only if value is bool and equal to "y" and
791 * choice is not "optional".
792 * (If choice is "optional" then all values can be "n")
794 if (sym_is_choice_value(sym
)) {
798 cs
= prop_get_symbol(sym_get_choice_prop(sym
));
799 ds
= sym_choice_default(cs
);
800 if (!sym_is_optional(cs
) && sym
== ds
) {
801 if ((sym
->type
== S_BOOLEAN
) &&
802 sym_get_tristate_value(sym
) == yes
)
806 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
809 if (menu
->list
!= NULL
) {
812 else if (menu
->next
!= NULL
) {
815 while ((menu
= menu
->parent
)) {
816 if (menu
->next
!= NULL
) {
827 int conf_write(const char *name
)
833 char tmpname
[PATH_MAX
+ 1], oldname
[PATH_MAX
+ 1];
836 bool need_newline
= false;
839 name
= conf_get_configname();
842 fprintf(stderr
, "config name is empty\n");
847 fprintf(stderr
, "%s: Is a directory\n", name
);
851 if (make_parent_dir(name
))
854 env
= getenv("KCONFIG_OVERWRITECONFIG");
857 out
= fopen(name
, "w");
859 snprintf(tmpname
, sizeof(tmpname
), "%s.%d.tmp",
860 name
, (int)getpid());
861 out
= fopen(tmpname
, "w");
866 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
868 if (!conf_get_changed())
869 sym_clear_all_valid();
871 menu
= rootmenu
.list
;
875 if (!menu_is_visible(menu
))
877 str
= menu_get_prompt(menu
);
882 need_newline
= false;
883 } else if (!(sym
->flags
& SYMBOL_CHOICE
) &&
884 !(sym
->flags
& SYMBOL_WRITTEN
)) {
886 if (!(sym
->flags
& SYMBOL_WRITE
))
890 need_newline
= false;
892 sym
->flags
|= SYMBOL_WRITTEN
;
893 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
903 else while ((menu
= menu
->parent
)) {
904 if (!menu
->sym
&& menu_is_visible(menu
) &&
906 str
= menu_get_prompt(menu
);
907 fprintf(out
, "# end of %s\n", str
);
918 for_all_symbols(i
, sym
)
919 sym
->flags
&= ~SYMBOL_WRITTEN
;
922 if (is_same(name
, tmpname
)) {
923 conf_message("No change to %s", name
);
925 sym_set_change_count(0);
929 snprintf(oldname
, sizeof(oldname
), "%s.old", name
);
930 rename(name
, oldname
);
931 if (rename(tmpname
, name
))
935 conf_message("configuration written to %s", name
);
937 sym_set_change_count(0);
942 /* write a dependency file as used by kbuild to track dependencies */
943 static int conf_write_dep(const char *name
)
948 out
= fopen("..config.tmp", "w");
951 fprintf(out
, "deps_config := \\\n");
952 for (file
= file_list
; file
; file
= file
->next
) {
954 fprintf(out
, "\t%s \\\n", file
->name
);
956 fprintf(out
, "\t%s\n", file
->name
);
958 fprintf(out
, "\n%s: \\\n"
959 "\t$(deps_config)\n\n", conf_get_autoconfig_name());
961 env_write_dep(out
, conf_get_autoconfig_name());
963 fprintf(out
, "\n$(deps_config): ;\n");
966 if (make_parent_dir(name
))
968 rename("..config.tmp", name
);
972 static int conf_touch_deps(void)
978 strcpy(depfile_path
, "include/config/");
979 depfile_prefix_len
= strlen(depfile_path
);
981 name
= conf_get_autoconfig_name();
982 conf_read_simple(name
, S_DEF_AUTO
);
983 sym_calc_value(modules_sym
);
985 for_all_symbols(i
, sym
) {
987 if ((sym
->flags
& SYMBOL_NO_WRITE
) || !sym
->name
)
989 if (sym
->flags
& SYMBOL_WRITE
) {
990 if (sym
->flags
& SYMBOL_DEF_AUTO
) {
992 * symbol has old and new value,
998 if (sym_get_tristate_value(sym
) ==
999 sym
->def
[S_DEF_AUTO
].tri
)
1005 if (!strcmp(sym_get_string_value(sym
),
1006 sym
->def
[S_DEF_AUTO
].val
))
1014 * If there is no old value, only 'no' (unset)
1015 * is allowed as new value.
1017 switch (sym
->type
) {
1020 if (sym_get_tristate_value(sym
) == no
)
1027 } else if (!(sym
->flags
& SYMBOL_DEF_AUTO
))
1028 /* There is neither an old nor a new value. */
1031 * There is an old value, but no new value ('no' (unset)
1032 * isn't saved in auto.conf, so the old value is always
1033 * different from 'no').
1036 res
= conf_touch_dep(sym
->name
);
1044 int conf_write_autoconf(int overwrite
)
1048 const char *autoconf_name
= conf_get_autoconfig_name();
1052 #ifndef OPENWRT_DOES_NOT_WANT_THIS
1055 if (!overwrite
&& is_present(autoconf_name
))
1058 conf_write_dep("include/config/auto.conf.cmd");
1060 if (conf_touch_deps())
1063 out
= fopen(".tmpconfig", "w");
1067 out_h
= fopen(".tmpconfig.h", "w");
1073 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
1074 conf_write_heading(out_h
, &header_printer_cb
, NULL
);
1076 for_all_symbols(i
, sym
) {
1077 sym_calc_value(sym
);
1078 if (!(sym
->flags
& SYMBOL_WRITE
) || !sym
->name
)
1081 /* write symbols to auto.conf and autoconf.h */
1082 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, (void *)1);
1083 conf_write_symbol(out_h
, sym
, &header_printer_cb
, NULL
);
1088 name
= getenv("KCONFIG_AUTOHEADER");
1090 name
= "include/generated/autoconf.h";
1091 if (make_parent_dir(name
))
1093 if (rename(".tmpconfig.h", name
))
1096 if (make_parent_dir(autoconf_name
))
1099 * This must be the last step, kbuild has a dependency on auto.conf
1100 * and this marks the successful completion of the previous steps.
1102 if (rename(".tmpconfig", autoconf_name
))
1108 static int sym_change_count
;
1109 static void (*conf_changed_callback
)(void);
1111 void sym_set_change_count(int count
)
1113 int _sym_change_count
= sym_change_count
;
1114 sym_change_count
= count
;
1115 if (conf_changed_callback
&&
1116 (bool)_sym_change_count
!= (bool)count
)
1117 conf_changed_callback();
1120 void sym_add_change_count(int count
)
1122 sym_set_change_count(count
+ sym_change_count
);
1125 bool conf_get_changed(void)
1127 return sym_change_count
;
1130 void conf_set_changed_callback(void (*fn
)(void))
1132 conf_changed_callback
= fn
;
1135 static bool randomize_choice_values(struct symbol
*csym
)
1137 struct property
*prop
;
1143 * If choice is mod then we may have more items selected
1144 * and if no then no-one.
1145 * In both cases stop.
1147 if (csym
->curr
.tri
!= yes
)
1150 prop
= sym_get_choice_prop(csym
);
1152 /* count entries in choice block */
1154 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1158 * find a random value and set it to yes,
1159 * set the rest to no so we have only one set
1161 def
= (rand() % cnt
);
1164 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1166 sym
->def
[S_DEF_USER
].tri
= yes
;
1167 csym
->def
[S_DEF_USER
].val
= sym
;
1170 sym
->def
[S_DEF_USER
].tri
= no
;
1172 sym
->flags
|= SYMBOL_DEF_USER
;
1173 /* clear VALID to get value calculated */
1174 sym
->flags
&= ~SYMBOL_VALID
;
1176 csym
->flags
|= SYMBOL_DEF_USER
;
1177 /* clear VALID to get value calculated */
1178 csym
->flags
&= ~(SYMBOL_VALID
);
1183 void set_all_choice_values(struct symbol
*csym
)
1185 struct property
*prop
;
1189 prop
= sym_get_choice_prop(csym
);
1192 * Set all non-assinged choice values to no
1194 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1195 if (!sym_has_value(sym
))
1196 sym
->def
[S_DEF_USER
].tri
= no
;
1198 csym
->flags
|= SYMBOL_DEF_USER
;
1199 /* clear VALID to get value calculated */
1200 csym
->flags
&= ~(SYMBOL_VALID
| SYMBOL_NEED_SET_CHOICE_VALUES
);
1203 bool conf_set_all_new_symbols(enum conf_def_mode mode
)
1205 struct symbol
*sym
, *csym
;
1206 int i
, cnt
, pby
, pty
, ptm
; /* pby: probability of bool = y
1207 * pty: probability of tristate = y
1208 * ptm: probability of tristate = m
1211 pby
= 50; pty
= ptm
= 33; /* can't go as the default in switch-case
1212 * below, otherwise gcc whines about
1213 * -Wmaybe-uninitialized */
1214 if (mode
== def_random
) {
1216 char *env
= getenv("KCONFIG_PROBABILITY");
1218 while( env
&& *env
) {
1220 int tmp
= strtol( env
, &endp
, 10 );
1221 if( tmp
>= 0 && tmp
<= 100 ) {
1225 perror( "KCONFIG_PROBABILITY" );
1228 env
= (*endp
== ':') ? endp
+1 : endp
;
1235 pby
= p
[0]; ptm
= pby
/2; pty
= pby
-ptm
;
1238 pty
= p
[0]; ptm
= p
[1]; pby
= pty
+ ptm
;
1241 pby
= p
[0]; pty
= p
[1]; ptm
= p
[2];
1245 if( pty
+ptm
> 100 ) {
1247 perror( "KCONFIG_PROBABILITY" );
1251 bool has_changed
= false;
1253 sym_clear_all_valid();
1255 for_all_symbols(i
, sym
) {
1256 if (sym_has_value(sym
) || (sym
->flags
& SYMBOL_VALID
))
1258 switch (sym_get_type(sym
)) {
1264 sym
->def
[S_DEF_USER
].tri
= yes
;
1267 sym
->def
[S_DEF_USER
].tri
= mod
;
1270 if (sym
->flags
& SYMBOL_ALLNOCONFIG_Y
)
1271 sym
->def
[S_DEF_USER
].tri
= yes
;
1273 sym
->def
[S_DEF_USER
].tri
= no
;
1276 sym
->def
[S_DEF_USER
].tri
= no
;
1278 if (sym
->type
== S_TRISTATE
) {
1280 sym
->def
[S_DEF_USER
].tri
= yes
;
1281 else if (cnt
< (pty
+ptm
))
1282 sym
->def
[S_DEF_USER
].tri
= mod
;
1283 } else if (cnt
< pby
)
1284 sym
->def
[S_DEF_USER
].tri
= yes
;
1289 if (!(sym_is_choice(sym
) && mode
== def_random
))
1290 sym
->flags
|= SYMBOL_DEF_USER
;
1299 * We have different type of choice blocks.
1300 * If curr.tri equals to mod then we can select several
1301 * choice symbols in one block.
1302 * In this case we do nothing.
1303 * If curr.tri equals yes then only one symbol can be
1304 * selected in a choice block and we set it to yes,
1305 * and the rest to no.
1307 if (mode
!= def_random
) {
1308 for_all_symbols(i
, csym
) {
1309 if ((sym_is_choice(csym
) && !sym_has_value(csym
)) ||
1310 sym_is_choice_value(csym
))
1311 csym
->flags
|= SYMBOL_NEED_SET_CHOICE_VALUES
;
1315 for_all_symbols(i
, csym
) {
1316 if (sym_has_value(csym
) || !sym_is_choice(csym
))
1319 sym_calc_value(csym
);
1320 if (mode
== def_random
)
1321 has_changed
= randomize_choice_values(csym
);
1323 set_all_choice_values(csym
);
1331 void conf_rewrite_mod_or_yes(enum conf_def_mode mode
)
1335 tristate old_val
= (mode
== def_y2m
) ? yes
: mod
;
1336 tristate new_val
= (mode
== def_y2m
) ? mod
: yes
;
1338 for_all_symbols(i
, sym
) {
1339 if (sym_get_type(sym
) == S_TRISTATE
&&
1340 sym
->def
[S_DEF_USER
].tri
== old_val
) {
1341 sym
->def
[S_DEF_USER
].tri
= new_val
;
1342 sym_add_change_count(1);