1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org> |
4 | */ |
5 | |
6 | #include <ctype.h> |
7 | #include <stdarg.h> |
8 | #include <stdlib.h> |
9 | #include <string.h> |
10 | |
11 | #include "lkc.h" |
12 | #include "internal.h" |
13 | #include "list.h" |
14 | |
15 | static const char nohelp_text[] = "There is no help available for this option." ; |
16 | |
17 | struct menu ; |
18 | static struct menu **last_entry_ptr; |
19 | |
20 | void (struct menu *, const char *fmt, ...) |
21 | { |
22 | va_list ap; |
23 | va_start(ap, fmt); |
24 | fprintf(stderr, "%s:%d:warning: " , menu->filename, menu->lineno); |
25 | vfprintf(stderr, fmt, ap); |
26 | fprintf(stderr, "\n" ); |
27 | va_end(ap); |
28 | } |
29 | |
30 | static void prop_warn(struct property *prop, const char *fmt, ...) |
31 | { |
32 | va_list ap; |
33 | va_start(ap, fmt); |
34 | fprintf(stderr, "%s:%d:warning: " , prop->filename, prop->lineno); |
35 | vfprintf(stderr, fmt, ap); |
36 | fprintf(stderr, "\n" ); |
37 | va_end(ap); |
38 | } |
39 | |
40 | void (void) |
41 | { |
42 | current_entry = current_menu = &rootmenu; |
43 | last_entry_ptr = &rootmenu.list; |
44 | } |
45 | |
46 | void (struct symbol *sym) |
47 | { |
48 | struct menu *; |
49 | |
50 | menu = xmalloc(sizeof(*menu)); |
51 | memset(menu, 0, sizeof(*menu)); |
52 | menu->sym = sym; |
53 | menu->parent = current_menu; |
54 | menu->filename = cur_filename; |
55 | menu->lineno = cur_lineno; |
56 | |
57 | *last_entry_ptr = menu; |
58 | last_entry_ptr = &menu->next; |
59 | current_entry = menu; |
60 | if (sym) { |
61 | menu_add_symbol(type: P_SYMBOL, sym, dep: NULL); |
62 | list_add_tail(new: &menu->link, head: &sym->menus); |
63 | } |
64 | } |
65 | |
66 | struct menu *(void) |
67 | { |
68 | last_entry_ptr = ¤t_entry->list; |
69 | current_menu = current_entry; |
70 | return current_menu; |
71 | } |
72 | |
73 | void (void) |
74 | { |
75 | last_entry_ptr = ¤t_menu->next; |
76 | current_menu = current_menu->parent; |
77 | } |
78 | |
79 | /* |
80 | * Rewrites 'm' to 'm' && MODULES, so that it evaluates to 'n' when running |
81 | * without modules |
82 | */ |
83 | static struct expr *rewrite_m(struct expr *e) |
84 | { |
85 | if (!e) |
86 | return e; |
87 | |
88 | switch (e->type) { |
89 | case E_NOT: |
90 | e->left.expr = rewrite_m(e: e->left.expr); |
91 | break; |
92 | case E_OR: |
93 | case E_AND: |
94 | e->left.expr = rewrite_m(e: e->left.expr); |
95 | e->right.expr = rewrite_m(e: e->right.expr); |
96 | break; |
97 | case E_SYMBOL: |
98 | /* change 'm' into 'm' && MODULES */ |
99 | if (e->left.sym == &symbol_mod) |
100 | return expr_alloc_and(e1: e, e2: expr_alloc_symbol(sym: modules_sym)); |
101 | break; |
102 | default: |
103 | break; |
104 | } |
105 | return e; |
106 | } |
107 | |
108 | void (struct expr *dep) |
109 | { |
110 | current_entry->dep = expr_alloc_and(e1: current_entry->dep, e2: dep); |
111 | } |
112 | |
113 | void (int type) |
114 | { |
115 | struct symbol *sym = current_entry->sym; |
116 | |
117 | if (sym->type == type) |
118 | return; |
119 | if (sym->type == S_UNKNOWN) { |
120 | sym->type = type; |
121 | return; |
122 | } |
123 | menu_warn(menu: current_entry, |
124 | fmt: "ignoring type redefinition of '%s' from '%s' to '%s'" , |
125 | sym->name ? sym->name : "<choice>" , |
126 | sym_type_name(type: sym->type), sym_type_name(type)); |
127 | } |
128 | |
129 | static struct property *(enum prop_type type, struct expr *expr, |
130 | struct expr *dep) |
131 | { |
132 | struct property *prop; |
133 | |
134 | prop = xmalloc(sizeof(*prop)); |
135 | memset(prop, 0, sizeof(*prop)); |
136 | prop->type = type; |
137 | prop->filename = cur_filename; |
138 | prop->lineno = cur_lineno; |
139 | prop->menu = current_entry; |
140 | prop->expr = expr; |
141 | prop->visible.expr = dep; |
142 | |
143 | /* append property to the prop list of symbol */ |
144 | if (current_entry->sym) { |
145 | struct property **propp; |
146 | |
147 | for (propp = ¤t_entry->sym->prop; |
148 | *propp; |
149 | propp = &(*propp)->next) |
150 | ; |
151 | *propp = prop; |
152 | } |
153 | |
154 | return prop; |
155 | } |
156 | |
157 | struct property *(enum prop_type type, char *prompt, |
158 | struct expr *dep) |
159 | { |
160 | struct property *prop = menu_add_prop(type, expr: NULL, dep); |
161 | |
162 | if (isspace(*prompt)) { |
163 | prop_warn(prop, fmt: "leading whitespace ignored" ); |
164 | while (isspace(*prompt)) |
165 | prompt++; |
166 | } |
167 | if (current_entry->prompt) |
168 | prop_warn(prop, fmt: "prompt redefined" ); |
169 | |
170 | /* Apply all upper menus' visibilities to actual prompts. */ |
171 | if (type == P_PROMPT) { |
172 | struct menu * = current_entry; |
173 | |
174 | while ((menu = menu->parent) != NULL) { |
175 | struct expr *dup_expr; |
176 | |
177 | if (!menu->visibility) |
178 | continue; |
179 | /* |
180 | * Do not add a reference to the menu's visibility |
181 | * expression but use a copy of it. Otherwise the |
182 | * expression reduction functions will modify |
183 | * expressions that have multiple references which |
184 | * can cause unwanted side effects. |
185 | */ |
186 | dup_expr = expr_copy(org: menu->visibility); |
187 | |
188 | prop->visible.expr = expr_alloc_and(e1: prop->visible.expr, |
189 | e2: dup_expr); |
190 | } |
191 | } |
192 | |
193 | current_entry->prompt = prop; |
194 | prop->text = prompt; |
195 | |
196 | return prop; |
197 | } |
198 | |
199 | void (struct expr *expr) |
200 | { |
201 | current_entry->visibility = expr_alloc_and(e1: current_entry->visibility, |
202 | e2: expr); |
203 | } |
204 | |
205 | void (enum prop_type type, struct expr *expr, struct expr *dep) |
206 | { |
207 | menu_add_prop(type, expr, dep); |
208 | } |
209 | |
210 | void (enum prop_type type, struct symbol *sym, struct expr *dep) |
211 | { |
212 | menu_add_prop(type, expr: expr_alloc_symbol(sym), dep); |
213 | } |
214 | |
215 | static int (struct symbol *sym, struct symbol *sym2) |
216 | { |
217 | return sym2->type == S_INT || sym2->type == S_HEX || |
218 | (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name)); |
219 | } |
220 | |
221 | static void sym_check_prop(struct symbol *sym) |
222 | { |
223 | struct property *prop; |
224 | struct symbol *sym2; |
225 | char *use; |
226 | |
227 | for (prop = sym->prop; prop; prop = prop->next) { |
228 | switch (prop->type) { |
229 | case P_DEFAULT: |
230 | if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) && |
231 | prop->expr->type != E_SYMBOL) |
232 | prop_warn(prop, |
233 | fmt: "default for config symbol '%s'" |
234 | " must be a single symbol" , sym->name); |
235 | if (prop->expr->type != E_SYMBOL) |
236 | break; |
237 | sym2 = prop_get_symbol(prop); |
238 | if (sym->type == S_HEX || sym->type == S_INT) { |
239 | if (!menu_validate_number(sym, sym2)) |
240 | prop_warn(prop, |
241 | fmt: "'%s': number is invalid" , |
242 | sym->name); |
243 | } |
244 | if (sym_is_choice(sym)) { |
245 | struct property *choice_prop = |
246 | sym_get_choice_prop(sym: sym2); |
247 | |
248 | if (!choice_prop || |
249 | prop_get_symbol(prop: choice_prop) != sym) |
250 | prop_warn(prop, |
251 | fmt: "choice default symbol '%s' is not contained in the choice" , |
252 | sym2->name); |
253 | } |
254 | break; |
255 | case P_SELECT: |
256 | case P_IMPLY: |
257 | use = prop->type == P_SELECT ? "select" : "imply" ; |
258 | sym2 = prop_get_symbol(prop); |
259 | if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE) |
260 | prop_warn(prop, |
261 | fmt: "config symbol '%s' uses %s, but is " |
262 | "not bool or tristate" , sym->name, use); |
263 | else if (sym2->type != S_UNKNOWN && |
264 | sym2->type != S_BOOLEAN && |
265 | sym2->type != S_TRISTATE) |
266 | prop_warn(prop, |
267 | fmt: "'%s' has wrong type. '%s' only " |
268 | "accept arguments of bool and " |
269 | "tristate type" , sym2->name, use); |
270 | break; |
271 | case P_RANGE: |
272 | if (sym->type != S_INT && sym->type != S_HEX) |
273 | prop_warn(prop, fmt: "range is only allowed " |
274 | "for int or hex symbols" ); |
275 | if (!menu_validate_number(sym, sym2: prop->expr->left.sym) || |
276 | !menu_validate_number(sym, sym2: prop->expr->right.sym)) |
277 | prop_warn(prop, fmt: "range is invalid" ); |
278 | break; |
279 | default: |
280 | ; |
281 | } |
282 | } |
283 | } |
284 | |
285 | static void (struct menu *parent, bool inside_choice) |
286 | { |
287 | struct menu *, *; |
288 | struct symbol *sym; |
289 | struct property *prop; |
290 | struct expr *parentdep, *basedep, *dep, *dep2, **ep; |
291 | |
292 | sym = parent->sym; |
293 | if (parent->list) { |
294 | /* |
295 | * This menu node has children. We (recursively) process them |
296 | * and propagate parent dependencies before moving on. |
297 | */ |
298 | |
299 | bool is_choice = false; |
300 | |
301 | if (sym && sym_is_choice(sym)) |
302 | is_choice = true; |
303 | |
304 | if (is_choice) { |
305 | if (sym->type == S_UNKNOWN) { |
306 | /* find the first choice value to find out choice type */ |
307 | current_entry = parent; |
308 | for (menu = parent->list; menu; menu = menu->next) { |
309 | if (menu->sym && menu->sym->type != S_UNKNOWN) { |
310 | menu_set_type(type: menu->sym->type); |
311 | break; |
312 | } |
313 | } |
314 | } |
315 | |
316 | /* |
317 | * Use the choice itself as the parent dependency of |
318 | * the contained items. This turns the mode of the |
319 | * choice into an upper bound on the visibility of the |
320 | * choice value symbols. |
321 | */ |
322 | parentdep = expr_alloc_symbol(sym); |
323 | } else { |
324 | /* Menu node for 'menu', 'if' */ |
325 | parentdep = parent->dep; |
326 | } |
327 | |
328 | /* For each child menu node... */ |
329 | for (menu = parent->list; menu; menu = menu->next) { |
330 | /* |
331 | * Propagate parent dependencies to the child menu |
332 | * node, also rewriting and simplifying expressions |
333 | */ |
334 | basedep = rewrite_m(e: menu->dep); |
335 | basedep = expr_transform(e: basedep); |
336 | basedep = expr_alloc_and(e1: expr_copy(org: parentdep), e2: basedep); |
337 | basedep = expr_eliminate_dups(e: basedep); |
338 | menu->dep = basedep; |
339 | |
340 | if (menu->sym) |
341 | /* |
342 | * Note: For symbols, all prompts are included |
343 | * too in the symbol's own property list |
344 | */ |
345 | prop = menu->sym->prop; |
346 | else |
347 | /* |
348 | * For non-symbol menu nodes, we just need to |
349 | * handle the prompt |
350 | */ |
351 | prop = menu->prompt; |
352 | |
353 | /* For each property... */ |
354 | for (; prop; prop = prop->next) { |
355 | if (prop->menu != menu) |
356 | /* |
357 | * Two possibilities: |
358 | * |
359 | * 1. The property lacks dependencies |
360 | * and so isn't location-specific, |
361 | * e.g. an 'option' |
362 | * |
363 | * 2. The property belongs to a symbol |
364 | * defined in multiple locations and |
365 | * is from some other location. It |
366 | * will be handled there in that |
367 | * case. |
368 | * |
369 | * Skip the property. |
370 | */ |
371 | continue; |
372 | |
373 | /* |
374 | * Propagate parent dependencies to the |
375 | * property's condition, rewriting and |
376 | * simplifying expressions at the same time |
377 | */ |
378 | dep = rewrite_m(e: prop->visible.expr); |
379 | dep = expr_transform(e: dep); |
380 | dep = expr_alloc_and(e1: expr_copy(org: basedep), e2: dep); |
381 | dep = expr_eliminate_dups(e: dep); |
382 | if (menu->sym && menu->sym->type != S_TRISTATE) |
383 | dep = expr_trans_bool(e: dep); |
384 | prop->visible.expr = dep; |
385 | |
386 | /* |
387 | * Handle selects and implies, which modify the |
388 | * dependencies of the selected/implied symbol |
389 | */ |
390 | if (prop->type == P_SELECT) { |
391 | struct symbol *es = prop_get_symbol(prop); |
392 | es->rev_dep.expr = expr_alloc_or(e1: es->rev_dep.expr, |
393 | e2: expr_alloc_and(e1: expr_alloc_symbol(sym: menu->sym), e2: expr_copy(org: dep))); |
394 | } else if (prop->type == P_IMPLY) { |
395 | struct symbol *es = prop_get_symbol(prop); |
396 | es->implied.expr = expr_alloc_or(e1: es->implied.expr, |
397 | e2: expr_alloc_and(e1: expr_alloc_symbol(sym: menu->sym), e2: expr_copy(org: dep))); |
398 | } |
399 | } |
400 | } |
401 | |
402 | if (is_choice) |
403 | expr_free(e: parentdep); |
404 | |
405 | /* |
406 | * Recursively process children in the same fashion before |
407 | * moving on |
408 | */ |
409 | for (menu = parent->list; menu; menu = menu->next) |
410 | _menu_finalize(menu, is_choice); |
411 | } else if (!inside_choice && sym) { |
412 | /* |
413 | * Automatic submenu creation. If sym is a symbol and A, B, C, |
414 | * ... are consecutive items (symbols, menus, ifs, etc.) that |
415 | * all depend on sym, then the following menu structure is |
416 | * created: |
417 | * |
418 | * sym |
419 | * +-A |
420 | * +-B |
421 | * +-C |
422 | * ... |
423 | * |
424 | * This also works recursively, giving the following structure |
425 | * if A is a symbol and B depends on A: |
426 | * |
427 | * sym |
428 | * +-A |
429 | * | +-B |
430 | * +-C |
431 | * ... |
432 | */ |
433 | |
434 | basedep = parent->prompt ? parent->prompt->visible.expr : NULL; |
435 | basedep = expr_trans_compare(e: basedep, type: E_UNEQUAL, sym: &symbol_no); |
436 | basedep = expr_eliminate_dups(e: expr_transform(e: basedep)); |
437 | |
438 | /* Examine consecutive elements after sym */ |
439 | last_menu = NULL; |
440 | for (menu = parent->next; menu; menu = menu->next) { |
441 | dep = menu->prompt ? menu->prompt->visible.expr : menu->dep; |
442 | if (!expr_contains_symbol(dep, sym)) |
443 | /* No dependency, quit */ |
444 | break; |
445 | if (expr_depends_symbol(dep, sym)) |
446 | /* Absolute dependency, put in submenu */ |
447 | goto next; |
448 | |
449 | /* |
450 | * Also consider it a dependency on sym if our |
451 | * dependencies contain sym and are a "superset" of |
452 | * sym's dependencies, e.g. '(sym || Q) && R' when sym |
453 | * depends on R. |
454 | * |
455 | * Note that 'R' might be from an enclosing menu or if, |
456 | * making this a more common case than it might seem. |
457 | */ |
458 | dep = expr_trans_compare(e: dep, type: E_UNEQUAL, sym: &symbol_no); |
459 | dep = expr_eliminate_dups(e: expr_transform(e: dep)); |
460 | dep2 = expr_copy(org: basedep); |
461 | expr_eliminate_eq(ep1: &dep, ep2: &dep2); |
462 | expr_free(e: dep); |
463 | if (!expr_is_yes(e: dep2)) { |
464 | /* Not superset, quit */ |
465 | expr_free(e: dep2); |
466 | break; |
467 | } |
468 | /* Superset, put in submenu */ |
469 | expr_free(e: dep2); |
470 | next: |
471 | _menu_finalize(menu, false); |
472 | menu->parent = parent; |
473 | last_menu = menu; |
474 | } |
475 | expr_free(e: basedep); |
476 | if (last_menu) { |
477 | parent->list = parent->next; |
478 | parent->next = last_menu->next; |
479 | last_menu->next = NULL; |
480 | } |
481 | |
482 | sym->dir_dep.expr = expr_alloc_or(e1: sym->dir_dep.expr, e2: parent->dep); |
483 | } |
484 | for (menu = parent->list; menu; menu = menu->next) { |
485 | if (sym && sym_is_choice(sym) && |
486 | menu->sym && !sym_is_choice_value(menu->sym)) { |
487 | current_entry = menu; |
488 | menu->sym->flags |= SYMBOL_CHOICEVAL; |
489 | if (!menu->prompt) |
490 | menu_warn(menu, fmt: "choice value must have a prompt" ); |
491 | for (prop = menu->sym->prop; prop; prop = prop->next) { |
492 | if (prop->type == P_DEFAULT) |
493 | prop_warn(prop, fmt: "defaults for choice " |
494 | "values not supported" ); |
495 | if (prop->menu == menu) |
496 | continue; |
497 | if (prop->type == P_PROMPT && |
498 | prop->menu->parent->sym != sym) |
499 | prop_warn(prop, fmt: "choice value used outside its choice group" ); |
500 | } |
501 | /* Non-tristate choice values of tristate choices must |
502 | * depend on the choice being set to Y. The choice |
503 | * values' dependencies were propagated to their |
504 | * properties above, so the change here must be re- |
505 | * propagated. |
506 | */ |
507 | if (sym->type == S_TRISTATE && menu->sym->type != S_TRISTATE) { |
508 | basedep = expr_alloc_comp(type: E_EQUAL, s1: sym, s2: &symbol_yes); |
509 | menu->dep = expr_alloc_and(e1: basedep, e2: menu->dep); |
510 | for (prop = menu->sym->prop; prop; prop = prop->next) { |
511 | if (prop->menu != menu) |
512 | continue; |
513 | prop->visible.expr = expr_alloc_and(e1: expr_copy(org: basedep), |
514 | e2: prop->visible.expr); |
515 | } |
516 | } |
517 | menu_add_symbol(P_CHOICE, sym, NULL); |
518 | prop = sym_get_choice_prop(sym); |
519 | for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr) |
520 | ; |
521 | *ep = expr_alloc_one(E_LIST, NULL); |
522 | (*ep)->right.sym = menu->sym; |
523 | } |
524 | |
525 | /* |
526 | * This code serves two purposes: |
527 | * |
528 | * (1) Flattening 'if' blocks, which do not specify a submenu |
529 | * and only add dependencies. |
530 | * |
531 | * (Automatic submenu creation might still create a submenu |
532 | * from an 'if' before this code runs.) |
533 | * |
534 | * (2) "Undoing" any automatic submenus created earlier below |
535 | * promptless symbols. |
536 | * |
537 | * Before: |
538 | * |
539 | * A |
540 | * if ... (or promptless symbol) |
541 | * +-B |
542 | * +-C |
543 | * D |
544 | * |
545 | * After: |
546 | * |
547 | * A |
548 | * if ... (or promptless symbol) |
549 | * B |
550 | * C |
551 | * D |
552 | */ |
553 | if (menu->list && (!menu->prompt || !menu->prompt->text)) { |
554 | for (last_menu = menu->list; ; last_menu = last_menu->next) { |
555 | last_menu->parent = parent; |
556 | if (!last_menu->next) |
557 | break; |
558 | } |
559 | last_menu->next = menu->next; |
560 | menu->next = menu->list; |
561 | menu->list = NULL; |
562 | } |
563 | } |
564 | |
565 | if (sym && !(sym->flags & SYMBOL_WARNED)) { |
566 | if (sym->type == S_UNKNOWN) |
567 | menu_warn(menu: parent, fmt: "config symbol defined without type" ); |
568 | |
569 | /* Check properties connected to this symbol */ |
570 | sym_check_prop(sym); |
571 | sym->flags |= SYMBOL_WARNED; |
572 | } |
573 | |
574 | /* |
575 | * For non-optional choices, add a reverse dependency (corresponding to |
576 | * a select) of '<visibility> && m'. This prevents the user from |
577 | * setting the choice mode to 'n' when the choice is visible. |
578 | * |
579 | * This would also work for non-choice symbols, but only non-optional |
580 | * choices clear SYMBOL_OPTIONAL as of writing. Choices are implemented |
581 | * as a type of symbol. |
582 | */ |
583 | if (sym && !sym_is_optional(sym) && parent->prompt) { |
584 | sym->rev_dep.expr = expr_alloc_or(e1: sym->rev_dep.expr, |
585 | e2: expr_alloc_and(e1: parent->prompt->visible.expr, |
586 | e2: expr_alloc_symbol(sym: &symbol_mod))); |
587 | } |
588 | } |
589 | |
590 | void (void) |
591 | { |
592 | _menu_finalize(&rootmenu, false); |
593 | } |
594 | |
595 | bool (struct menu *) |
596 | { |
597 | if (!menu->prompt) |
598 | return false; |
599 | return true; |
600 | } |
601 | |
602 | /* |
603 | * Determine if a menu is empty. |
604 | * A menu is considered empty if it contains no or only |
605 | * invisible entries. |
606 | */ |
607 | bool (struct menu *) |
608 | { |
609 | struct menu *child; |
610 | |
611 | for (child = menu->list; child; child = child->next) { |
612 | if (menu_is_visible(child)) |
613 | return(false); |
614 | } |
615 | return(true); |
616 | } |
617 | |
618 | bool (struct menu *) |
619 | { |
620 | struct menu *child; |
621 | struct symbol *sym; |
622 | tristate visible; |
623 | |
624 | if (!menu->prompt) |
625 | return false; |
626 | |
627 | if (menu->visibility) { |
628 | if (expr_calc_value(menu->visibility) == no) |
629 | return false; |
630 | } |
631 | |
632 | sym = menu->sym; |
633 | if (sym) { |
634 | sym_calc_value(sym); |
635 | visible = menu->prompt->visible.tri; |
636 | } else |
637 | visible = menu->prompt->visible.tri = expr_calc_value(e: menu->prompt->visible.expr); |
638 | |
639 | if (visible != no) |
640 | return true; |
641 | |
642 | if (!sym || sym_get_tristate_value(menu->sym) == no) |
643 | return false; |
644 | |
645 | for (child = menu->list; child; child = child->next) { |
646 | if (menu_is_visible(child)) { |
647 | if (sym) |
648 | sym->flags |= SYMBOL_DEF_USER; |
649 | return true; |
650 | } |
651 | } |
652 | |
653 | return false; |
654 | } |
655 | |
656 | const char *(struct menu *) |
657 | { |
658 | if (menu->prompt) |
659 | return menu->prompt->text; |
660 | else if (menu->sym) |
661 | return menu->sym->name; |
662 | return NULL; |
663 | } |
664 | |
665 | struct menu *(struct menu *) |
666 | { |
667 | enum prop_type type; |
668 | |
669 | for (; menu != &rootmenu; menu = menu->parent) { |
670 | type = menu->prompt ? menu->prompt->type : 0; |
671 | if (type == P_MENU) |
672 | break; |
673 | } |
674 | return menu; |
675 | } |
676 | |
677 | static void get_def_str(struct gstr *r, struct menu *) |
678 | { |
679 | str_printf(gs: r, fmt: "Defined at %s:%d\n" , |
680 | menu->filename, menu->lineno); |
681 | } |
682 | |
683 | static void get_dep_str(struct gstr *r, struct expr *expr, const char *prefix) |
684 | { |
685 | if (!expr_is_yes(e: expr)) { |
686 | str_append(gs: r, s: prefix); |
687 | expr_gstr_print(e: expr, gs: r); |
688 | str_append(gs: r, s: "\n" ); |
689 | } |
690 | } |
691 | |
692 | int __attribute__((weak)) get_jump_key_char(void) |
693 | { |
694 | return -1; |
695 | } |
696 | |
697 | static void get_prompt_str(struct gstr *r, struct property *prop, |
698 | struct list_head *head) |
699 | { |
700 | int i, j; |
701 | struct menu *[8], *, *location = NULL; |
702 | struct jump_key *jump = NULL; |
703 | |
704 | str_printf(gs: r, fmt: " Prompt: %s\n" , prop->text); |
705 | |
706 | get_dep_str(r, expr: prop->menu->dep, prefix: " Depends on: " ); |
707 | /* |
708 | * Most prompts in Linux have visibility that exactly matches their |
709 | * dependencies. For these, we print only the dependencies to improve |
710 | * readability. However, prompts with inline "if" expressions and |
711 | * prompts with a parent that has a "visible if" expression have |
712 | * differing dependencies and visibility. In these rare cases, we |
713 | * print both. |
714 | */ |
715 | if (!expr_eq(e1: prop->menu->dep, e2: prop->visible.expr)) |
716 | get_dep_str(r, expr: prop->visible.expr, prefix: " Visible if: " ); |
717 | |
718 | menu = prop->menu; |
719 | for (i = 0; menu != &rootmenu && i < 8; menu = menu->parent) { |
720 | submenu[i++] = menu; |
721 | if (location == NULL && menu_is_visible(menu)) |
722 | location = menu; |
723 | } |
724 | if (head && location) { |
725 | jump = xmalloc(sizeof(struct jump_key)); |
726 | jump->target = location; |
727 | list_add_tail(new: &jump->entries, head); |
728 | } |
729 | |
730 | str_printf(gs: r, fmt: " Location:\n" ); |
731 | for (j = 0; --i >= 0; j++) { |
732 | int jk = -1; |
733 | int indent = 2 * j + 4; |
734 | |
735 | menu = submenu[i]; |
736 | if (jump && menu == location) { |
737 | jump->offset = strlen(r->s); |
738 | jk = get_jump_key_char(); |
739 | } |
740 | |
741 | if (jk >= 0) { |
742 | str_printf(gs: r, fmt: "(%c)" , jk); |
743 | indent -= 3; |
744 | } |
745 | |
746 | str_printf(gs: r, fmt: "%*c-> %s" , indent, ' ', menu_get_prompt(menu)); |
747 | if (menu->sym) { |
748 | str_printf(gs: r, fmt: " (%s [=%s])" , menu->sym->name ? |
749 | menu->sym->name : "<choice>" , |
750 | sym_get_string_value(sym: menu->sym)); |
751 | } |
752 | str_append(gs: r, s: "\n" ); |
753 | } |
754 | } |
755 | |
756 | static void get_symbol_props_str(struct gstr *r, struct symbol *sym, |
757 | enum prop_type tok, const char *prefix) |
758 | { |
759 | bool hit = false; |
760 | struct property *prop; |
761 | |
762 | for_all_properties(sym, prop, tok) { |
763 | if (!hit) { |
764 | str_append(gs: r, s: prefix); |
765 | hit = true; |
766 | } else |
767 | str_printf(gs: r, fmt: " && " ); |
768 | expr_gstr_print(e: prop->expr, gs: r); |
769 | } |
770 | if (hit) |
771 | str_append(gs: r, s: "\n" ); |
772 | } |
773 | |
774 | /* |
775 | * head is optional and may be NULL |
776 | */ |
777 | static void get_symbol_str(struct gstr *r, struct symbol *sym, |
778 | struct list_head *head) |
779 | { |
780 | struct property *prop; |
781 | struct menu *; |
782 | |
783 | if (sym && sym->name) { |
784 | str_printf(gs: r, fmt: "Symbol: %s [=%s]\n" , sym->name, |
785 | sym_get_string_value(sym)); |
786 | str_printf(gs: r, fmt: "Type : %s\n" , sym_type_name(type: sym->type)); |
787 | if (sym->type == S_INT || sym->type == S_HEX) { |
788 | prop = sym_get_range_prop(sym); |
789 | if (prop) { |
790 | str_printf(gs: r, fmt: "Range : " ); |
791 | expr_gstr_print(e: prop->expr, gs: r); |
792 | str_append(gs: r, s: "\n" ); |
793 | } |
794 | } |
795 | } |
796 | |
797 | /* Print the definitions with prompts before the ones without */ |
798 | list_for_each_entry(menu, &sym->menus, link) { |
799 | if (menu->prompt) { |
800 | get_def_str(r, menu); |
801 | get_prompt_str(r, prop: menu->prompt, head); |
802 | } |
803 | } |
804 | |
805 | list_for_each_entry(menu, &sym->menus, link) { |
806 | if (!menu->prompt) { |
807 | get_def_str(r, menu); |
808 | get_dep_str(r, expr: menu->dep, prefix: " Depends on: " ); |
809 | } |
810 | } |
811 | |
812 | get_symbol_props_str(r, sym, tok: P_SELECT, prefix: "Selects: " ); |
813 | if (sym->rev_dep.expr) { |
814 | expr_gstr_print_revdep(e: sym->rev_dep.expr, gs: r, pr_type: yes, title: "Selected by [y]:\n" ); |
815 | expr_gstr_print_revdep(e: sym->rev_dep.expr, gs: r, pr_type: mod, title: "Selected by [m]:\n" ); |
816 | expr_gstr_print_revdep(e: sym->rev_dep.expr, gs: r, pr_type: no, title: "Selected by [n]:\n" ); |
817 | } |
818 | |
819 | get_symbol_props_str(r, sym, tok: P_IMPLY, prefix: "Implies: " ); |
820 | if (sym->implied.expr) { |
821 | expr_gstr_print_revdep(e: sym->implied.expr, gs: r, pr_type: yes, title: "Implied by [y]:\n" ); |
822 | expr_gstr_print_revdep(e: sym->implied.expr, gs: r, pr_type: mod, title: "Implied by [m]:\n" ); |
823 | expr_gstr_print_revdep(e: sym->implied.expr, gs: r, pr_type: no, title: "Implied by [n]:\n" ); |
824 | } |
825 | |
826 | str_append(gs: r, s: "\n\n" ); |
827 | } |
828 | |
829 | struct gstr get_relations_str(struct symbol **sym_arr, struct list_head *head) |
830 | { |
831 | struct symbol *sym; |
832 | struct gstr res = str_new(); |
833 | int i; |
834 | |
835 | for (i = 0; sym_arr && (sym = sym_arr[i]); i++) |
836 | get_symbol_str(r: &res, sym, head); |
837 | if (!i) |
838 | str_append(gs: &res, s: "No matches found.\n" ); |
839 | return res; |
840 | } |
841 | |
842 | |
843 | void (struct menu *, struct gstr *help) |
844 | { |
845 | struct symbol *sym = menu->sym; |
846 | const char *help_text = nohelp_text; |
847 | |
848 | if (menu->help) { |
849 | if (sym->name) |
850 | str_printf(gs: help, fmt: "%s%s:\n\n" , CONFIG_, sym->name); |
851 | help_text = menu->help; |
852 | } |
853 | str_printf(gs: help, fmt: "%s\n" , help_text); |
854 | if (sym) |
855 | get_symbol_str(help, sym, NULL); |
856 | } |
857 | |