1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
10 #include <sys/utsname.h>
14 struct symbol symbol_yes
= {
17 .flags
= SYMBOL_CONST
|SYMBOL_VALID
,
21 .flags
= SYMBOL_CONST
|SYMBOL_VALID
,
25 .flags
= SYMBOL_CONST
|SYMBOL_VALID
,
29 .flags
= SYMBOL_VALID
,
32 struct symbol
*sym_defconfig_list
;
33 struct symbol
*modules_sym
;
36 enum symbol_type
sym_get_type(struct symbol
*sym
)
38 enum symbol_type type
= sym
->type
;
40 if (type
== S_TRISTATE
) {
41 if (sym_is_choice_value(sym
) && sym
->visible
== yes
)
43 else if (modules_val
== no
)
49 const char *sym_type_name(enum symbol_type type
)
68 struct property
*sym_get_choice_prop(struct symbol
*sym
)
70 struct property
*prop
;
72 for_all_choices(sym
, prop
)
77 static struct property
*sym_get_default_prop(struct symbol
*sym
)
79 struct property
*prop
;
81 for_all_defaults(sym
, prop
) {
82 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
83 if (prop
->visible
.tri
!= no
)
89 struct property
*sym_get_range_prop(struct symbol
*sym
)
91 struct property
*prop
;
93 for_all_properties(sym
, prop
, P_RANGE
) {
94 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
95 if (prop
->visible
.tri
!= no
)
101 static long long sym_get_range_val(struct symbol
*sym
, int base
)
114 return strtoll(sym
->curr
.val
, NULL
, base
);
117 static void sym_validate_range(struct symbol
*sym
)
119 struct property
*prop
;
134 prop
= sym_get_range_prop(sym
);
137 val
= strtoll(sym
->curr
.val
, NULL
, base
);
138 val2
= sym_get_range_val(prop
->expr
->left
.sym
, base
);
140 val2
= sym_get_range_val(prop
->expr
->right
.sym
, base
);
144 if (sym
->type
== S_INT
)
145 sprintf(str
, "%lld", val2
);
147 sprintf(str
, "0x%llx", val2
);
148 sym
->curr
.val
= xstrdup(str
);
151 static void sym_set_changed(struct symbol
*sym
)
153 struct property
*prop
;
155 sym
->flags
|= SYMBOL_CHANGED
;
156 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
158 prop
->menu
->flags
|= MENU_CHANGED
;
162 static void sym_set_all_changed(void)
167 for_all_symbols(i
, sym
)
168 sym_set_changed(sym
);
171 static void sym_calc_visibility(struct symbol
*sym
)
173 struct property
*prop
;
174 struct symbol
*choice_sym
= NULL
;
177 /* any prompt visible? */
180 if (sym_is_choice_value(sym
))
181 choice_sym
= prop_get_symbol(sym_get_choice_prop(sym
));
183 for_all_prompts(sym
, prop
) {
184 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
186 * Tristate choice_values with visibility 'mod' are
187 * not visible if the corresponding choice's value is
190 if (choice_sym
&& sym
->type
== S_TRISTATE
&&
191 prop
->visible
.tri
== mod
&& choice_sym
->curr
.tri
== yes
)
192 prop
->visible
.tri
= no
;
194 tri
= EXPR_OR(tri
, prop
->visible
.tri
);
196 if (tri
== mod
&& (sym
->type
!= S_TRISTATE
|| modules_val
== no
))
198 if (sym
->visible
!= tri
) {
200 sym_set_changed(sym
);
202 if (sym_is_choice_value(sym
))
204 /* defaulting to "yes" if no explicit "depends on" are given */
206 if (sym
->dir_dep
.expr
)
207 tri
= expr_calc_value(sym
->dir_dep
.expr
);
208 if (tri
== mod
&& sym_get_type(sym
) == S_BOOLEAN
)
210 if (sym
->dir_dep
.tri
!= tri
) {
211 sym
->dir_dep
.tri
= tri
;
212 sym_set_changed(sym
);
215 if (sym
->rev_dep
.expr
)
216 tri
= expr_calc_value(sym
->rev_dep
.expr
);
217 if (tri
== mod
&& sym_get_type(sym
) == S_BOOLEAN
)
219 if (sym
->rev_dep
.tri
!= tri
) {
220 sym
->rev_dep
.tri
= tri
;
221 sym_set_changed(sym
);
224 if (sym
->implied
.expr
&& sym
->dir_dep
.tri
!= no
)
225 tri
= expr_calc_value(sym
->implied
.expr
);
226 if (tri
== mod
&& sym_get_type(sym
) == S_BOOLEAN
)
228 if (sym
->implied
.tri
!= tri
) {
229 sym
->implied
.tri
= tri
;
230 sym_set_changed(sym
);
235 * Find the default symbol for a choice.
236 * First try the default values for the choice symbol
237 * Next locate the first visible choice value
238 * Return NULL if none was found
240 struct symbol
*sym_choice_default(struct symbol
*sym
)
242 struct symbol
*def_sym
;
243 struct property
*prop
;
246 /* any of the defaults visible? */
247 for_all_defaults(sym
, prop
) {
248 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
249 if (prop
->visible
.tri
== no
)
251 def_sym
= prop_get_symbol(prop
);
252 if (def_sym
->visible
!= no
)
256 /* just get the first visible value */
257 prop
= sym_get_choice_prop(sym
);
258 expr_list_for_each_sym(prop
->expr
, e
, def_sym
)
259 if (def_sym
->visible
!= no
)
262 /* failed to locate any defaults */
266 static struct symbol
*sym_calc_choice(struct symbol
*sym
)
268 struct symbol
*def_sym
;
269 struct property
*prop
;
273 /* first calculate all choice values' visibilities */
275 prop
= sym_get_choice_prop(sym
);
276 expr_list_for_each_sym(prop
->expr
, e
, def_sym
) {
277 sym_calc_visibility(def_sym
);
278 if (def_sym
->visible
!= no
)
279 flags
&= def_sym
->flags
;
282 sym
->flags
&= flags
| ~SYMBOL_DEF_USER
;
284 /* is the user choice visible? */
285 def_sym
= sym
->def
[S_DEF_USER
].val
;
286 if (def_sym
&& def_sym
->visible
!= no
)
289 def_sym
= sym_choice_default(sym
);
292 /* no choice? reset tristate value */
298 void sym_calc_value(struct symbol
*sym
)
300 struct symbol_value newval
, oldval
;
301 struct property
*prop
;
307 if (sym
->flags
& SYMBOL_VALID
)
310 if (sym_is_choice_value(sym
) &&
311 sym
->flags
& SYMBOL_NEED_SET_CHOICE_VALUES
) {
312 sym
->flags
&= ~SYMBOL_NEED_SET_CHOICE_VALUES
;
313 prop
= sym_get_choice_prop(sym
);
314 sym_calc_value(prop_get_symbol(prop
));
317 sym
->flags
|= SYMBOL_VALID
;
325 newval
= symbol_empty
.curr
;
329 newval
= symbol_no
.curr
;
332 sym
->curr
.val
= sym
->name
;
336 sym
->flags
&= ~SYMBOL_WRITE
;
338 sym_calc_visibility(sym
);
340 if (sym
->visible
!= no
)
341 sym
->flags
|= SYMBOL_WRITE
;
343 /* set default if recursively called */
346 switch (sym_get_type(sym
)) {
349 if (sym_is_choice_value(sym
) && sym
->visible
== yes
) {
350 prop
= sym_get_choice_prop(sym
);
351 newval
.tri
= (prop_get_symbol(prop
)->curr
.val
== sym
) ? yes
: no
;
353 if (sym
->visible
!= no
) {
354 /* if the symbol is visible use the user value
355 * if available, otherwise try the default value
357 if (sym_has_value(sym
)) {
358 newval
.tri
= EXPR_AND(sym
->def
[S_DEF_USER
].tri
,
363 if (sym
->rev_dep
.tri
!= no
)
364 sym
->flags
|= SYMBOL_WRITE
;
365 if (!sym_is_choice(sym
)) {
366 prop
= sym_get_default_prop(sym
);
368 sym
->flags
|= SYMBOL_WRITE
;
369 newval
.tri
= EXPR_AND(expr_calc_value(prop
->expr
),
372 if (sym
->implied
.tri
!= no
) {
373 sym
->flags
|= SYMBOL_WRITE
;
374 newval
.tri
= EXPR_OR(newval
.tri
, sym
->implied
.tri
);
378 if (sym
->dir_dep
.tri
< sym
->rev_dep
.tri
) {
381 newval
.tri
= EXPR_OR(newval
.tri
, sym
->rev_dep
.tri
);
384 if (newval
.tri
== mod
&&
385 (sym_get_type(sym
) == S_BOOLEAN
|| sym
->implied
.tri
== yes
))
391 if (sym
->visible
!= no
&& sym_has_value(sym
)) {
392 newval
.val
= sym
->def
[S_DEF_USER
].val
;
395 prop
= sym_get_default_prop(sym
);
397 struct symbol
*ds
= prop_get_symbol(prop
);
399 sym
->flags
|= SYMBOL_WRITE
;
401 newval
.val
= ds
->curr
.val
;
410 if (sym_is_choice(sym
) && newval
.tri
== yes
)
411 sym
->curr
.val
= sym_calc_choice(sym
);
412 sym_validate_range(sym
);
414 if (memcmp(&oldval
, &sym
->curr
, sizeof(oldval
))) {
415 sym_set_changed(sym
);
416 if (modules_sym
== sym
) {
417 sym_set_all_changed();
418 modules_val
= modules_sym
->curr
.tri
;
422 if (sym_is_choice(sym
)) {
423 struct symbol
*choice_sym
;
425 prop
= sym_get_choice_prop(sym
);
426 expr_list_for_each_sym(prop
->expr
, e
, choice_sym
) {
427 if ((sym
->flags
& SYMBOL_WRITE
) &&
428 choice_sym
->visible
!= no
)
429 choice_sym
->flags
|= SYMBOL_WRITE
;
430 if (sym
->flags
& SYMBOL_CHANGED
)
431 sym_set_changed(choice_sym
);
435 if (sym
->flags
& SYMBOL_NO_WRITE
)
436 sym
->flags
&= ~SYMBOL_WRITE
;
438 if (sym
->flags
& SYMBOL_NEED_SET_CHOICE_VALUES
)
439 set_all_choice_values(sym
);
442 void sym_clear_all_valid(void)
447 for_all_symbols(i
, sym
)
448 sym
->flags
&= ~SYMBOL_VALID
;
449 sym_add_change_count(1);
450 sym_calc_value(modules_sym
);
453 bool sym_tristate_within_range(struct symbol
*sym
, tristate val
)
455 int type
= sym_get_type(sym
);
457 if (sym
->visible
== no
)
460 if (type
!= S_BOOLEAN
&& type
!= S_TRISTATE
)
463 if (type
== S_BOOLEAN
&& val
== mod
)
465 if (sym
->visible
<= sym
->rev_dep
.tri
)
467 if (sym
->implied
.tri
== yes
&& val
== mod
)
469 if (sym_is_choice_value(sym
) && sym
->visible
== yes
)
471 return val
>= sym
->rev_dep
.tri
&& val
<= sym
->visible
;
474 bool sym_set_tristate_value(struct symbol
*sym
, tristate val
)
476 tristate oldval
= sym_get_tristate_value(sym
);
478 if (oldval
!= val
&& !sym_tristate_within_range(sym
, val
))
481 if (!(sym
->flags
& SYMBOL_DEF_USER
)) {
482 sym
->flags
|= SYMBOL_DEF_USER
;
483 sym_set_changed(sym
);
486 * setting a choice value also resets the new flag of the choice
487 * symbol and all other choice values.
489 if (sym_is_choice_value(sym
) && val
== yes
) {
490 struct symbol
*cs
= prop_get_symbol(sym_get_choice_prop(sym
));
491 struct property
*prop
;
494 cs
->def
[S_DEF_USER
].val
= sym
;
495 cs
->flags
|= SYMBOL_DEF_USER
;
496 prop
= sym_get_choice_prop(cs
);
497 for (e
= prop
->expr
; e
; e
= e
->left
.expr
) {
498 if (e
->right
.sym
->visible
!= no
)
499 e
->right
.sym
->flags
|= SYMBOL_DEF_USER
;
503 sym
->def
[S_DEF_USER
].tri
= val
;
505 sym_clear_all_valid();
510 tristate
sym_toggle_tristate_value(struct symbol
*sym
)
512 tristate oldval
, newval
;
514 oldval
= newval
= sym_get_tristate_value(sym
);
527 if (sym_set_tristate_value(sym
, newval
))
529 } while (oldval
!= newval
);
533 bool sym_string_valid(struct symbol
*sym
, const char *str
)
546 if (ch
== '0' && *str
!= 0)
548 while ((ch
= *str
++)) {
554 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
560 } while ((ch
= *str
++));
576 bool sym_string_within_range(struct symbol
*sym
, const char *str
)
578 struct property
*prop
;
583 return sym_string_valid(sym
, str
);
585 if (!sym_string_valid(sym
, str
))
587 prop
= sym_get_range_prop(sym
);
590 val
= strtoll(str
, NULL
, 10);
591 return val
>= sym_get_range_val(prop
->expr
->left
.sym
, 10) &&
592 val
<= sym_get_range_val(prop
->expr
->right
.sym
, 10);
594 if (!sym_string_valid(sym
, str
))
596 prop
= sym_get_range_prop(sym
);
599 val
= strtoll(str
, NULL
, 16);
600 return val
>= sym_get_range_val(prop
->expr
->left
.sym
, 16) &&
601 val
<= sym_get_range_val(prop
->expr
->right
.sym
, 16);
606 return sym_tristate_within_range(sym
, yes
);
608 return sym_tristate_within_range(sym
, mod
);
610 return sym_tristate_within_range(sym
, no
);
618 bool sym_set_string_value(struct symbol
*sym
, const char *newval
)
629 return sym_set_tristate_value(sym
, yes
);
631 return sym_set_tristate_value(sym
, mod
);
633 return sym_set_tristate_value(sym
, no
);
640 if (!sym_string_within_range(sym
, newval
))
643 if (!(sym
->flags
& SYMBOL_DEF_USER
)) {
644 sym
->flags
|= SYMBOL_DEF_USER
;
645 sym_set_changed(sym
);
648 oldval
= sym
->def
[S_DEF_USER
].val
;
649 size
= strlen(newval
) + 1;
650 if (sym
->type
== S_HEX
&& (newval
[0] != '0' || (newval
[1] != 'x' && newval
[1] != 'X'))) {
652 sym
->def
[S_DEF_USER
].val
= val
= xmalloc(size
);
655 } else if (!oldval
|| strcmp(oldval
, newval
))
656 sym
->def
[S_DEF_USER
].val
= val
= xmalloc(size
);
661 free((void *)oldval
);
662 sym_clear_all_valid();
668 * Find the default value associated to a symbol.
669 * For tristate symbol handle the modules=n case
670 * in which case "m" becomes "y".
671 * If the symbol does not have any default then fallback
672 * to the fixed default values.
674 const char *sym_get_string_default(struct symbol
*sym
)
676 struct property
*prop
;
681 sym_calc_visibility(sym
);
682 sym_calc_value(modules_sym
);
683 val
= symbol_no
.curr
.tri
;
684 str
= symbol_empty
.curr
.val
;
686 /* If symbol has a default value look it up */
687 prop
= sym_get_default_prop(sym
);
692 /* The visibility may limit the value from yes => mod */
693 val
= EXPR_AND(expr_calc_value(prop
->expr
), prop
->visible
.tri
);
697 * The following fails to handle the situation
698 * where a default value is further limited by
701 ds
= prop_get_symbol(prop
);
704 str
= (const char *)ds
->curr
.val
;
709 /* Handle select statements */
710 val
= EXPR_OR(val
, sym
->rev_dep
.tri
);
712 /* transpose mod to yes if modules are not enabled */
714 if (!sym_is_choice_value(sym
) && modules_sym
->curr
.tri
== no
)
717 /* transpose mod to yes if type is bool */
718 if (sym
->type
== S_BOOLEAN
&& val
== mod
)
721 /* adjust the default value if this symbol is implied by another */
722 if (val
< sym
->implied
.tri
)
723 val
= sym
->implied
.tri
;
730 case mod
: return "m";
731 case yes
: return "y";
744 const char *sym_get_string_value(struct symbol
*sym
)
751 val
= sym_get_tristate_value(sym
);
756 sym_calc_value(modules_sym
);
757 return (modules_sym
->curr
.tri
== no
) ? "n" : "m";
765 return (const char *)sym
->curr
.val
;
768 bool sym_is_changeable(struct symbol
*sym
)
770 return sym
->visible
> sym
->rev_dep
.tri
;
773 static unsigned strhash(const char *s
)
776 unsigned hash
= 2166136261U;
778 hash
= (hash
^ *s
) * 0x01000193;
782 struct symbol
*sym_lookup(const char *name
, int flags
)
784 struct symbol
*symbol
;
789 if (name
[0] && !name
[1]) {
791 case 'y': return &symbol_yes
;
792 case 'm': return &symbol_mod
;
793 case 'n': return &symbol_no
;
796 hash
= strhash(name
) % SYMBOL_HASHSIZE
;
798 for (symbol
= symbol_hash
[hash
]; symbol
; symbol
= symbol
->next
) {
800 !strcmp(symbol
->name
, name
) &&
801 (flags
? symbol
->flags
& flags
802 : !(symbol
->flags
& (SYMBOL_CONST
|SYMBOL_CHOICE
))))
805 new_name
= xstrdup(name
);
811 symbol
= xmalloc(sizeof(*symbol
));
812 memset(symbol
, 0, sizeof(*symbol
));
813 symbol
->name
= new_name
;
814 symbol
->type
= S_UNKNOWN
;
815 symbol
->flags
|= flags
;
817 symbol
->next
= symbol_hash
[hash
];
818 symbol_hash
[hash
] = symbol
;
823 struct symbol
*sym_find(const char *name
)
825 struct symbol
*symbol
= NULL
;
831 if (name
[0] && !name
[1]) {
833 case 'y': return &symbol_yes
;
834 case 'm': return &symbol_mod
;
835 case 'n': return &symbol_no
;
838 hash
= strhash(name
) % SYMBOL_HASHSIZE
;
840 for (symbol
= symbol_hash
[hash
]; symbol
; symbol
= symbol
->next
) {
842 !strcmp(symbol
->name
, name
) &&
843 !(symbol
->flags
& SYMBOL_CONST
))
850 const char *sym_escape_string_value(const char *in
)
857 reslen
= strlen(in
) + strlen("\"\"") + 1;
861 l
= strcspn(p
, "\"\\");
871 res
= xmalloc(reslen
);
878 l
= strcspn(p
, "\"\\");
886 strncat(res
, p
++, 1);
898 /* Compare matched symbols as thus:
899 * - first, symbols that match exactly
900 * - then, alphabetical sort
902 static int sym_rel_comp(const void *sym1
, const void *sym2
)
904 const struct sym_match
*s1
= sym1
;
905 const struct sym_match
*s2
= sym2
;
909 * - if matched length on symbol s1 is the length of that symbol,
910 * then this symbol should come first;
911 * - if matched length on symbol s2 is the length of that symbol,
912 * then this symbol should come first.
913 * Note: since the search can be a regexp, both symbols may match
914 * exactly; if this is the case, we can't decide which comes first,
915 * and we fallback to sorting alphabetically.
917 exact1
= (s1
->eo
- s1
->so
) == strlen(s1
->sym
->name
);
918 exact2
= (s2
->eo
- s2
->so
) == strlen(s2
->sym
->name
);
919 if (exact1
&& !exact2
)
921 if (!exact1
&& exact2
)
924 /* As a fallback, sort symbols alphabetically */
925 return strcmp(s1
->sym
->name
, s2
->sym
->name
);
928 struct symbol
**sym_re_search(const char *pattern
)
930 struct symbol
*sym
, **sym_arr
= NULL
;
931 struct sym_match
*sym_match_arr
= NULL
;
938 if (strlen(pattern
) == 0)
940 if (regcomp(&re
, pattern
, REG_EXTENDED
|REG_ICASE
))
943 for_all_symbols(i
, sym
) {
944 if (sym
->flags
& SYMBOL_CONST
|| !sym
->name
)
946 if (regexec(&re
, sym
->name
, 1, match
, 0))
951 tmp
= realloc(sym_match_arr
, size
* sizeof(struct sym_match
));
953 goto sym_re_search_free
;
957 /* As regexec returned 0, we know we have a match, so
958 * we can use match[0].rm_[se]o without further checks
960 sym_match_arr
[cnt
].so
= match
[0].rm_so
;
961 sym_match_arr
[cnt
].eo
= match
[0].rm_eo
;
962 sym_match_arr
[cnt
++].sym
= sym
;
965 qsort(sym_match_arr
, cnt
, sizeof(struct sym_match
), sym_rel_comp
);
966 sym_arr
= malloc((cnt
+1) * sizeof(struct symbol
*));
968 goto sym_re_search_free
;
969 for (i
= 0; i
< cnt
; i
++)
970 sym_arr
[i
] = sym_match_arr
[i
].sym
;
974 /* sym_match_arr can be NULL if no match, but free(NULL) is OK */
982 * When we check for recursive dependencies we use a stack to save
983 * current state so we can print out relevant info to user.
984 * The entries are located on the call stack so no need to free memory.
985 * Note insert() remove() must always match to properly clear the stack.
987 static struct dep_stack
{
988 struct dep_stack
*prev
, *next
;
990 struct property
*prop
;
994 static void dep_stack_insert(struct dep_stack
*stack
, struct symbol
*sym
)
996 memset(stack
, 0, sizeof(*stack
));
998 check_top
->next
= stack
;
999 stack
->prev
= check_top
;
1004 static void dep_stack_remove(void)
1006 check_top
= check_top
->prev
;
1008 check_top
->next
= NULL
;
1012 * Called when we have detected a recursive dependency.
1013 * check_top point to the top of the stact so we use
1014 * the ->prev pointer to locate the bottom of the stack.
1016 static void sym_check_print_recursive(struct symbol
*last_sym
)
1018 struct dep_stack
*stack
;
1019 struct symbol
*sym
, *next_sym
;
1020 struct menu
*menu
= NULL
;
1021 struct property
*prop
;
1022 struct dep_stack cv_stack
;
1024 if (sym_is_choice_value(last_sym
)) {
1025 dep_stack_insert(&cv_stack
, last_sym
);
1026 last_sym
= prop_get_symbol(sym_get_choice_prop(last_sym
));
1029 for (stack
= check_top
; stack
!= NULL
; stack
= stack
->prev
)
1030 if (stack
->sym
== last_sym
)
1033 fprintf(stderr
, "unexpected recursive dependency error\n");
1037 for (; stack
; stack
= stack
->next
) {
1039 next_sym
= stack
->next
? stack
->next
->sym
: last_sym
;
1042 prop
= stack
->sym
->prop
;
1044 /* for choice values find the menu entry (used below) */
1045 if (sym_is_choice(sym
) || sym_is_choice_value(sym
)) {
1046 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
1052 if (stack
->sym
== last_sym
)
1053 fprintf(stderr
, "%s:%d:error: recursive dependency detected!\n",
1054 prop
->file
->name
, prop
->lineno
);
1056 if (sym_is_choice(sym
)) {
1057 fprintf(stderr
, "%s:%d:\tchoice %s contains symbol %s\n",
1058 menu
->file
->name
, menu
->lineno
,
1059 sym
->name
? sym
->name
: "<choice>",
1060 next_sym
->name
? next_sym
->name
: "<choice>");
1061 } else if (sym_is_choice_value(sym
)) {
1062 fprintf(stderr
, "%s:%d:\tsymbol %s is part of choice %s\n",
1063 menu
->file
->name
, menu
->lineno
,
1064 sym
->name
? sym
->name
: "<choice>",
1065 next_sym
->name
? next_sym
->name
: "<choice>");
1066 } else if (stack
->expr
== &sym
->dir_dep
.expr
) {
1067 fprintf(stderr
, "%s:%d:\tsymbol %s depends on %s\n",
1068 prop
->file
->name
, prop
->lineno
,
1069 sym
->name
? sym
->name
: "<choice>",
1070 next_sym
->name
? next_sym
->name
: "<choice>");
1071 } else if (stack
->expr
== &sym
->rev_dep
.expr
) {
1072 fprintf(stderr
, "%s:%d:\tsymbol %s is selected by %s\n",
1073 prop
->file
->name
, prop
->lineno
,
1074 sym
->name
? sym
->name
: "<choice>",
1075 next_sym
->name
? next_sym
->name
: "<choice>");
1076 } else if (stack
->expr
== &sym
->implied
.expr
) {
1077 fprintf(stderr
, "%s:%d:\tsymbol %s is implied by %s\n",
1078 prop
->file
->name
, prop
->lineno
,
1079 sym
->name
? sym
->name
: "<choice>",
1080 next_sym
->name
? next_sym
->name
: "<choice>");
1081 } else if (stack
->expr
) {
1082 fprintf(stderr
, "%s:%d:\tsymbol %s %s value contains %s\n",
1083 prop
->file
->name
, prop
->lineno
,
1084 sym
->name
? sym
->name
: "<choice>",
1085 prop_get_type_name(prop
->type
),
1086 next_sym
->name
? next_sym
->name
: "<choice>");
1088 fprintf(stderr
, "%s:%d:\tsymbol %s %s is visible depending on %s\n",
1089 prop
->file
->name
, prop
->lineno
,
1090 sym
->name
? sym
->name
: "<choice>",
1091 prop_get_type_name(prop
->type
),
1092 next_sym
->name
? next_sym
->name
: "<choice>");
1097 "For a resolution refer to Documentation/kbuild/kconfig-language.rst\n"
1098 "subsection \"Kconfig recursive dependency limitations\"\n"
1101 if (check_top
== &cv_stack
)
1105 static struct symbol
*sym_check_expr_deps(struct expr
*e
)
1114 sym
= sym_check_expr_deps(e
->left
.expr
);
1117 return sym_check_expr_deps(e
->right
.expr
);
1119 return sym_check_expr_deps(e
->left
.expr
);
1126 sym
= sym_check_deps(e
->left
.sym
);
1129 return sym_check_deps(e
->right
.sym
);
1131 return sym_check_deps(e
->left
.sym
);
1135 fprintf(stderr
, "Oops! How to check %d?\n", e
->type
);
1139 /* return NULL when dependencies are OK */
1140 static struct symbol
*sym_check_sym_deps(struct symbol
*sym
)
1142 struct symbol
*sym2
;
1143 struct property
*prop
;
1144 struct dep_stack stack
;
1146 dep_stack_insert(&stack
, sym
);
1148 stack
.expr
= &sym
->dir_dep
.expr
;
1149 sym2
= sym_check_expr_deps(sym
->dir_dep
.expr
);
1153 stack
.expr
= &sym
->rev_dep
.expr
;
1154 sym2
= sym_check_expr_deps(sym
->rev_dep
.expr
);
1158 stack
.expr
= &sym
->implied
.expr
;
1159 sym2
= sym_check_expr_deps(sym
->implied
.expr
);
1165 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
1166 if (prop
->type
== P_CHOICE
|| prop
->type
== P_SELECT
||
1167 prop
->type
== P_IMPLY
)
1170 sym2
= sym_check_expr_deps(prop
->visible
.expr
);
1173 if (prop
->type
!= P_DEFAULT
|| sym_is_choice(sym
))
1175 stack
.expr
= &prop
->expr
;
1176 sym2
= sym_check_expr_deps(prop
->expr
);
1188 static struct symbol
*sym_check_choice_deps(struct symbol
*choice
)
1190 struct symbol
*sym
, *sym2
;
1191 struct property
*prop
;
1193 struct dep_stack stack
;
1195 dep_stack_insert(&stack
, choice
);
1197 prop
= sym_get_choice_prop(choice
);
1198 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1199 sym
->flags
|= (SYMBOL_CHECK
| SYMBOL_CHECKED
);
1201 choice
->flags
|= (SYMBOL_CHECK
| SYMBOL_CHECKED
);
1202 sym2
= sym_check_sym_deps(choice
);
1203 choice
->flags
&= ~SYMBOL_CHECK
;
1207 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1208 sym2
= sym_check_sym_deps(sym
);
1213 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1214 sym
->flags
&= ~SYMBOL_CHECK
;
1216 if (sym2
&& sym_is_choice_value(sym2
) &&
1217 prop_get_symbol(sym_get_choice_prop(sym2
)) == choice
)
1225 struct symbol
*sym_check_deps(struct symbol
*sym
)
1227 struct symbol
*sym2
;
1228 struct property
*prop
;
1230 if (sym
->flags
& SYMBOL_CHECK
) {
1231 sym_check_print_recursive(sym
);
1234 if (sym
->flags
& SYMBOL_CHECKED
)
1237 if (sym_is_choice_value(sym
)) {
1238 struct dep_stack stack
;
1240 /* for choice groups start the check with main choice symbol */
1241 dep_stack_insert(&stack
, sym
);
1242 prop
= sym_get_choice_prop(sym
);
1243 sym2
= sym_check_deps(prop_get_symbol(prop
));
1245 } else if (sym_is_choice(sym
)) {
1246 sym2
= sym_check_choice_deps(sym
);
1248 sym
->flags
|= (SYMBOL_CHECK
| SYMBOL_CHECKED
);
1249 sym2
= sym_check_sym_deps(sym
);
1250 sym
->flags
&= ~SYMBOL_CHECK
;
1256 struct symbol
*prop_get_symbol(struct property
*prop
)
1258 if (prop
->expr
&& (prop
->expr
->type
== E_SYMBOL
||
1259 prop
->expr
->type
== E_LIST
))
1260 return prop
->expr
->left
.sym
;
1264 const char *prop_get_type_name(enum prop_type type
)