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
,
123 "ignoring type redefinition of '%s' from '%s' to '%s'",
124 sym
->name
? sym
->name
: "<choice>",
125 sym_type_name(sym
->type
), sym_type_name(type
));
128 struct property
*menu_add_prop(enum prop_type type
, char *prompt
, struct expr
*expr
, struct expr
*dep
)
130 struct property
*prop
= prop_alloc(type
, current_entry
->sym
);
132 prop
->menu
= current_entry
;
134 prop
->visible
.expr
= menu_check_dep(dep
);
137 if (isspace(*prompt
)) {
138 prop_warn(prop
, "leading whitespace ignored");
139 while (isspace(*prompt
))
142 if (current_entry
->prompt
&& current_entry
!= &rootmenu
)
143 prop_warn(prop
, "prompt redefined");
145 /* Apply all upper menus' visibilities to actual prompts. */
146 if(type
== P_PROMPT
) {
147 struct menu
*menu
= current_entry
;
149 while ((menu
= menu
->parent
) != NULL
) {
150 struct expr
*dup_expr
;
152 if (!menu
->visibility
)
155 * Do not add a reference to the
156 * menu's visibility expression but
157 * use a copy of it. Otherwise the
158 * expression reduction functions
159 * will modify expressions that have
160 * multiple references which can
161 * cause unwanted side effects.
163 dup_expr
= expr_copy(menu
->visibility
);
166 = expr_alloc_and(prop
->visible
.expr
,
171 current_entry
->prompt
= prop
;
178 struct property
*menu_add_prompt(enum prop_type type
, char *prompt
, struct expr
*dep
)
180 return menu_add_prop(type
, prompt
, NULL
, dep
);
183 void menu_add_visibility(struct expr
*expr
)
185 current_entry
->visibility
= expr_alloc_and(current_entry
->visibility
,
189 void menu_add_expr(enum prop_type type
, struct expr
*expr
, struct expr
*dep
)
191 menu_add_prop(type
, NULL
, expr
, dep
);
194 void menu_add_symbol(enum prop_type type
, struct symbol
*sym
, struct expr
*dep
)
196 menu_add_prop(type
, NULL
, expr_alloc_symbol(sym
), dep
);
199 void menu_add_option(int token
, char *arg
)
204 zconf_error("symbol '%s' redefines option 'modules'"
205 " already defined by symbol '%s'",
206 current_entry
->sym
->name
,
209 modules_sym
= current_entry
->sym
;
211 case T_OPT_DEFCONFIG_LIST
:
212 if (!sym_defconfig_list
)
213 sym_defconfig_list
= current_entry
->sym
;
214 else if (sym_defconfig_list
!= current_entry
->sym
)
215 zconf_error("trying to redefine defconfig symbol");
223 static int menu_validate_number(struct symbol
*sym
, struct symbol
*sym2
)
225 return sym2
->type
== S_INT
|| sym2
->type
== S_HEX
||
226 (sym2
->type
== S_UNKNOWN
&& sym_string_valid(sym
, sym2
->name
));
229 static void sym_check_prop(struct symbol
*sym
)
231 struct property
*prop
;
233 for (prop
= sym
->prop
; prop
; prop
= prop
->next
) {
234 switch (prop
->type
) {
236 if ((sym
->type
== S_STRING
|| sym
->type
== S_INT
|| sym
->type
== S_HEX
) &&
237 prop
->expr
->type
!= E_SYMBOL
)
239 "default for config symbol '%s'"
240 " must be a single symbol", sym
->name
);
241 if (prop
->expr
->type
!= E_SYMBOL
)
243 sym2
= prop_get_symbol(prop
);
244 if (sym
->type
== S_HEX
|| sym
->type
== S_INT
) {
245 if (!menu_validate_number(sym
, sym2
))
247 "'%s': number is invalid",
252 sym2
= prop_get_symbol(prop
);
253 if (sym
->type
!= S_BOOLEAN
&& sym
->type
!= S_TRISTATE
)
255 "config symbol '%s' uses select, but is "
256 "not boolean or tristate", sym
->name
);
257 else if (sym2
->type
!= S_UNKNOWN
&&
258 sym2
->type
!= S_BOOLEAN
&&
259 sym2
->type
!= S_TRISTATE
)
261 "'%s' has wrong type. 'select' only "
262 "accept arguments of boolean and "
263 "tristate type", sym2
->name
);
266 if (sym
->type
!= S_INT
&& sym
->type
!= S_HEX
)
267 prop_warn(prop
, "range is only allowed "
268 "for int or hex symbols");
269 if (!menu_validate_number(sym
, prop
->expr
->left
.sym
) ||
270 !menu_validate_number(sym
, prop
->expr
->right
.sym
))
271 prop_warn(prop
, "range is invalid");
279 void menu_finalize(struct menu
*parent
)
281 struct menu
*menu
, *last_menu
;
283 struct property
*prop
;
284 struct expr
*parentdep
, *basedep
, *dep
, *dep2
, **ep
;
288 if (sym
&& sym_is_choice(sym
)) {
289 if (sym
->type
== S_UNKNOWN
) {
290 /* find the first choice value to find out choice type */
291 current_entry
= parent
;
292 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
293 if (menu
->sym
&& menu
->sym
->type
!= S_UNKNOWN
) {
294 menu_set_type(menu
->sym
->type
);
299 /* set the type of the remaining choice values */
300 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
301 current_entry
= menu
;
302 if (menu
->sym
&& menu
->sym
->type
== S_UNKNOWN
)
303 menu_set_type(sym
->type
);
305 parentdep
= expr_alloc_symbol(sym
);
306 } else if (parent
->prompt
)
307 parentdep
= parent
->prompt
->visible
.expr
;
309 parentdep
= parent
->dep
;
311 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
312 basedep
= expr_transform(menu
->dep
);
313 basedep
= expr_alloc_and(expr_copy(parentdep
), basedep
);
314 basedep
= expr_eliminate_dups(basedep
);
317 prop
= menu
->sym
->prop
;
320 for (; prop
; prop
= prop
->next
) {
321 if (prop
->menu
!= menu
)
323 dep
= expr_transform(prop
->visible
.expr
);
324 dep
= expr_alloc_and(expr_copy(basedep
), dep
);
325 dep
= expr_eliminate_dups(dep
);
326 if (menu
->sym
&& menu
->sym
->type
!= S_TRISTATE
)
327 dep
= expr_trans_bool(dep
);
328 prop
->visible
.expr
= dep
;
329 if (prop
->type
== P_SELECT
) {
330 struct symbol
*es
= prop_get_symbol(prop
);
331 es
->rev_dep
.expr
= expr_alloc_or(es
->rev_dep
.expr
,
332 expr_alloc_and(expr_alloc_symbol(menu
->sym
), expr_copy(dep
)));
336 for (menu
= parent
->list
; menu
; menu
= menu
->next
)
339 basedep
= parent
->prompt
? parent
->prompt
->visible
.expr
: NULL
;
340 basedep
= expr_trans_compare(basedep
, E_UNEQUAL
, &symbol_no
);
341 basedep
= expr_eliminate_dups(expr_transform(basedep
));
343 for (menu
= parent
->next
; menu
; menu
= menu
->next
) {
344 dep
= menu
->prompt
? menu
->prompt
->visible
.expr
: menu
->dep
;
345 if (!expr_contains_symbol(dep
, sym
))
347 if (expr_depends_symbol(dep
, sym
))
349 dep
= expr_trans_compare(dep
, E_UNEQUAL
, &symbol_no
);
350 dep
= expr_eliminate_dups(expr_transform(dep
));
351 dep2
= expr_copy(basedep
);
352 expr_eliminate_eq(&dep
, &dep2
);
354 if (!expr_is_yes(dep2
)) {
361 menu
->parent
= parent
;
365 parent
->list
= parent
->next
;
366 parent
->next
= last_menu
->next
;
367 last_menu
->next
= NULL
;
370 sym
->dir_dep
.expr
= expr_alloc_or(sym
->dir_dep
.expr
, parent
->dep
);
372 for (menu
= parent
->list
; menu
; menu
= menu
->next
) {
373 if (sym
&& sym_is_choice(sym
) &&
374 menu
->sym
&& !sym_is_choice_value(menu
->sym
)) {
375 current_entry
= menu
;
376 menu
->sym
->flags
|= SYMBOL_CHOICEVAL
;
378 menu_warn(menu
, "choice value must have a prompt");
379 for (prop
= menu
->sym
->prop
; prop
; prop
= prop
->next
) {
380 if (prop
->type
== P_DEFAULT
)
381 prop_warn(prop
, "defaults for choice "
382 "values not supported");
383 if (prop
->menu
== menu
)
385 if (prop
->type
== P_PROMPT
&&
386 prop
->menu
->parent
->sym
!= sym
)
387 prop_warn(prop
, "choice value used outside its choice group");
389 /* Non-tristate choice values of tristate choices must
390 * depend on the choice being set to Y. The choice
391 * values' dependencies were propagated to their
392 * properties above, so the change here must be re-
395 if (sym
->type
== S_TRISTATE
&& menu
->sym
->type
!= S_TRISTATE
) {
396 basedep
= expr_alloc_comp(E_EQUAL
, sym
, &symbol_yes
);
397 menu
->dep
= expr_alloc_and(basedep
, menu
->dep
);
398 for (prop
= menu
->sym
->prop
; prop
; prop
= prop
->next
) {
399 if (prop
->menu
!= menu
)
401 prop
->visible
.expr
= expr_alloc_and(expr_copy(basedep
),
405 menu_add_symbol(P_CHOICE
, sym
, NULL
);
406 prop
= sym_get_choice_prop(sym
);
407 for (ep
= &prop
->expr
; *ep
; ep
= &(*ep
)->left
.expr
)
409 *ep
= expr_alloc_one(E_LIST
, NULL
);
410 (*ep
)->right
.sym
= menu
->sym
;
412 if (menu
->list
&& (!menu
->prompt
|| !menu
->prompt
->text
)) {
413 for (last_menu
= menu
->list
; ; last_menu
= last_menu
->next
) {
414 last_menu
->parent
= parent
;
415 if (!last_menu
->next
)
418 last_menu
->next
= menu
->next
;
419 menu
->next
= menu
->list
;
424 if (sym
&& !(sym
->flags
& SYMBOL_WARNED
)) {
425 if (sym
->type
== S_UNKNOWN
)
426 menu_warn(parent
, "config symbol defined without type");
428 if (sym_is_choice(sym
) && !parent
->prompt
)
429 menu_warn(parent
, "choice must have a prompt");
431 /* Check properties connected to this symbol */
433 sym
->flags
|= SYMBOL_WARNED
;
436 if (sym
&& !sym_is_optional(sym
) && parent
->prompt
) {
437 sym
->rev_dep
.expr
= expr_alloc_or(sym
->rev_dep
.expr
,
438 expr_alloc_and(parent
->prompt
->visible
.expr
,
439 expr_alloc_symbol(&symbol_mod
)));
443 bool menu_has_prompt(struct menu
*menu
)
451 * Determine if a menu is empty.
452 * A menu is considered empty if it contains no or only
455 bool menu_is_empty(struct menu
*menu
)
459 for (child
= menu
->list
; child
; child
= child
->next
) {
460 if (menu_is_visible(child
))
466 bool menu_is_visible(struct menu
*menu
)
475 if (menu
->visibility
) {
476 if (expr_calc_value(menu
->visibility
) == no
)
483 visible
= menu
->prompt
->visible
.tri
;
485 visible
= menu
->prompt
->visible
.tri
= expr_calc_value(menu
->prompt
->visible
.expr
);
490 if (!sym
|| sym_get_tristate_value(menu
->sym
) == no
)
493 for (child
= menu
->list
; child
; child
= child
->next
) {
494 if (menu_is_visible(child
)) {
496 sym
->flags
|= SYMBOL_DEF_USER
;
504 const char *menu_get_prompt(struct menu
*menu
)
507 return menu
->prompt
->text
;
509 return menu
->sym
->name
;
513 struct menu
*menu_get_root_menu(struct menu
*menu
)
518 struct menu
*menu_get_parent_menu(struct menu
*menu
)
522 for (; menu
!= &rootmenu
; menu
= menu
->parent
) {
523 type
= menu
->prompt
? menu
->prompt
->type
: 0;
530 bool menu_has_help(struct menu
*menu
)
532 return menu
->help
!= NULL
;
535 const char *menu_get_help(struct menu
*menu
)
543 static void get_prompt_str(struct gstr
*r
, struct property
*prop
,
544 struct list_head
*head
)
547 struct menu
*submenu
[8], *menu
, *location
= NULL
;
548 struct jump_key
*jump
;
550 str_printf(r
, _("Prompt: %s\n"), _(prop
->text
));
551 menu
= prop
->menu
->parent
;
552 for (i
= 0; menu
!= &rootmenu
&& i
< 8; menu
= menu
->parent
) {
553 bool accessible
= menu_is_visible(menu
);
556 if (location
== NULL
&& accessible
)
559 if (head
&& location
) {
560 jump
= xmalloc(sizeof(struct jump_key
));
562 if (menu_is_visible(prop
->menu
)) {
564 * There is not enough room to put the hint at the
565 * beginning of the "Prompt" line. Put the hint on the
566 * last "Location" line even when it would belong on
569 jump
->target
= prop
->menu
;
571 jump
->target
= location
;
573 if (list_empty(head
))
576 jump
->index
= list_entry(head
->prev
, struct jump_key
,
579 list_add_tail(&jump
->entries
, head
);
583 str_printf(r
, _(" Location:\n"));
584 for (j
= 4; --i
>= 0; j
+= 2) {
586 if (head
&& location
&& menu
== location
)
587 jump
->offset
= strlen(r
->s
);
588 str_printf(r
, "%*c-> %s", j
, ' ',
589 _(menu_get_prompt(menu
)));
591 str_printf(r
, " (%s [=%s])", menu
->sym
->name
?
592 menu
->sym
->name
: _("<choice>"),
593 sym_get_string_value(menu
->sym
));
601 * get property of type P_SYMBOL
603 static struct property
*get_symbol_prop(struct symbol
*sym
)
605 struct property
*prop
= NULL
;
607 for_all_properties(sym
, prop
, P_SYMBOL
)
613 * head is optional and may be NULL
615 void get_symbol_str(struct gstr
*r
, struct symbol
*sym
,
616 struct list_head
*head
)
619 struct property
*prop
;
621 if (sym
&& sym
->name
) {
622 str_printf(r
, "Symbol: %s [=%s]\n", sym
->name
,
623 sym_get_string_value(sym
));
624 str_printf(r
, "Type : %s\n", sym_type_name(sym
->type
));
625 if (sym
->type
== S_INT
|| sym
->type
== S_HEX
) {
626 prop
= sym_get_range_prop(sym
);
628 str_printf(r
, "Range : ");
629 expr_gstr_print(prop
->expr
, r
);
634 for_all_prompts(sym
, prop
)
635 get_prompt_str(r
, prop
, head
);
637 prop
= get_symbol_prop(sym
);
639 str_printf(r
, _(" Defined at %s:%d\n"), prop
->menu
->file
->name
,
641 if (!expr_is_yes(prop
->visible
.expr
)) {
642 str_append(r
, _(" Depends on: "));
643 expr_gstr_print(prop
->visible
.expr
, r
);
649 for_all_properties(sym
, prop
, P_SELECT
) {
651 str_append(r
, " Selects: ");
654 str_printf(r
, " && ");
655 expr_gstr_print(prop
->expr
, r
);
659 if (sym
->rev_dep
.expr
) {
660 str_append(r
, _(" Selected by: "));
661 expr_gstr_print(sym
->rev_dep
.expr
, r
);
664 str_append(r
, "\n\n");
667 struct gstr
get_relations_str(struct symbol
**sym_arr
, struct list_head
*head
)
670 struct gstr res
= str_new();
673 for (i
= 0; sym_arr
&& (sym
= sym_arr
[i
]); i
++)
674 get_symbol_str(&res
, sym
, head
);
676 str_append(&res
, _("No matches found.\n"));
681 void menu_get_ext_help(struct menu
*menu
, struct gstr
*help
)
683 struct symbol
*sym
= menu
->sym
;
684 const char *help_text
= nohelp_text
;
686 if (menu_has_help(menu
)) {
688 str_printf(help
, "%s%s:\n\n", CONFIG_
, sym
->name
);
689 help_text
= menu_get_help(menu
);
691 str_printf(help
, "%s\n", _(help_text
));
693 get_symbol_str(help
, sym
, NULL
);
This page took 0.044275 seconds and 6 git commands to generate.