2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
13 static const char nohelp_text
[] = "There is no help available for this option.";
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
= xmalloc(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
&& current_entry
!= &rootmenu
)
142 prop_warn(prop
, "prompt redefined");
144 /* Apply all upper menus' visibilities to actual prompts. */
145 if(type
== P_PROMPT
) {
146 struct menu
*menu
= current_entry
;
148 while ((menu
= menu
->parent
) != NULL
) {
149 struct expr
*dup_expr
;
151 if (!menu
->visibility
)
154 * Do not add a reference to the
155 * menu's visibility expression but
156 * use a copy of it. Otherwise the
157 * expression reduction functions
158 * will modify expressions that have
159 * multiple references which can
160 * cause unwanted side effects.
162 dup_expr
= expr_copy(menu
->visibility
);
165 = expr_alloc_and(prop
->visible
.expr
,
170 current_entry
->prompt
= prop
;
177 struct property
*menu_add_prompt(enum prop_type type
, char *prompt
, struct expr
*dep
)
179 return menu_add_prop(type
, prompt
, NULL
, dep
);
182 void menu_add_visibility(struct expr
*expr
)
184 current_entry
->visibility
= expr_alloc_and(current_entry
->visibility
,
188 void menu_add_expr(enum prop_type type
, struct expr
*expr
, struct expr
*dep
)
190 menu_add_prop(type
, NULL
, expr
, dep
);
193 void menu_add_symbol(enum prop_type type
, struct symbol
*sym
, struct expr
*dep
)
195 menu_add_prop(type
, NULL
, expr_alloc_symbol(sym
), dep
);
198 void menu_add_option(int token
, char *arg
)
203 zconf_error("symbol '%s' redefines option 'modules'"
204 " already defined by symbol '%s'",
205 current_entry
->sym
->name
,
208 modules_sym
= current_entry
->sym
;
210 case T_OPT_DEFCONFIG_LIST
:
211 if (!sym_defconfig_list
)
212 sym_defconfig_list
= current_entry
->sym
;
213 else if (sym_defconfig_list
!= current_entry
->sym
)
214 zconf_error("trying to redefine defconfig symbol");
222 static int menu_validate_number(struct symbol
*sym
, struct symbol
*sym2
)
224 return sym2
->type
== S_INT
|| sym2
->type
== S_HEX
||
225 (sym2
->type
== S_UNKNOWN
&& sym_string_valid(sym
, sym2
->name
));
228 static void sym_check_prop(struct symbol
*sym
)
230 struct property
*prop
;
232 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
233 switch (prop
->type
) {
235 if ((sym
->type
== S_STRING
|| sym
->type
== S_INT
|| sym
->type
== S_HEX
) &&
236 prop
->expr
->type
!= E_SYMBOL
)
238 "default for config symbol '%s'"
239 " must be a single symbol", sym
->name
);
240 if (prop
->expr
->type
!= E_SYMBOL
)
242 sym2
= prop_get_symbol(prop
);
243 if (sym
->type
== S_HEX
|| sym
->type
== S_INT
) {
244 if (!menu_validate_number(sym
, sym2
))
246 "'%s': number is invalid",
251 sym2
= prop_get_symbol(prop
);
252 if (sym
->type
!= S_BOOLEAN
&& sym
->type
!= S_TRISTATE
)
254 "config symbol '%s' uses select, but is "
255 "not boolean or tristate", sym
->name
);
256 else if (sym2
->type
!= S_UNKNOWN
&&
257 sym2
->type
!= S_BOOLEAN
&&
258 sym2
->type
!= S_TRISTATE
)
260 "'%s' has wrong type. 'select' only "
261 "accept arguments of boolean and "
262 "tristate type", sym2
->name
);
265 if (sym
->type
!= S_INT
&& sym
->type
!= S_HEX
)
266 prop_warn(prop
, "range is only allowed "
267 "for int or hex symbols");
268 if (!menu_validate_number(sym
, prop
->expr
->left
.sym
) ||
269 !menu_validate_number(sym
, prop
->expr
->right
.sym
))
270 prop_warn(prop
, "range is invalid");
278 void menu_finalize(struct menu
*parent
)
280 struct menu
*menu
, *last_menu
;
282 struct property
*prop
;
283 struct expr
*parentdep
, *basedep
, *dep
, *dep2
, **ep
;
287 if (sym
&& sym_is_choice(sym
)) {
288 if (sym
->type
== S_UNKNOWN
) {
289 /* find the first choice value to find out choice type */
290 current_entry
= parent
;
291 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
292 if (menu
->sym
&& menu
->sym
->type
!= S_UNKNOWN
) {
293 menu_set_type(menu
->sym
->type
);
298 /* set the type of the remaining choice values */
299 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
300 current_entry
= menu
;
301 if (menu
->sym
&& menu
->sym
->type
== S_UNKNOWN
)
302 menu_set_type(sym
->type
);
304 parentdep
= expr_alloc_symbol(sym
);
305 } else if (parent
->prompt
)
306 parentdep
= parent
->prompt
->visible
.expr
;
308 parentdep
= parent
->dep
;
310 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
311 basedep
= expr_transform(menu
->dep
);
312 basedep
= expr_alloc_and(expr_copy(parentdep
), basedep
);
313 basedep
= expr_eliminate_dups(basedep
);
316 prop
= menu
->sym
->prop
;
319 for (; prop
; prop
= prop
->next
) {
320 if (prop
->menu
!= menu
)
322 dep
= expr_transform(prop
->visible
.expr
);
323 dep
= expr_alloc_and(expr_copy(basedep
), dep
);
324 dep
= expr_eliminate_dups(dep
);
325 if (menu
->sym
&& menu
->sym
->type
!= S_TRISTATE
)
326 dep
= expr_trans_bool(dep
);
327 prop
->visible
.expr
= dep
;
328 if (prop
->type
== P_SELECT
) {
329 struct symbol
*es
= prop_get_symbol(prop
);
330 es
->rev_dep
.expr
= expr_alloc_or(es
->rev_dep
.expr
,
331 expr_alloc_and(expr_alloc_symbol(menu
->sym
), expr_copy(dep
)));
335 for (menu
= parent
->list
; menu
; menu
= menu
->next
)
338 basedep
= parent
->prompt
? parent
->prompt
->visible
.expr
: NULL
;
339 basedep
= expr_trans_compare(basedep
, E_UNEQUAL
, &symbol_no
);
340 basedep
= expr_eliminate_dups(expr_transform(basedep
));
342 for (menu
= parent
->next
; menu
; menu
= menu
->next
) {
343 dep
= menu
->prompt
? menu
->prompt
->visible
.expr
: menu
->dep
;
344 if (!expr_contains_symbol(dep
, sym
))
346 if (expr_depends_symbol(dep
, sym
))
348 dep
= expr_trans_compare(dep
, E_UNEQUAL
, &symbol_no
);
349 dep
= expr_eliminate_dups(expr_transform(dep
));
350 dep2
= expr_copy(basedep
);
351 expr_eliminate_eq(&dep
, &dep2
);
353 if (!expr_is_yes(dep2
)) {
360 menu
->parent
= parent
;
364 parent
->list
= parent
->next
;
365 parent
->next
= last_menu
->next
;
366 last_menu
->next
= NULL
;
369 sym
->dir_dep
.expr
= expr_alloc_or(sym
->dir_dep
.expr
, parent
->dep
);
371 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
372 if (sym
&& sym_is_choice(sym
) &&
373 menu
->sym
&& !sym_is_choice_value(menu
->sym
)) {
374 current_entry
= menu
;
375 menu
->sym
->flags
|= SYMBOL_CHOICEVAL
;
377 menu_warn(menu
, "choice value must have a prompt");
378 for (prop
= menu
->sym
->prop
; prop
; prop
= prop
->next
) {
379 if (prop
->type
== P_DEFAULT
)
380 prop_warn(prop
, "defaults for choice "
381 "values not supported");
382 if (prop
->menu
== menu
)
384 if (prop
->type
== P_PROMPT
&&
385 prop
->menu
->parent
->sym
!= sym
)
386 prop_warn(prop
, "choice value used outside its choice group");
388 /* Non-tristate choice values of tristate choices must
389 * depend on the choice being set to Y. The choice
390 * values' dependencies were propagated to their
391 * properties above, so the change here must be re-
394 if (sym
->type
== S_TRISTATE
&& menu
->sym
->type
!= S_TRISTATE
) {
395 basedep
= expr_alloc_comp(E_EQUAL
, sym
, &symbol_yes
);
396 menu
->dep
= expr_alloc_and(basedep
, menu
->dep
);
397 for (prop
= menu
->sym
->prop
; prop
; prop
= prop
->next
) {
398 if (prop
->menu
!= menu
)
400 prop
->visible
.expr
= expr_alloc_and(expr_copy(basedep
),
404 menu_add_symbol(P_CHOICE
, sym
, NULL
);
405 prop
= sym_get_choice_prop(sym
);
406 for (ep
= &prop
->expr
; *ep
; ep
= &(*ep
)->left
.expr
)
408 *ep
= expr_alloc_one(E_LIST
, NULL
);
409 (*ep
)->right
.sym
= menu
->sym
;
411 if (menu
->list
&& (!menu
->prompt
|| !menu
->prompt
->text
)) {
412 for (last_menu
= menu
->list
; ; last_menu
= last_menu
->next
) {
413 last_menu
->parent
= parent
;
414 if (!last_menu
->next
)
417 last_menu
->next
= menu
->next
;
418 menu
->next
= menu
->list
;
423 if (sym
&& !(sym
->flags
& SYMBOL_WARNED
)) {
424 if (sym
->type
== S_UNKNOWN
)
425 menu_warn(parent
, "config symbol defined without type");
427 if (sym_is_choice(sym
) && !parent
->prompt
)
428 menu_warn(parent
, "choice must have a prompt");
430 /* Check properties connected to this symbol */
432 sym
->flags
|= SYMBOL_WARNED
;
435 if (sym
&& !sym_is_optional(sym
) && parent
->prompt
) {
436 sym
->rev_dep
.expr
= expr_alloc_or(sym
->rev_dep
.expr
,
437 expr_alloc_and(parent
->prompt
->visible
.expr
,
438 expr_alloc_symbol(&symbol_mod
)));
442 bool menu_has_prompt(struct menu
*menu
)
450 * Determine if a menu is empty.
451 * A menu is considered empty if it contains no or only
454 bool menu_is_empty(struct menu
*menu
)
458 for (child
= menu
->list
; child
; child
= child
->next
) {
459 if (menu_is_visible(child
))
465 bool menu_is_visible(struct menu
*menu
)
474 if (menu
->visibility
) {
475 if (expr_calc_value(menu
->visibility
) == no
)
482 visible
= menu
->prompt
->visible
.tri
;
484 visible
= menu
->prompt
->visible
.tri
= expr_calc_value(menu
->prompt
->visible
.expr
);
489 if (!sym
|| sym_get_tristate_value(menu
->sym
) == no
)
492 for (child
= menu
->list
; child
; child
= child
->next
) {
493 if (menu_is_visible(child
)) {
495 sym
->flags
|= SYMBOL_DEF_USER
;
503 const char *menu_get_prompt(struct menu
*menu
)
506 return menu
->prompt
->text
;
508 return menu
->sym
->name
;
512 struct menu
*menu_get_root_menu(struct menu
*menu
)
517 struct menu
*menu_get_parent_menu(struct menu
*menu
)
521 for (; menu
!= &rootmenu
; menu
= menu
->parent
) {
522 type
= menu
->prompt
? menu
->prompt
->type
: 0;
529 bool menu_has_help(struct menu
*menu
)
531 return menu
->help
!= NULL
;
534 const char *menu_get_help(struct menu
*menu
)
542 static void get_prompt_str(struct gstr
*r
, struct property
*prop
,
543 struct list_head
*head
)
546 struct menu
*submenu
[8], *menu
, *location
= NULL
;
547 struct jump_key
*jump
;
549 str_printf(r
, _("Prompt: %s\n"), _(prop
->text
));
550 menu
= prop
->menu
->parent
;
551 for (i
= 0; menu
!= &rootmenu
&& i
< 8; menu
= menu
->parent
) {
552 bool accessible
= menu_is_visible(menu
);
555 if (location
== NULL
&& accessible
)
558 if (head
&& location
) {
559 jump
= xmalloc(sizeof(struct jump_key
));
561 if (menu_is_visible(prop
->menu
)) {
563 * There is not enough room to put the hint at the
564 * beginning of the "Prompt" line. Put the hint on the
565 * last "Location" line even when it would belong on
568 jump
->target
= prop
->menu
;
570 jump
->target
= location
;
572 if (list_empty(head
))
575 jump
->index
= list_entry(head
->prev
, struct jump_key
,
578 list_add_tail(&jump
->entries
, head
);
582 str_printf(r
, _(" Location:\n"));
583 for (j
= 4; --i
>= 0; j
+= 2) {
585 if (head
&& location
&& menu
== location
)
586 jump
->offset
= r
->len
- 1;
587 str_printf(r
, "%*c-> %s", j
, ' ',
588 _(menu_get_prompt(menu
)));
590 str_printf(r
, " (%s [=%s])", menu
->sym
->name
?
591 menu
->sym
->name
: _("<choice>"),
592 sym_get_string_value(menu
->sym
));
600 * get peoperty of type P_SYMBOL
602 static struct property
*get_symbol_prop(struct symbol
*sym
)
604 struct property
*prop
= NULL
;
606 for_all_properties(sym
, prop
, P_SYMBOL
)
612 * head is optional and may be NULL
614 void get_symbol_str(struct gstr
*r
, struct symbol
*sym
,
615 struct list_head
*head
)
618 struct property
*prop
;
620 if (sym
&& sym
->name
) {
621 str_printf(r
, "Symbol: %s [=%s]\n", sym
->name
,
622 sym_get_string_value(sym
));
623 str_printf(r
, "Type : %s\n", sym_type_name(sym
->type
));
624 if (sym
->type
== S_INT
|| sym
->type
== S_HEX
) {
625 prop
= sym_get_range_prop(sym
);
627 str_printf(r
, "Range : ");
628 expr_gstr_print(prop
->expr
, r
);
633 for_all_prompts(sym
, prop
)
634 get_prompt_str(r
, prop
, head
);
636 prop
= get_symbol_prop(sym
);
638 str_printf(r
, _(" Defined at %s:%d\n"), prop
->menu
->file
->name
,
640 if (!expr_is_yes(prop
->visible
.expr
)) {
641 str_append(r
, _(" Depends on: "));
642 expr_gstr_print(prop
->visible
.expr
, r
);
648 for_all_properties(sym
, prop
, P_SELECT
) {
650 str_append(r
, " Selects: ");
653 str_printf(r
, " && ");
654 expr_gstr_print(prop
->expr
, r
);
658 if (sym
->rev_dep
.expr
) {
659 str_append(r
, _(" Selected by: "));
660 expr_gstr_print(sym
->rev_dep
.expr
, r
);
663 str_append(r
, "\n\n");
666 struct gstr
get_relations_str(struct symbol
**sym_arr
, struct list_head
*head
)
669 struct gstr res
= str_new();
672 for (i
= 0; sym_arr
&& (sym
= sym_arr
[i
]); i
++)
673 get_symbol_str(&res
, sym
, head
);
675 str_append(&res
, _("No matches found.\n"));
680 void menu_get_ext_help(struct menu
*menu
, struct gstr
*help
)
682 struct symbol
*sym
= menu
->sym
;
683 const char *help_text
= nohelp_text
;
685 if (menu_has_help(menu
)) {
687 str_printf(help
, "%s%s:\n\n", CONFIG_
, sym
->name
);
688 help_text
= menu_get_help(menu
);
690 str_printf(help
, "%s\n", _(help_text
));
692 get_symbol_str(help
, sym
, NULL
);
This page took 0.044266 seconds and 6 git commands to generate.