2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
10 #include <sys/utsname.h>
12 #define LKC_DIRECT_LINK
15 struct symbol symbol_yes
= {
18 .flags
= SYMBOL_CONST
|SYMBOL_VALID
,
22 .flags
= SYMBOL_CONST
|SYMBOL_VALID
,
26 .flags
= SYMBOL_CONST
|SYMBOL_VALID
,
30 .flags
= SYMBOL_VALID
,
33 struct symbol
*sym_defconfig_list
;
34 struct symbol
*modules_sym
;
37 struct expr
*sym_env_list
;
39 static void sym_add_default(struct symbol
*sym
, const char *def
)
41 struct property
*prop
= prop_alloc(P_DEFAULT
, sym
);
43 prop
->expr
= expr_alloc_symbol(sym_lookup(def
, SYMBOL_CONST
));
50 static bool inited
= false;
58 sym
= sym_lookup("UNAME_RELEASE", 0);
60 sym
->flags
|= SYMBOL_AUTO
;
61 sym_add_default(sym
, uts
.release
);
64 enum symbol_type
sym_get_type(struct symbol
*sym
)
66 enum symbol_type type
= sym
->type
;
68 if (type
== S_TRISTATE
) {
69 if (sym_is_choice_value(sym
) && sym
->visible
== yes
)
71 else if (modules_val
== no
)
77 const char *sym_type_name(enum symbol_type type
)
98 struct property
*sym_get_choice_prop(struct symbol
*sym
)
100 struct property
*prop
;
102 for_all_choices(sym
, prop
)
107 struct property
*sym_get_env_prop(struct symbol
*sym
)
109 struct property
*prop
;
111 for_all_properties(sym
, prop
, P_ENV
)
116 struct property
*sym_get_default_prop(struct symbol
*sym
)
118 struct property
*prop
;
120 for_all_defaults(sym
, prop
) {
121 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
122 if (prop
->visible
.tri
!= no
)
128 static struct property
*sym_get_range_prop(struct symbol
*sym
)
130 struct property
*prop
;
132 for_all_properties(sym
, prop
, P_RANGE
) {
133 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
134 if (prop
->visible
.tri
!= no
)
140 static int sym_get_range_val(struct symbol
*sym
, int base
)
153 return strtol(sym
->curr
.val
, NULL
, base
);
156 static void sym_validate_range(struct symbol
*sym
)
158 struct property
*prop
;
172 prop
= sym_get_range_prop(sym
);
175 val
= strtol(sym
->curr
.val
, NULL
, base
);
176 val2
= sym_get_range_val(prop
->expr
->left
.sym
, base
);
178 val2
= sym_get_range_val(prop
->expr
->right
.sym
, base
);
182 if (sym
->type
== S_INT
)
183 sprintf(str
, "%d", val2
);
185 sprintf(str
, "0x%x", val2
);
186 sym
->curr
.val
= strdup(str
);
189 static void sym_calc_visibility(struct symbol
*sym
)
191 struct property
*prop
;
194 /* any prompt visible? */
196 for_all_prompts(sym
, prop
) {
197 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
198 tri
= EXPR_OR(tri
, prop
->visible
.tri
);
200 if (tri
== mod
&& (sym
->type
!= S_TRISTATE
|| modules_val
== no
))
202 if (sym
->visible
!= tri
) {
204 sym_set_changed(sym
);
206 if (sym_is_choice_value(sym
))
208 /* defaulting to "yes" if no explicit "depends on" are given */
210 if (sym
->dir_dep
.expr
)
211 tri
= expr_calc_value(sym
->dir_dep
.expr
);
214 if (sym
->dir_dep
.tri
!= tri
) {
215 sym
->dir_dep
.tri
= tri
;
216 sym_set_changed(sym
);
219 if (sym
->rev_dep
.expr
)
220 tri
= expr_calc_value(sym
->rev_dep
.expr
);
221 if (tri
== mod
&& sym_get_type(sym
) == S_BOOLEAN
)
223 if (sym
->rev_dep
.tri
!= tri
) {
224 sym
->rev_dep
.tri
= tri
;
225 sym_set_changed(sym
);
230 * Find the default symbol for a choice.
231 * First try the default values for the choice symbol
232 * Next locate the first visible choice value
233 * Return NULL if none was found
235 struct symbol
*sym_choice_default(struct symbol
*sym
)
237 struct symbol
*def_sym
;
238 struct property
*prop
;
241 /* any of the defaults visible? */
242 for_all_defaults(sym
, prop
) {
243 prop
->visible
.tri
= expr_calc_value(prop
->visible
.expr
);
244 if (prop
->visible
.tri
== no
)
246 def_sym
= prop_get_symbol(prop
);
247 if (def_sym
->visible
!= no
)
251 /* just get the first visible value */
252 prop
= sym_get_choice_prop(sym
);
253 expr_list_for_each_sym(prop
->expr
, e
, def_sym
)
254 if (def_sym
->visible
!= no
)
257 /* failed to locate any defaults */
261 static struct symbol
*sym_calc_choice(struct symbol
*sym
)
263 struct symbol
*def_sym
;
264 struct property
*prop
;
267 /* first calculate all choice values' visibilities */
268 prop
= sym_get_choice_prop(sym
);
269 expr_list_for_each_sym(prop
->expr
, e
, def_sym
)
270 sym_calc_visibility(def_sym
);
272 /* is the user choice visible? */
273 def_sym
= sym
->def
[S_DEF_USER
].val
;
274 if (def_sym
&& def_sym
->visible
!= no
)
277 def_sym
= sym_choice_default(sym
);
280 /* no choice? reset tristate value */
286 void sym_calc_value(struct symbol
*sym
)
288 struct symbol_value newval
, oldval
;
289 struct property
*prop
;
295 if (sym
->flags
& SYMBOL_VALID
)
297 sym
->flags
|= SYMBOL_VALID
;
305 newval
= symbol_empty
.curr
;
309 newval
= symbol_no
.curr
;
312 sym
->curr
.val
= sym
->name
;
316 if (!sym_is_choice_value(sym
))
317 sym
->flags
&= ~SYMBOL_WRITE
;
319 sym_calc_visibility(sym
);
321 /* set default if recursively called */
324 switch (sym_get_type(sym
)) {
327 if (sym_is_choice_value(sym
) && sym
->visible
== yes
) {
328 prop
= sym_get_choice_prop(sym
);
329 newval
.tri
= (prop_get_symbol(prop
)->curr
.val
== sym
) ? yes
: no
;
331 if (sym
->visible
!= no
) {
332 /* if the symbol is visible use the user value
333 * if available, otherwise try the default value
335 sym
->flags
|= SYMBOL_WRITE
;
336 if (sym_has_value(sym
)) {
337 newval
.tri
= EXPR_AND(sym
->def
[S_DEF_USER
].tri
,
342 if (sym
->rev_dep
.tri
!= no
)
343 sym
->flags
|= SYMBOL_WRITE
;
344 if (!sym_is_choice(sym
)) {
345 prop
= sym_get_default_prop(sym
);
347 sym
->flags
|= SYMBOL_WRITE
;
348 newval
.tri
= EXPR_AND(expr_calc_value(prop
->expr
),
353 newval
.tri
= EXPR_OR(newval
.tri
, sym
->rev_dep
.tri
);
355 if (newval
.tri
== mod
&& sym_get_type(sym
) == S_BOOLEAN
)
361 if (sym
->visible
!= no
) {
362 sym
->flags
|= SYMBOL_WRITE
;
363 if (sym_has_value(sym
)) {
364 newval
.val
= sym
->def
[S_DEF_USER
].val
;
368 prop
= sym_get_default_prop(sym
);
370 struct symbol
*ds
= prop_get_symbol(prop
);
372 sym
->flags
|= SYMBOL_WRITE
;
374 newval
.val
= ds
->curr
.val
;
383 if (sym_is_choice(sym
) && newval
.tri
== yes
)
384 sym
->curr
.val
= sym_calc_choice(sym
);
385 sym_validate_range(sym
);
387 if (memcmp(&oldval
, &sym
->curr
, sizeof(oldval
))) {
388 sym_set_changed(sym
);
389 if (modules_sym
== sym
) {
390 sym_set_all_changed();
391 modules_val
= modules_sym
->curr
.tri
;
395 if (sym_is_choice(sym
)) {
396 struct symbol
*choice_sym
;
398 prop
= sym_get_choice_prop(sym
);
399 expr_list_for_each_sym(prop
->expr
, e
, choice_sym
) {
400 if ((sym
->flags
& SYMBOL_WRITE
) &&
401 choice_sym
->visible
!= no
)
402 choice_sym
->flags
|= SYMBOL_WRITE
;
403 if (sym
->flags
& SYMBOL_CHANGED
)
404 sym_set_changed(choice_sym
);
408 if (sym
->flags
& SYMBOL_AUTO
)
409 sym
->flags
&= ~SYMBOL_WRITE
;
412 void sym_clear_all_valid(void)
417 for_all_symbols(i
, sym
)
418 sym
->flags
&= ~SYMBOL_VALID
;
419 sym_add_change_count(1);
421 sym_calc_value(modules_sym
);
424 void sym_set_changed(struct symbol
*sym
)
426 struct property
*prop
;
428 sym
->flags
|= SYMBOL_CHANGED
;
429 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
431 prop
->menu
->flags
|= MENU_CHANGED
;
435 void sym_set_all_changed(void)
440 for_all_symbols(i
, sym
)
441 sym_set_changed(sym
);
444 bool sym_tristate_within_range(struct symbol
*sym
, tristate val
)
446 int type
= sym_get_type(sym
);
448 if (sym
->visible
== no
)
451 if (type
!= S_BOOLEAN
&& type
!= S_TRISTATE
)
454 if (type
== S_BOOLEAN
&& val
== mod
)
456 if (sym
->visible
<= sym
->rev_dep
.tri
)
458 if (sym_is_choice_value(sym
) && sym
->visible
== yes
)
460 return val
>= sym
->rev_dep
.tri
&& val
<= sym
->visible
;
463 bool sym_set_tristate_value(struct symbol
*sym
, tristate val
)
465 tristate oldval
= sym_get_tristate_value(sym
);
467 if (oldval
!= val
&& !sym_tristate_within_range(sym
, val
))
470 if (!(sym
->flags
& SYMBOL_DEF_USER
)) {
471 sym
->flags
|= SYMBOL_DEF_USER
;
472 sym_set_changed(sym
);
475 * setting a choice value also resets the new flag of the choice
476 * symbol and all other choice values.
478 if (sym_is_choice_value(sym
) && val
== yes
) {
479 struct symbol
*cs
= prop_get_symbol(sym_get_choice_prop(sym
));
480 struct property
*prop
;
483 cs
->def
[S_DEF_USER
].val
= sym
;
484 cs
->flags
|= SYMBOL_DEF_USER
;
485 prop
= sym_get_choice_prop(cs
);
486 for (e
= prop
->expr
; e
; e
= e
->left
.expr
) {
487 if (e
->right
.sym
->visible
!= no
)
488 e
->right
.sym
->flags
|= SYMBOL_DEF_USER
;
492 sym
->def
[S_DEF_USER
].tri
= val
;
494 sym_clear_all_valid();
499 tristate
sym_toggle_tristate_value(struct symbol
*sym
)
501 tristate oldval
, newval
;
503 oldval
= newval
= sym_get_tristate_value(sym
);
516 if (sym_set_tristate_value(sym
, newval
))
518 } while (oldval
!= newval
);
522 bool sym_string_valid(struct symbol
*sym
, const char *str
)
535 if (ch
== '0' && *str
!= 0)
537 while ((ch
= *str
++)) {
543 if (str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
549 } while ((ch
= *str
++));
565 bool sym_string_within_range(struct symbol
*sym
, const char *str
)
567 struct property
*prop
;
572 return sym_string_valid(sym
, str
);
574 if (!sym_string_valid(sym
, str
))
576 prop
= sym_get_range_prop(sym
);
579 val
= strtol(str
, NULL
, 10);
580 return val
>= sym_get_range_val(prop
->expr
->left
.sym
, 10) &&
581 val
<= sym_get_range_val(prop
->expr
->right
.sym
, 10);
583 if (!sym_string_valid(sym
, str
))
585 prop
= sym_get_range_prop(sym
);
588 val
= strtol(str
, NULL
, 16);
589 return val
>= sym_get_range_val(prop
->expr
->left
.sym
, 16) &&
590 val
<= sym_get_range_val(prop
->expr
->right
.sym
, 16);
595 return sym_tristate_within_range(sym
, yes
);
597 return sym_tristate_within_range(sym
, mod
);
599 return sym_tristate_within_range(sym
, no
);
607 bool sym_set_string_value(struct symbol
*sym
, const char *newval
)
618 return sym_set_tristate_value(sym
, yes
);
620 return sym_set_tristate_value(sym
, mod
);
622 return sym_set_tristate_value(sym
, no
);
629 if (!sym_string_within_range(sym
, newval
))
632 if (!(sym
->flags
& SYMBOL_DEF_USER
)) {
633 sym
->flags
|= SYMBOL_DEF_USER
;
634 sym_set_changed(sym
);
637 oldval
= sym
->def
[S_DEF_USER
].val
;
638 size
= strlen(newval
) + 1;
639 if (sym
->type
== S_HEX
&& (newval
[0] != '0' || (newval
[1] != 'x' && newval
[1] != 'X'))) {
641 sym
->def
[S_DEF_USER
].val
= val
= malloc(size
);
644 } else if (!oldval
|| strcmp(oldval
, newval
))
645 sym
->def
[S_DEF_USER
].val
= val
= malloc(size
);
650 free((void *)oldval
);
651 sym_clear_all_valid();
657 * Find the default value associated to a symbol.
658 * For tristate symbol handle the modules=n case
659 * in which case "m" becomes "y".
660 * If the symbol does not have any default then fallback
661 * to the fixed default values.
663 const char *sym_get_string_default(struct symbol
*sym
)
665 struct property
*prop
;
670 sym_calc_visibility(sym
);
671 sym_calc_value(modules_sym
);
672 val
= symbol_no
.curr
.tri
;
673 str
= symbol_empty
.curr
.val
;
675 /* If symbol has a default value look it up */
676 prop
= sym_get_default_prop(sym
);
681 /* The visibility imay limit the value from yes => mod */
682 val
= EXPR_AND(expr_calc_value(prop
->expr
), prop
->visible
.tri
);
686 * The following fails to handle the situation
687 * where a default value is further limited by
690 ds
= prop_get_symbol(prop
);
693 str
= (const char *)ds
->curr
.val
;
698 /* Handle select statements */
699 val
= EXPR_OR(val
, sym
->rev_dep
.tri
);
701 /* transpose mod to yes if modules are not enabled */
703 if (!sym_is_choice_value(sym
) && modules_sym
->curr
.tri
== no
)
706 /* transpose mod to yes if type is bool */
707 if (sym
->type
== S_BOOLEAN
&& val
== mod
)
715 case mod
: return "m";
716 case yes
: return "y";
730 const char *sym_get_string_value(struct symbol
*sym
)
737 val
= sym_get_tristate_value(sym
);
750 return (const char *)sym
->curr
.val
;
753 bool sym_is_changable(struct symbol
*sym
)
755 return sym
->visible
> sym
->rev_dep
.tri
;
758 static unsigned strhash(const char *s
)
761 unsigned hash
= 2166136261U;
763 hash
= (hash
^ *s
) * 0x01000193;
767 struct symbol
*sym_lookup(const char *name
, int flags
)
769 struct symbol
*symbol
;
774 if (name
[0] && !name
[1]) {
776 case 'y': return &symbol_yes
;
777 case 'm': return &symbol_mod
;
778 case 'n': return &symbol_no
;
781 hash
= strhash(name
) % SYMBOL_HASHSIZE
;
783 for (symbol
= symbol_hash
[hash
]; symbol
; symbol
= symbol
->next
) {
785 !strcmp(symbol
->name
, name
) &&
786 (flags
? symbol
->flags
& flags
787 : !(symbol
->flags
& (SYMBOL_CONST
|SYMBOL_CHOICE
))))
790 new_name
= strdup(name
);
796 symbol
= malloc(sizeof(*symbol
));
797 memset(symbol
, 0, sizeof(*symbol
));
798 symbol
->name
= new_name
;
799 symbol
->type
= S_UNKNOWN
;
800 symbol
->flags
|= flags
;
802 symbol
->next
= symbol_hash
[hash
];
803 symbol_hash
[hash
] = symbol
;
808 struct symbol
*sym_find(const char *name
)
810 struct symbol
*symbol
= NULL
;
816 if (name
[0] && !name
[1]) {
818 case 'y': return &symbol_yes
;
819 case 'm': return &symbol_mod
;
820 case 'n': return &symbol_no
;
823 hash
= strhash(name
) % SYMBOL_HASHSIZE
;
825 for (symbol
= symbol_hash
[hash
]; symbol
; symbol
= symbol
->next
) {
827 !strcmp(symbol
->name
, name
) &&
828 !(symbol
->flags
& SYMBOL_CONST
))
835 struct symbol
**sym_re_search(const char *pattern
)
837 struct symbol
*sym
, **sym_arr
= NULL
;
843 if (strlen(pattern
) == 0)
845 if (regcomp(&re
, pattern
, REG_EXTENDED
|REG_NOSUB
|REG_ICASE
))
848 for_all_symbols(i
, sym
) {
849 if (sym
->flags
& SYMBOL_CONST
|| !sym
->name
)
851 if (regexec(&re
, sym
->name
, 0, NULL
, 0))
853 if (cnt
+ 1 >= size
) {
856 sym_arr
= realloc(sym_arr
, size
* sizeof(struct symbol
*));
863 sym_arr
[cnt
++] = sym
;
873 * When we check for recursive dependencies we use a stack to save
874 * current state so we can print out relevant info to user.
875 * The entries are located on the call stack so no need to free memory.
876 * Note inser() remove() must always match to properly clear the stack.
878 static struct dep_stack
{
879 struct dep_stack
*prev
, *next
;
881 struct property
*prop
;
885 static void dep_stack_insert(struct dep_stack
*stack
, struct symbol
*sym
)
887 memset(stack
, 0, sizeof(*stack
));
889 check_top
->next
= stack
;
890 stack
->prev
= check_top
;
895 static void dep_stack_remove(void)
897 check_top
= check_top
->prev
;
899 check_top
->next
= NULL
;
903 * Called when we have detected a recursive dependency.
904 * check_top point to the top of the stact so we use
905 * the ->prev pointer to locate the bottom of the stack.
907 static void sym_check_print_recursive(struct symbol
*last_sym
)
909 struct dep_stack
*stack
;
910 struct symbol
*sym
, *next_sym
;
911 struct menu
*menu
= NULL
;
912 struct property
*prop
;
913 struct dep_stack cv_stack
;
915 if (sym_is_choice_value(last_sym
)) {
916 dep_stack_insert(&cv_stack
, last_sym
);
917 last_sym
= prop_get_symbol(sym_get_choice_prop(last_sym
));
920 for (stack
= check_top
; stack
!= NULL
; stack
= stack
->prev
)
921 if (stack
->sym
== last_sym
)
924 fprintf(stderr
, "unexpected recursive dependency error\n");
928 for (; stack
; stack
= stack
->next
) {
930 next_sym
= stack
->next
? stack
->next
->sym
: last_sym
;
933 prop
= stack
->sym
->prop
;
935 /* for choice values find the menu entry (used below) */
936 if (sym_is_choice(sym
) || sym_is_choice_value(sym
)) {
937 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
943 if (stack
->sym
== last_sym
)
944 fprintf(stderr
, "%s:%d:error: recursive dependency detected!\n",
945 prop
->file
->name
, prop
->lineno
);
947 fprintf(stderr
, "%s:%d:\tsymbol %s %s value contains %s\n",
948 prop
->file
->name
, prop
->lineno
,
949 sym
->name
? sym
->name
: "<choice>",
950 prop_get_type_name(prop
->type
),
951 next_sym
->name
? next_sym
->name
: "<choice>");
952 } else if (stack
->prop
) {
953 fprintf(stderr
, "%s:%d:\tsymbol %s depends on %s\n",
954 prop
->file
->name
, prop
->lineno
,
955 sym
->name
? sym
->name
: "<choice>",
956 next_sym
->name
? next_sym
->name
: "<choice>");
957 } else if (sym_is_choice(sym
)) {
958 fprintf(stderr
, "%s:%d:\tchoice %s contains symbol %s\n",
959 menu
->file
->name
, menu
->lineno
,
960 sym
->name
? sym
->name
: "<choice>",
961 next_sym
->name
? next_sym
->name
: "<choice>");
962 } else if (sym_is_choice_value(sym
)) {
963 fprintf(stderr
, "%s:%d:\tsymbol %s is part of choice %s\n",
964 menu
->file
->name
, menu
->lineno
,
965 sym
->name
? sym
->name
: "<choice>",
966 next_sym
->name
? next_sym
->name
: "<choice>");
968 fprintf(stderr
, "%s:%d:\tsymbol %s is selected by %s\n",
969 prop
->file
->name
, prop
->lineno
,
970 sym
->name
? sym
->name
: "<choice>",
971 next_sym
->name
? next_sym
->name
: "<choice>");
975 if (check_top
== &cv_stack
)
979 static struct symbol
*sym_check_expr_deps(struct expr
*e
)
988 sym
= sym_check_expr_deps(e
->left
.expr
);
991 return sym_check_expr_deps(e
->right
.expr
);
993 return sym_check_expr_deps(e
->left
.expr
);
996 sym
= sym_check_deps(e
->left
.sym
);
999 return sym_check_deps(e
->right
.sym
);
1001 return sym_check_deps(e
->left
.sym
);
1005 printf("Oops! How to check %d?\n", e
->type
);
1009 /* return NULL when dependencies are OK */
1010 static struct symbol
*sym_check_sym_deps(struct symbol
*sym
)
1012 struct symbol
*sym2
;
1013 struct property
*prop
;
1014 struct dep_stack stack
;
1016 dep_stack_insert(&stack
, sym
);
1018 sym2
= sym_check_expr_deps(sym
->rev_dep
.expr
);
1022 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
1023 if (prop
->type
== P_CHOICE
|| prop
->type
== P_SELECT
)
1026 sym2
= sym_check_expr_deps(prop
->visible
.expr
);
1029 if (prop
->type
!= P_DEFAULT
|| sym_is_choice(sym
))
1031 stack
.expr
= prop
->expr
;
1032 sym2
= sym_check_expr_deps(prop
->expr
);
1044 static struct symbol
*sym_check_choice_deps(struct symbol
*choice
)
1046 struct symbol
*sym
, *sym2
;
1047 struct property
*prop
;
1049 struct dep_stack stack
;
1051 dep_stack_insert(&stack
, choice
);
1053 prop
= sym_get_choice_prop(choice
);
1054 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1055 sym
->flags
|= (SYMBOL_CHECK
| SYMBOL_CHECKED
);
1057 choice
->flags
|= (SYMBOL_CHECK
| SYMBOL_CHECKED
);
1058 sym2
= sym_check_sym_deps(choice
);
1059 choice
->flags
&= ~SYMBOL_CHECK
;
1063 expr_list_for_each_sym(prop
->expr
, e
, sym
) {
1064 sym2
= sym_check_sym_deps(sym
);
1069 expr_list_for_each_sym(prop
->expr
, e
, sym
)
1070 sym
->flags
&= ~SYMBOL_CHECK
;
1072 if (sym2
&& sym_is_choice_value(sym2
) &&
1073 prop_get_symbol(sym_get_choice_prop(sym2
)) == choice
)
1081 struct symbol
*sym_check_deps(struct symbol
*sym
)
1083 struct symbol
*sym2
;
1084 struct property
*prop
;
1086 if (sym
->flags
& SYMBOL_CHECK
) {
1087 sym_check_print_recursive(sym
);
1090 if (sym
->flags
& SYMBOL_CHECKED
)
1093 if (sym_is_choice_value(sym
)) {
1094 struct dep_stack stack
;
1096 /* for choice groups start the check with main choice symbol */
1097 dep_stack_insert(&stack
, sym
);
1098 prop
= sym_get_choice_prop(sym
);
1099 sym2
= sym_check_deps(prop_get_symbol(prop
));
1101 } else if (sym_is_choice(sym
)) {
1102 sym2
= sym_check_choice_deps(sym
);
1104 sym
->flags
|= (SYMBOL_CHECK
| SYMBOL_CHECKED
);
1105 sym2
= sym_check_sym_deps(sym
);
1106 sym
->flags
&= ~SYMBOL_CHECK
;
1109 if (sym2
&& sym2
== sym
)
1115 struct property
*prop_alloc(enum prop_type type
, struct symbol
*sym
)
1117 struct property
*prop
;
1118 struct property
**propp
;
1120 prop
= malloc(sizeof(*prop
));
1121 memset(prop
, 0, sizeof(*prop
));
1124 prop
->file
= current_file
;
1125 prop
->lineno
= zconf_lineno();
1127 /* append property to the prop list of symbol */
1129 for (propp
= &sym
->prop
; *propp
; propp
= &(*propp
)->next
)
1137 struct symbol
*prop_get_symbol(struct property
*prop
)
1139 if (prop
->expr
&& (prop
->expr
->type
== E_SYMBOL
||
1140 prop
->expr
->type
== E_LIST
))
1141 return prop
->expr
->left
.sym
;
1145 const char *prop_get_type_name(enum prop_type type
)
1172 static void prop_add_env(const char *env
)
1174 struct symbol
*sym
, *sym2
;
1175 struct property
*prop
;
1178 sym
= current_entry
->sym
;
1179 sym
->flags
|= SYMBOL_AUTO
;
1180 for_all_properties(sym
, prop
, P_ENV
) {
1181 sym2
= prop_get_symbol(prop
);
1182 if (strcmp(sym2
->name
, env
))
1183 menu_warn(current_entry
, "redefining environment symbol from %s",
1188 prop
= prop_alloc(P_ENV
, sym
);
1189 prop
->expr
= expr_alloc_symbol(sym_lookup(env
, SYMBOL_CONST
));
1191 sym_env_list
= expr_alloc_one(E_LIST
, sym_env_list
);
1192 sym_env_list
->right
.sym
= sym
;
1196 sym_add_default(sym
, p
);
1198 menu_warn(current_entry
, "environment variable %s undefined", env
);