2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
9 #define LKC_DIRECT_LINK
12 static const char nohelp_text
[] = N_(
13 "There is no help available for this kernel option.\n");
16 static struct menu
**last_entry_ptr
;
18 struct file
*file_list
;
19 struct file
*current_file
;
21 void menu_warn(struct menu
*menu
, const char *fmt
, ...)
25 fprintf(stderr
, "%s:%d:warning: ", menu
->file
->name
, menu
->lineno
);
26 vfprintf(stderr
, fmt
, ap
);
27 fprintf(stderr
, "\n");
31 static void prop_warn(struct property
*prop
, const char *fmt
, ...)
35 fprintf(stderr
, "%s:%d:warning: ", prop
->file
->name
, prop
->lineno
);
36 vfprintf(stderr
, fmt
, ap
);
37 fprintf(stderr
, "\n");
43 current_entry
= current_menu
= &rootmenu
;
44 last_entry_ptr
= &rootmenu
.list
;
47 void menu_add_entry(struct symbol
*sym
)
51 menu
= malloc(sizeof(*menu
));
52 memset(menu
, 0, sizeof(*menu
));
54 menu
->parent
= current_menu
;
55 menu
->file
= current_file
;
56 menu
->lineno
= zconf_lineno();
58 *last_entry_ptr
= menu
;
59 last_entry_ptr
= &menu
->next
;
62 menu_add_symbol(P_SYMBOL
, sym
, NULL
);
65 void menu_end_entry(void)
69 struct menu
*menu_add_menu(void)
72 last_entry_ptr
= ¤t_entry
->list
;
73 return current_menu
= current_entry
;
76 void menu_end_menu(void)
78 last_entry_ptr
= ¤t_menu
->next
;
79 current_menu
= current_menu
->parent
;
82 static struct expr
*menu_check_dep(struct expr
*e
)
89 e
->left
.expr
= menu_check_dep(e
->left
.expr
);
93 e
->left
.expr
= menu_check_dep(e
->left
.expr
);
94 e
->right
.expr
= menu_check_dep(e
->right
.expr
);
97 /* change 'm' into 'm' && MODULES */
98 if (e
->left
.sym
== &symbol_mod
)
99 return expr_alloc_and(e
, expr_alloc_symbol(modules_sym
));
107 void menu_add_dep(struct expr
*dep
)
109 current_entry
->dep
= expr_alloc_and(current_entry
->dep
, menu_check_dep(dep
));
112 void menu_set_type(int type
)
114 struct symbol
*sym
= current_entry
->sym
;
116 if (sym
->type
== type
)
118 if (sym
->type
== S_UNKNOWN
) {
122 menu_warn(current_entry
, "type of '%s' redefined from '%s' to '%s'",
123 sym
->name
? sym
->name
: "<choice>",
124 sym_type_name(sym
->type
), sym_type_name(type
));
127 struct property
*menu_add_prop(enum prop_type type
, char *prompt
, struct expr
*expr
, struct expr
*dep
)
129 struct property
*prop
= prop_alloc(type
, current_entry
->sym
);
131 prop
->menu
= current_entry
;
133 prop
->visible
.expr
= menu_check_dep(dep
);
136 if (isspace(*prompt
)) {
137 prop_warn(prop
, "leading whitespace ignored");
138 while (isspace(*prompt
))
141 if (current_entry
->prompt
)
142 prop_warn(prop
, "prompt redefined");
143 current_entry
->prompt
= prop
;
150 struct property
*menu_add_prompt(enum prop_type type
, char *prompt
, struct expr
*dep
)
152 return menu_add_prop(type
, prompt
, NULL
, dep
);
155 void menu_add_expr(enum prop_type type
, struct expr
*expr
, struct expr
*dep
)
157 menu_add_prop(type
, NULL
, expr
, dep
);
160 void menu_add_symbol(enum prop_type type
, struct symbol
*sym
, struct expr
*dep
)
162 menu_add_prop(type
, NULL
, expr_alloc_symbol(sym
), dep
);
165 void menu_add_option(int token
, char *arg
)
167 struct property
*prop
;
171 prop
= prop_alloc(P_DEFAULT
, modules_sym
);
172 prop
->expr
= expr_alloc_symbol(current_entry
->sym
);
174 case T_OPT_DEFCONFIG_LIST
:
175 if (!sym_defconfig_list
)
176 sym_defconfig_list
= current_entry
->sym
;
177 else if (sym_defconfig_list
!= current_entry
->sym
)
178 zconf_error("trying to redefine defconfig symbol");
186 static int menu_range_valid_sym(struct symbol
*sym
, struct symbol
*sym2
)
188 return sym2
->type
== S_INT
|| sym2
->type
== S_HEX
||
189 (sym2
->type
== S_UNKNOWN
&& sym_string_valid(sym
, sym2
->name
));
192 static void sym_check_prop(struct symbol
*sym
)
194 struct property
*prop
;
196 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
197 switch (prop
->type
) {
199 if ((sym
->type
== S_STRING
|| sym
->type
== S_INT
|| sym
->type
== S_HEX
) &&
200 prop
->expr
->type
!= E_SYMBOL
)
202 "default for config symbol '%s'"
203 " must be a single symbol", sym
->name
);
206 sym2
= prop_get_symbol(prop
);
207 if (sym
->type
!= S_BOOLEAN
&& sym
->type
!= S_TRISTATE
)
209 "config symbol '%s' uses select, but is "
210 "not boolean or tristate", sym
->name
);
211 else if (sym2
->type
!= S_UNKNOWN
&&
212 sym2
->type
!= S_BOOLEAN
&&
213 sym2
->type
!= S_TRISTATE
)
215 "'%s' has wrong type. 'select' only "
216 "accept arguments of boolean and "
217 "tristate type", sym2
->name
);
220 if (sym
->type
!= S_INT
&& sym
->type
!= S_HEX
)
221 prop_warn(prop
, "range is only allowed "
222 "for int or hex symbols");
223 if (!menu_range_valid_sym(sym
, prop
->expr
->left
.sym
) ||
224 !menu_range_valid_sym(sym
, prop
->expr
->right
.sym
))
225 prop_warn(prop
, "range is invalid");
233 void menu_finalize(struct menu
*parent
)
235 struct menu
*menu
, *last_menu
;
237 struct property
*prop
;
238 struct expr
*parentdep
, *basedep
, *dep
, *dep2
, **ep
;
242 if (sym
&& sym_is_choice(sym
)) {
243 if (sym
->type
== S_UNKNOWN
) {
244 /* find the first choice value to find out choice type */
245 current_entry
= parent
;
246 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
247 if (menu
->sym
&& menu
->sym
->type
!= S_UNKNOWN
) {
248 menu_set_type(menu
->sym
->type
);
253 /* set the type of the remaining choice values */
254 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
255 current_entry
= menu
;
256 if (menu
->sym
&& menu
->sym
->type
== S_UNKNOWN
)
257 menu_set_type(sym
->type
);
259 parentdep
= expr_alloc_symbol(sym
);
260 } else if (parent
->prompt
)
261 parentdep
= parent
->prompt
->visible
.expr
;
263 parentdep
= parent
->dep
;
265 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
266 basedep
= expr_transform(menu
->dep
);
267 basedep
= expr_alloc_and(expr_copy(parentdep
), basedep
);
268 basedep
= expr_eliminate_dups(basedep
);
271 prop
= menu
->sym
->prop
;
274 for (; prop
; prop
= prop
->next
) {
275 if (prop
->menu
!= menu
)
277 dep
= expr_transform(prop
->visible
.expr
);
278 dep
= expr_alloc_and(expr_copy(basedep
), dep
);
279 dep
= expr_eliminate_dups(dep
);
280 if (menu
->sym
&& menu
->sym
->type
!= S_TRISTATE
)
281 dep
= expr_trans_bool(dep
);
282 prop
->visible
.expr
= dep
;
283 if (prop
->type
== P_SELECT
) {
284 struct symbol
*es
= prop_get_symbol(prop
);
285 es
->rev_dep
.expr
= expr_alloc_or(es
->rev_dep
.expr
,
286 expr_alloc_and(expr_alloc_symbol(menu
->sym
), expr_copy(dep
)));
290 for (menu
= parent
->list
; menu
; menu
= menu
->next
)
293 basedep
= parent
->prompt
? parent
->prompt
->visible
.expr
: NULL
;
294 basedep
= expr_trans_compare(basedep
, E_UNEQUAL
, &symbol_no
);
295 basedep
= expr_eliminate_dups(expr_transform(basedep
));
297 for (menu
= parent
->next
; menu
; menu
= menu
->next
) {
298 dep
= menu
->prompt
? menu
->prompt
->visible
.expr
: menu
->dep
;
299 if (!expr_contains_symbol(dep
, sym
))
301 if (expr_depends_symbol(dep
, sym
))
303 dep
= expr_trans_compare(dep
, E_UNEQUAL
, &symbol_no
);
304 dep
= expr_eliminate_dups(expr_transform(dep
));
305 dep2
= expr_copy(basedep
);
306 expr_eliminate_eq(&dep
, &dep2
);
308 if (!expr_is_yes(dep2
)) {
315 menu
->parent
= parent
;
319 parent
->list
= parent
->next
;
320 parent
->next
= last_menu
->next
;
321 last_menu
->next
= NULL
;
324 sym
->dir_dep
.expr
= parent
->dep
;
326 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
327 if (sym
&& sym_is_choice(sym
) &&
328 menu
->sym
&& !sym_is_choice_value(menu
->sym
)) {
329 current_entry
= menu
;
330 menu
->sym
->flags
|= SYMBOL_CHOICEVAL
;
332 menu_warn(menu
, "choice value must have a prompt");
333 for (prop
= menu
->sym
->prop
; prop
; prop
= prop
->next
) {
334 if (prop
->type
== P_DEFAULT
)
335 prop_warn(prop
, "defaults for choice "
336 "values not supported");
337 if (prop
->menu
== menu
)
339 if (prop
->type
== P_PROMPT
&&
340 prop
->menu
->parent
->sym
!= sym
)
341 prop_warn(prop
, "choice value used outside its choice group");
343 /* Non-tristate choice values of tristate choices must
344 * depend on the choice being set to Y. The choice
345 * values' dependencies were propagated to their
346 * properties above, so the change here must be re-
349 if (sym
->type
== S_TRISTATE
&& menu
->sym
->type
!= S_TRISTATE
) {
350 basedep
= expr_alloc_comp(E_EQUAL
, sym
, &symbol_yes
);
351 menu
->dep
= expr_alloc_and(basedep
, menu
->dep
);
352 for (prop
= menu
->sym
->prop
; prop
; prop
= prop
->next
) {
353 if (prop
->menu
!= menu
)
355 prop
->visible
.expr
= expr_alloc_and(expr_copy(basedep
),
359 menu_add_symbol(P_CHOICE
, sym
, NULL
);
360 prop
= sym_get_choice_prop(sym
);
361 for (ep
= &prop
->expr
; *ep
; ep
= &(*ep
)->left
.expr
)
363 *ep
= expr_alloc_one(E_LIST
, NULL
);
364 (*ep
)->right
.sym
= menu
->sym
;
366 if (menu
->list
&& (!menu
->prompt
|| !menu
->prompt
->text
)) {
367 for (last_menu
= menu
->list
; ; last_menu
= last_menu
->next
) {
368 last_menu
->parent
= parent
;
369 if (!last_menu
->next
)
372 last_menu
->next
= menu
->next
;
373 menu
->next
= menu
->list
;
378 if (sym
&& !(sym
->flags
& SYMBOL_WARNED
)) {
379 if (sym
->type
== S_UNKNOWN
)
380 menu_warn(parent
, "config symbol defined without type");
382 if (sym_is_choice(sym
) && !parent
->prompt
)
383 menu_warn(parent
, "choice must have a prompt");
385 /* Check properties connected to this symbol */
387 sym
->flags
|= SYMBOL_WARNED
;
390 if (sym
&& !sym_is_optional(sym
) && parent
->prompt
) {
391 sym
->rev_dep
.expr
= expr_alloc_or(sym
->rev_dep
.expr
,
392 expr_alloc_and(parent
->prompt
->visible
.expr
,
393 expr_alloc_symbol(&symbol_mod
)));
397 bool menu_has_prompt(struct menu
*menu
)
404 bool menu_is_visible(struct menu
*menu
)
416 visible
= menu
->prompt
->visible
.tri
;
418 visible
= menu
->prompt
->visible
.tri
= expr_calc_value(menu
->prompt
->visible
.expr
);
423 if (!sym
|| sym_get_tristate_value(menu
->sym
) == no
)
426 for (child
= menu
->list
; child
; child
= child
->next
) {
427 if (menu_is_visible(child
)) {
429 sym
->flags
|= SYMBOL_DEF_USER
;
437 const char *menu_get_prompt(struct menu
*menu
)
440 return menu
->prompt
->text
;
442 return menu
->sym
->name
;
446 struct menu
*menu_get_root_menu(struct menu
*menu
)
451 struct menu
*menu_get_parent_menu(struct menu
*menu
)
455 for (; menu
!= &rootmenu
; menu
= menu
->parent
) {
456 type
= menu
->prompt
? menu
->prompt
->type
: 0;
463 bool menu_has_help(struct menu
*menu
)
465 return menu
->help
!= NULL
;
468 const char *menu_get_help(struct menu
*menu
)
476 static void get_prompt_str(struct gstr
*r
, struct property
*prop
)
479 struct menu
*submenu
[8], *menu
;
481 str_printf(r
, _("Prompt: %s\n"), _(prop
->text
));
482 str_printf(r
, _(" Defined at %s:%d\n"), prop
->menu
->file
->name
,
484 if (!expr_is_yes(prop
->visible
.expr
)) {
485 str_append(r
, _(" Depends on: "));
486 expr_gstr_print(prop
->visible
.expr
, r
);
489 menu
= prop
->menu
->parent
;
490 for (i
= 0; menu
!= &rootmenu
&& i
< 8; menu
= menu
->parent
)
493 str_printf(r
, _(" Location:\n"));
494 for (j
= 4; --i
>= 0; j
+= 2) {
496 str_printf(r
, "%*c-> %s", j
, ' ', _(menu_get_prompt(menu
)));
498 str_printf(r
, " (%s [=%s])", menu
->sym
->name
?
499 menu
->sym
->name
: _("<choice>"),
500 sym_get_string_value(menu
->sym
));
507 void get_symbol_str(struct gstr
*r
, struct symbol
*sym
)
510 struct property
*prop
;
512 if (sym
&& sym
->name
) {
513 str_printf(r
, "Symbol: %s [=%s]\n", sym
->name
,
514 sym_get_string_value(sym
));
515 str_printf(r
, "Type : %s\n", sym_type_name(sym
->type
));
516 if (sym
->type
== S_INT
|| sym
->type
== S_HEX
) {
517 prop
= sym_get_range_prop(sym
);
519 str_printf(r
, "Range : ");
520 expr_gstr_print(prop
->expr
, r
);
525 for_all_prompts(sym
, prop
)
526 get_prompt_str(r
, prop
);
528 for_all_properties(sym
, prop
, P_SELECT
) {
530 str_append(r
, " Selects: ");
533 str_printf(r
, " && ");
534 expr_gstr_print(prop
->expr
, r
);
538 if (sym
->rev_dep
.expr
) {
539 str_append(r
, _(" Selected by: "));
540 expr_gstr_print(sym
->rev_dep
.expr
, r
);
543 str_append(r
, "\n\n");
546 struct gstr
get_relations_str(struct symbol
**sym_arr
)
549 struct gstr res
= str_new();
552 for (i
= 0; sym_arr
&& (sym
= sym_arr
[i
]); i
++)
553 get_symbol_str(&res
, sym
);
555 str_append(&res
, _("No matches found.\n"));
560 void menu_get_ext_help(struct menu
*menu
, struct gstr
*help
)
562 struct symbol
*sym
= menu
->sym
;
564 if (menu_has_help(menu
)) {
566 str_printf(help
, "CONFIG_%s:\n\n", sym
->name
);
567 str_append(help
, _(menu_get_help(menu
)));
568 str_append(help
, "\n");
571 str_append(help
, nohelp_text
);
574 get_symbol_str(help
, sym
);