2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
20 void (*print_symbol
)(FILE *, struct symbol
*, const char *, void *);
21 void (*print_comment
)(FILE *, const char *, void *);
24 static void conf_warning(const char *fmt
, ...)
25 __attribute__ ((format (printf
, 1, 2)));
27 static void conf_message(const char *fmt
, ...)
28 __attribute__ ((format (printf
, 1, 2)));
30 static const char *conf_filename
;
31 static int conf_lineno
, conf_warnings
, conf_unsaved
;
33 const char conf_defname
[] = "arch/$ARCH/defconfig";
35 static void conf_warning(const char *fmt
, ...)
39 fprintf(stderr
, "%s:%d:warning: ", conf_filename
, conf_lineno
);
40 vfprintf(stderr
, fmt
, ap
);
41 fprintf(stderr
, "\n");
46 static void conf_default_message_callback(const char *fmt
, va_list ap
)
53 static void (*conf_message_callback
) (const char *fmt
, va_list ap
) =
54 conf_default_message_callback
;
55 void conf_set_message_callback(void (*fn
) (const char *fmt
, va_list ap
))
57 conf_message_callback
= fn
;
60 static void conf_message(const char *fmt
, ...)
65 if (conf_message_callback
)
66 conf_message_callback(fmt
, ap
);
70 const char *conf_get_configname(void)
72 char *name
= getenv("KCONFIG_CONFIG");
74 return name
? name
: ".config";
77 const char *conf_get_autoconfig_name(void)
79 char *name
= getenv("KCONFIG_AUTOCONFIG");
81 return name
? name
: "include/config/auto.conf";
84 static char *conf_expand_value(const char *in
)
88 static char res_value
[SYMBOL_MAXLENGTH
];
89 char *dst
, name
[SYMBOL_MAXLENGTH
];
93 while ((src
= strchr(in
, '$'))) {
94 strncat(res_value
, in
, src
- in
);
97 while (isalnum(*src
) || *src
== '_')
100 sym
= sym_lookup(name
, 0);
102 strcat(res_value
, sym_get_string_value(sym
));
105 strcat(res_value
, in
);
110 char *conf_get_default_confname(void)
113 static char fullname
[PATH_MAX
+1];
116 name
= conf_expand_value(conf_defname
);
117 env
= getenv(SRCTREE
);
119 sprintf(fullname
, "%s/%s", env
, name
);
120 if (!stat(fullname
, &buf
))
126 static int conf_set_sym_val(struct symbol
*sym
, int def
, int def_flags
, char *p
)
133 sym
->def
[def
].tri
= mod
;
134 sym
->flags
|= def_flags
;
140 sym
->def
[def
].tri
= yes
;
141 sym
->flags
|= def_flags
;
145 sym
->def
[def
].tri
= no
;
146 sym
->flags
|= def_flags
;
149 if (def
!= S_DEF_AUTO
)
150 conf_warning("symbol value '%s' invalid for %s",
155 for (p2
= p
; *p2
&& !isspace(*p2
); p2
++)
157 sym
->type
= S_STRING
;
164 for (p2
= p
; (p2
= strpbrk(p2
, "\"\\")); p2
++) {
169 memmove(p2
, p2
+ 1, strlen(p2
));
172 if (def
!= S_DEF_AUTO
)
173 conf_warning("invalid string found");
180 if (sym_string_valid(sym
, p
)) {
181 sym
->def
[def
].val
= strdup(p
);
182 sym
->flags
|= def_flags
;
184 if (def
!= S_DEF_AUTO
)
185 conf_warning("symbol value '%s' invalid for %s",
196 #define LINE_GROWTH 16
197 static int add_byte(int c
, char **lineptr
, size_t slen
, size_t *n
)
200 size_t new_size
= slen
+ 1;
202 new_size
+= LINE_GROWTH
- 1;
204 nline
= realloc(*lineptr
, new_size
);
212 (*lineptr
)[slen
] = c
;
217 static ssize_t
compat_getline(char **lineptr
, size_t *n
, FILE *stream
)
219 char *line
= *lineptr
;
223 int c
= getc(stream
);
227 if (add_byte(c
, &line
, slen
, n
) < 0)
232 if (add_byte('\0', &line
, slen
, n
) < 0)
239 if (add_byte(c
, &line
, slen
, n
) < 0)
251 void conf_reset(int def
)
256 def_flags
= SYMBOL_DEF
<< def
;
257 for_all_symbols(i
, sym
) {
258 sym
->flags
|= SYMBOL_CHANGED
;
259 sym
->flags
&= ~(def_flags
|SYMBOL_VALID
);
260 if (sym_is_choice(sym
))
261 sym
->flags
|= def_flags
;
266 if (sym
->def
[def
].val
)
267 free(sym
->def
[def
].val
);
270 sym
->def
[def
].val
= NULL
;
271 sym
->def
[def
].tri
= no
;
276 int conf_read_simple(const char *name
, int def
)
280 size_t line_asize
= 0;
286 in
= zconf_fopen(name
);
288 struct property
*prop
;
290 name
= conf_get_configname();
291 in
= zconf_fopen(name
);
294 sym_add_change_count(1);
295 if (!sym_defconfig_list
)
298 for_all_defaults(sym_defconfig_list
, prop
) {
299 if (expr_calc_value(prop
->visible
.expr
) == no
||
300 prop
->expr
->type
!= E_SYMBOL
)
302 name
= conf_expand_value(prop
->expr
->left
.sym
->name
);
303 in
= zconf_fopen(name
);
305 conf_message(_("using defaults found in %s"),
315 conf_filename
= name
;
320 def_flags
= SYMBOL_DEF
<< def
;
323 while (compat_getline(&line
, &line_asize
, in
) != -1) {
326 if (line
[0] == '#') {
327 if (memcmp(line
+ 2, CONFIG_
, strlen(CONFIG_
)))
329 p
= strchr(line
+ 2 + strlen(CONFIG_
), ' ');
333 if (strncmp(p
, "is not set", 10))
335 if (def
== S_DEF_USER
) {
336 sym
= sym_find(line
+ 2 + strlen(CONFIG_
));
338 sym_add_change_count(1);
342 sym
= sym_lookup(line
+ 2 + strlen(CONFIG_
), 0);
343 if (sym
->type
== S_UNKNOWN
)
344 sym
->type
= S_BOOLEAN
;
349 sym
->def
[def
].tri
= no
;
350 sym
->flags
|= def_flags
;
355 } else if (memcmp(line
, CONFIG_
, strlen(CONFIG_
)) == 0) {
356 p
= strchr(line
+ strlen(CONFIG_
), '=');
360 p2
= strchr(p
, '\n');
366 if (def
== S_DEF_USER
) {
367 sym
= sym_find(line
+ strlen(CONFIG_
));
369 sym_add_change_count(1);
373 sym
= sym_lookup(line
+ strlen(CONFIG_
), 0);
374 if (sym
->type
== S_UNKNOWN
)
377 if (conf_set_sym_val(sym
, def
, def_flags
, p
))
380 if (line
[0] != '\r' && line
[0] != '\n')
381 conf_warning("unexpected data: %.*s",
382 (int)strcspn(line
, "\r\n"), line
);
387 if (sym
&& sym_is_choice_value(sym
)) {
388 struct symbol
*cs
= prop_get_symbol(sym_get_choice_prop(sym
));
389 switch (sym
->def
[def
].tri
) {
393 if (cs
->def
[def
].tri
== yes
) {
394 conf_warning("%s creates inconsistent choice state", sym
->name
);
395 cs
->flags
&= ~def_flags
;
399 if (cs
->def
[def
].tri
!= no
)
400 conf_warning("override: %s changes choice state", sym
->name
);
401 cs
->def
[def
].val
= sym
;
404 cs
->def
[def
].tri
= EXPR_OR(cs
->def
[def
].tri
, sym
->def
[def
].tri
);
412 int conf_read(const char *name
)
417 sym_set_change_count(0);
419 if (conf_read_simple(name
, S_DEF_USER
)) {
420 sym_calc_value(modules_sym
);
424 sym_calc_value(modules_sym
);
426 for_all_symbols(i
, sym
) {
428 if (sym_is_choice(sym
) || (sym
->flags
& SYMBOL_AUTO
))
430 if (sym_has_value(sym
) && (sym
->flags
& SYMBOL_WRITE
)) {
431 /* check that calculated value agrees with saved value */
435 if (sym
->def
[S_DEF_USER
].tri
!= sym_get_tristate_value(sym
))
437 if (!sym_is_choice(sym
))
441 if (!strcmp(sym
->curr
.val
, sym
->def
[S_DEF_USER
].val
))
445 } else if (!sym_has_value(sym
) && !(sym
->flags
& SYMBOL_WRITE
))
446 /* no previous value and not saved */
449 /* maybe print value in verbose mode... */
452 for_all_symbols(i
, sym
) {
453 if (sym_has_value(sym
) && !sym_is_choice_value(sym
)) {
454 /* Reset values of generates values, so they'll appear
455 * as new, if they should become visible, but that
456 * doesn't quite work if the Kconfig and the saved
457 * configuration disagree.
459 if (sym
->visible
== no
&& !conf_unsaved
)
460 sym
->flags
&= ~SYMBOL_DEF_USER
;
465 /* Reset a string value if it's out of range */
466 if (sym_string_within_range(sym
, sym
->def
[S_DEF_USER
].val
))
468 sym
->flags
&= ~(SYMBOL_VALID
|SYMBOL_DEF_USER
);
477 sym_add_change_count(conf_warnings
|| conf_unsaved
);
483 * Kconfig configuration printer
485 * This printer is used when generating the resulting configuration after
486 * kconfig invocation and `defconfig' files. Unset symbol might be omitted by
487 * passing a non-NULL argument to the printer.
491 kconfig_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
498 bool skip_unset
= (arg
!= NULL
);
501 fprintf(fp
, "# %s%s is not set\n",
510 fprintf(fp
, "%s%s=%s\n", CONFIG_
, sym
->name
, value
);
514 kconfig_print_comment(FILE *fp
, const char *value
, void *arg
)
516 const char *p
= value
;
520 l
= strcspn(p
, "\n");
524 xfwrite(p
, l
, 1, fp
);
533 static struct conf_printer kconfig_printer_cb
=
535 .print_symbol
= kconfig_print_symbol
,
536 .print_comment
= kconfig_print_comment
,
542 * This printer is used when generating the `include/generated/autoconf.h' file.
545 header_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
551 const char *suffix
= "";
560 fprintf(fp
, "#define %s%s%s 1\n",
561 CONFIG_
, sym
->name
, suffix
);
566 const char *prefix
= "";
568 if (value
[0] != '0' || (value
[1] != 'x' && value
[1] != 'X'))
570 fprintf(fp
, "#define %s%s %s%s\n",
571 CONFIG_
, sym
->name
, prefix
, value
);
576 fprintf(fp
, "#define %s%s %s\n",
577 CONFIG_
, sym
->name
, value
);
586 header_print_comment(FILE *fp
, const char *value
, void *arg
)
588 const char *p
= value
;
593 l
= strcspn(p
, "\n");
597 xfwrite(p
, l
, 1, fp
);
604 fprintf(fp
, " */\n");
607 static struct conf_printer header_printer_cb
=
609 .print_symbol
= header_print_symbol
,
610 .print_comment
= header_print_comment
,
616 * This printer is used when generating the `include/config/tristate.conf' file.
619 tristate_print_symbol(FILE *fp
, struct symbol
*sym
, const char *value
, void *arg
)
622 if (sym
->type
== S_TRISTATE
&& *value
!= 'n')
623 fprintf(fp
, "%s%s=%c\n", CONFIG_
, sym
->name
, (char)toupper(*value
));
626 static struct conf_printer tristate_printer_cb
=
628 .print_symbol
= tristate_print_symbol
,
629 .print_comment
= kconfig_print_comment
,
632 static void conf_write_symbol(FILE *fp
, struct symbol
*sym
,
633 struct conf_printer
*printer
, void *printer_arg
)
642 str
= sym_get_string_value(sym
);
643 str
= sym_escape_string_value(str
);
644 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
648 str
= sym_get_string_value(sym
);
649 printer
->print_symbol(fp
, sym
, str
, printer_arg
);
654 conf_write_heading(FILE *fp
, struct conf_printer
*printer
, void *printer_arg
)
658 snprintf(buf
, sizeof(buf
),
660 "Automatically generated file; DO NOT EDIT.\n"
662 rootmenu
.prompt
->text
);
664 printer
->print_comment(fp
, buf
, printer_arg
);
668 * Write out a minimal config.
669 * All values that has default values are skipped as this is redundant.
671 int conf_write_defconfig(const char *filename
)
677 out
= fopen(filename
, "w");
681 sym_clear_all_valid();
683 /* Traverse all menus to find all relevant symbols */
684 menu
= rootmenu
.list
;
690 if (!menu_is_visible(menu
))
692 } else if (!sym_is_choice(sym
)) {
694 if (!(sym
->flags
& SYMBOL_WRITE
))
696 sym
->flags
&= ~SYMBOL_WRITE
;
697 /* If we cannot change the symbol - skip */
698 if (!sym_is_changable(sym
))
700 /* If symbol equals to default value - skip */
701 if (strcmp(sym_get_string_value(sym
), sym_get_string_default(sym
)) == 0)
705 * If symbol is a choice value and equals to the
706 * default for a choice - skip.
707 * But only if value is bool and equal to "y" and
708 * choice is not "optional".
709 * (If choice is "optional" then all values can be "n")
711 if (sym_is_choice_value(sym
)) {
715 cs
= prop_get_symbol(sym_get_choice_prop(sym
));
716 ds
= sym_choice_default(cs
);
717 if (!sym_is_optional(cs
) && sym
== ds
) {
718 if ((sym
->type
== S_BOOLEAN
) &&
719 sym_get_tristate_value(sym
) == yes
)
723 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
726 if (menu
->list
!= NULL
) {
729 else if (menu
->next
!= NULL
) {
732 while ((menu
= menu
->parent
)) {
733 if (menu
->next
!= NULL
) {
744 int conf_write(const char *name
)
749 const char *basename
;
751 char dirname
[PATH_MAX
+1], tmpname
[PATH_MAX
+1], newname
[PATH_MAX
+1];
755 if (name
&& name
[0]) {
759 if (!stat(name
, &st
) && S_ISDIR(st
.st_mode
)) {
760 strcpy(dirname
, name
);
761 strcat(dirname
, "/");
762 basename
= conf_get_configname();
763 } else if ((slash
= strrchr(name
, '/'))) {
764 int size
= slash
- name
+ 1;
765 memcpy(dirname
, name
, size
);
768 basename
= slash
+ 1;
770 basename
= conf_get_configname();
774 basename
= conf_get_configname();
776 sprintf(newname
, "%s%s", dirname
, basename
);
777 env
= getenv("KCONFIG_OVERWRITECONFIG");
779 sprintf(tmpname
, "%s.tmpconfig.%d", dirname
, (int)getpid());
780 out
= fopen(tmpname
, "w");
783 out
= fopen(newname
, "w");
788 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
790 if (!conf_get_changed())
791 sym_clear_all_valid();
793 menu
= rootmenu
.list
;
797 if (!menu_is_visible(menu
))
799 str
= menu_get_prompt(menu
);
804 } else if (!(sym
->flags
& SYMBOL_CHOICE
)) {
806 if (!(sym
->flags
& SYMBOL_WRITE
))
808 sym
->flags
&= ~SYMBOL_WRITE
;
810 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, NULL
);
820 else while ((menu
= menu
->parent
)) {
830 strcat(dirname
, basename
);
831 strcat(dirname
, ".old");
832 rename(newname
, dirname
);
833 if (rename(tmpname
, newname
))
837 conf_message(_("configuration written to %s"), newname
);
839 sym_set_change_count(0);
844 static int conf_split_config(void)
847 char path
[PATH_MAX
+1];
853 name
= conf_get_autoconfig_name();
854 conf_read_simple(name
, S_DEF_AUTO
);
855 sym_calc_value(modules_sym
);
857 if (chdir("include/config"))
861 for_all_symbols(i
, sym
) {
863 if ((sym
->flags
& SYMBOL_AUTO
) || !sym
->name
)
865 if (sym
->flags
& SYMBOL_WRITE
) {
866 if (sym
->flags
& SYMBOL_DEF_AUTO
) {
868 * symbol has old and new value,
874 if (sym_get_tristate_value(sym
) ==
875 sym
->def
[S_DEF_AUTO
].tri
)
881 if (!strcmp(sym_get_string_value(sym
),
882 sym
->def
[S_DEF_AUTO
].val
))
890 * If there is no old value, only 'no' (unset)
891 * is allowed as new value.
896 if (sym_get_tristate_value(sym
) == no
)
903 } else if (!(sym
->flags
& SYMBOL_DEF_AUTO
))
904 /* There is neither an old nor a new value. */
907 * There is an old value, but no new value ('no' (unset)
908 * isn't saved in auto.conf, so the old value is always
909 * different from 'no').
912 /* Replace all '_' and append ".h" */
917 *d
++ = (c
== '_') ? '/' : c
;
921 /* Assume directory path already exists. */
922 fd
= open(path
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0644);
924 if (errno
!= ENOENT
) {
929 * Create directory components,
930 * unless they exist already.
933 while ((d
= strchr(d
, '/'))) {
935 if (stat(path
, &sb
) && mkdir(path
, 0755)) {
942 fd
= open(path
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0644);
957 int conf_write_autoconf(void)
961 FILE *out
, *tristate
, *out_h
;
964 sym_clear_all_valid();
966 file_write_dep("include/config/auto.conf.cmd");
968 if (conf_split_config())
971 out
= fopen(".tmpconfig", "w");
975 tristate
= fopen(".tmpconfig_tristate", "w");
981 out_h
= fopen(".tmpconfig.h", "w");
988 conf_write_heading(out
, &kconfig_printer_cb
, NULL
);
990 conf_write_heading(tristate
, &tristate_printer_cb
, NULL
);
992 conf_write_heading(out_h
, &header_printer_cb
, NULL
);
994 for_all_symbols(i
, sym
) {
996 if (!(sym
->flags
& SYMBOL_WRITE
) || !sym
->name
)
999 /* write symbol to auto.conf, tristate and header files */
1000 conf_write_symbol(out
, sym
, &kconfig_printer_cb
, (void *)1);
1002 conf_write_symbol(tristate
, sym
, &tristate_printer_cb
, (void *)1);
1004 conf_write_symbol(out_h
, sym
, &header_printer_cb
, NULL
);
1010 name
= getenv("KCONFIG_AUTOHEADER");
1012 name
= "include/generated/autoconf.h";
1013 if (rename(".tmpconfig.h", name
))
1015 name
= getenv("KCONFIG_TRISTATE");
1017 name
= "include/config/tristate.conf";
1018 if (rename(".tmpconfig_tristate", name
))
1020 name
= conf_get_autoconfig_name();
1022 * This must be the last step, kbuild has a dependency on auto.conf
1023 * and this marks the successful completion of the previous steps.
1025 if (rename(".tmpconfig", name
))
1031 static int sym_change_count
;
1032 static void (*conf_changed_callback
)(void);
1034 void sym_set_change_count(int count
)
1036 int _sym_change_count
= sym_change_count
;
1037 sym_change_count
= count
;
1038 if (conf_changed_callback
&&
1039 (bool)_sym_change_count
!= (bool)count
)
1040 conf_changed_callback();
1043 void sym_add_change_count(int count
)
1045 sym_set_change_count(count
+ sym_change_count
);
1048 bool conf_get_changed(void)
1050 return sym_change_count
;
1053 void conf_set_changed_callback(void (*fn
)(void))
1055 conf_changed_callback
= fn
;
1058 static bool randomize_choice_values(struct symbol
*csym
)
1060 struct property
*prop
;
1066 * If choice is mod then we may have more items selected
1067 * and if no then no-one.
1068 * In both cases stop.
1070 if (csym
->curr
.tri
!= yes
)
1073 prop
= sym_get_choice_prop(csym
);
1075 /* count entries in choice block */
1077 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1081 * find a random value and set it to yes,
1082 * set the rest to no so we have only one set
1084 def
= (rand() % cnt
);
1087 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1089 sym
->def
[S_DEF_USER
].tri
= yes
;
1090 csym
->def
[S_DEF_USER
].val
= sym
;
1093 sym
->def
[S_DEF_USER
].tri
= no
;
1095 sym
->flags
|= SYMBOL_DEF_USER
;
1096 /* clear VALID to get value calculated */
1097 sym
->flags
&= ~SYMBOL_VALID
;
1099 csym
->flags
|= SYMBOL_DEF_USER
;
1100 /* clear VALID to get value calculated */
1101 csym
->flags
&= ~(SYMBOL_VALID
);
1106 void set_all_choice_values(struct symbol
*csym
)
1108 struct property
*prop
;
1112 prop
= sym_get_choice_prop(csym
);
1115 * Set all non-assinged choice values to no
1117 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1118 if (!sym_has_value(sym
))
1119 sym
->def
[S_DEF_USER
].tri
= no
;
1121 csym
->flags
|= SYMBOL_DEF_USER
;
1122 /* clear VALID to get value calculated */
1123 csym
->flags
&= ~(SYMBOL_VALID
| SYMBOL_NEED_SET_CHOICE_VALUES
);
1126 bool conf_set_all_new_symbols(enum conf_def_mode mode
)
1128 struct symbol
*sym
, *csym
;
1129 int i
, cnt
, pby
, pty
, ptm
; /* pby: probability of boolean = y
1130 * pty: probability of tristate = y
1131 * ptm: probability of tristate = m
1134 pby
= 50; pty
= ptm
= 33; /* can't go as the default in switch-case
1135 * below, otherwise gcc whines about
1136 * -Wmaybe-uninitialized */
1137 if (mode
== def_random
) {
1139 char *env
= getenv("KCONFIG_PROBABILITY");
1141 while( env
&& *env
) {
1143 int tmp
= strtol( env
, &endp
, 10 );
1144 if( tmp
>= 0 && tmp
<= 100 ) {
1148 perror( "KCONFIG_PROBABILITY" );
1151 env
= (*endp
== ':') ? endp
+1 : endp
;
1158 pby
= p
[0]; ptm
= pby
/2; pty
= pby
-ptm
;
1161 pty
= p
[0]; ptm
= p
[1]; pby
= pty
+ ptm
;
1164 pby
= p
[0]; pty
= p
[1]; ptm
= p
[2];
1168 if( pty
+ptm
> 100 ) {
1170 perror( "KCONFIG_PROBABILITY" );
1174 bool has_changed
= false;
1176 sym_clear_all_valid();
1178 for_all_symbols(i
, sym
) {
1179 if (sym_has_value(sym
) || (sym
->flags
& SYMBOL_VALID
))
1181 switch (sym_get_type(sym
)) {
1187 sym
->def
[S_DEF_USER
].tri
= yes
;
1190 sym
->def
[S_DEF_USER
].tri
= mod
;
1193 if (sym
->flags
& SYMBOL_ALLNOCONFIG_Y
)
1194 sym
->def
[S_DEF_USER
].tri
= yes
;
1196 sym
->def
[S_DEF_USER
].tri
= no
;
1199 sym
->def
[S_DEF_USER
].tri
= no
;
1201 if (sym
->type
== S_TRISTATE
) {
1203 sym
->def
[S_DEF_USER
].tri
= yes
;
1204 else if (cnt
< (pty
+ptm
))
1205 sym
->def
[S_DEF_USER
].tri
= mod
;
1206 } else if (cnt
< pby
)
1207 sym
->def
[S_DEF_USER
].tri
= yes
;
1212 if (!(sym_is_choice(sym
) && mode
== def_random
))
1213 sym
->flags
|= SYMBOL_DEF_USER
;
1222 * We have different type of choice blocks.
1223 * If curr.tri equals to mod then we can select several
1224 * choice symbols in one block.
1225 * In this case we do nothing.
1226 * If curr.tri equals yes then only one symbol can be
1227 * selected in a choice block and we set it to yes,
1228 * and the rest to no.
1230 if (mode
!= def_random
) {
1231 for_all_symbols(i
, csym
) {
1232 if ((sym_is_choice(csym
) && !sym_has_value(csym
)) ||
1233 sym_is_choice_value(csym
))
1234 csym
->flags
|= SYMBOL_NEED_SET_CHOICE_VALUES
;
1238 for_all_symbols(i
, csym
) {
1239 if (sym_has_value(csym
) || !sym_is_choice(csym
))
1242 sym_calc_value(csym
);
1243 if (mode
== def_random
)
1244 has_changed
= randomize_choice_values(csym
);
1246 set_all_choice_values(csym
);