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
15static const char nohelp_text[] = "There is no help available for this option.";
16
17struct menu rootmenu;
18static struct menu **last_entry_ptr;
19
20void menu_warn(struct menu *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
30static 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
40void _menu_init(void)
41{
42	current_entry = current_menu = &rootmenu;
43	last_entry_ptr = &rootmenu.list;
44}
45
46void menu_add_entry(struct symbol *sym)
47{
48	struct menu *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(P_SYMBOL, sym, NULL);
62		list_add_tail(&menu->link, &sym->menus);
63	}
64}
65
66struct menu *menu_add_menu(void)
67{
68	last_entry_ptr = &current_entry->list;
69	current_menu = current_entry;
70	return current_menu;
71}
72
73void menu_end_menu(void)
74{
75	last_entry_ptr = &current_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 */
83static 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->left.expr);
91		break;
92	case E_OR:
93	case E_AND:
94		e->left.expr = rewrite_m(e->left.expr);
95		e->right.expr = rewrite_m(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(e, expr_alloc_symbol(modules_sym));
101		break;
102	default:
103		break;
104	}
105	return e;
106}
107
108void menu_add_dep(struct expr *dep)
109{
110	current_entry->dep = expr_alloc_and(current_entry->dep, dep);
111}
112
113void menu_set_type(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(current_entry,
124		"ignoring type redefinition of '%s' from '%s' to '%s'",
125		sym->name ? sym->name : "<choice>",
126		sym_type_name(sym->type), sym_type_name(type));
127}
128
129static struct property *menu_add_prop(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 = &current_entry->sym->prop;
148		     *propp;
149		     propp = &(*propp)->next)
150			;
151		*propp = prop;
152	}
153
154	return prop;
155}
156
157struct property *menu_add_prompt(enum prop_type type, char *prompt,
158				 struct expr *dep)
159{
160	struct property *prop = menu_add_prop(type, NULL, dep);
161
162	if (isspace(*prompt)) {
163		prop_warn(prop, "leading whitespace ignored");
164		while (isspace(*prompt))
165			prompt++;
166	}
167	if (current_entry->prompt)
168		prop_warn(prop, "prompt redefined");
169
170	/* Apply all upper menus' visibilities to actual prompts. */
171	if (type == P_PROMPT) {
172		struct menu *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(menu->visibility);
187
188			prop->visible.expr = expr_alloc_and(prop->visible.expr,
189							    dup_expr);
190		}
191	}
192
193	current_entry->prompt = prop;
194	prop->text = prompt;
195
196	return prop;
197}
198
199void menu_add_visibility(struct expr *expr)
200{
201	current_entry->visibility = expr_alloc_and(current_entry->visibility,
202	    expr);
203}
204
205void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep)
206{
207	menu_add_prop(type, expr, dep);
208}
209
210void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep)
211{
212	menu_add_prop(type, expr_alloc_symbol(sym), dep);
213}
214
215static int menu_validate_number(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
221static 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				    "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					    "'%s': number is invalid",
242					    sym->name);
243			}
244			if (sym_is_choice(sym)) {
245				struct property *choice_prop =
246					sym_get_choice_prop(sym2);
247
248				if (!choice_prop ||
249				    prop_get_symbol(choice_prop) != sym)
250					prop_warn(prop,
251						  "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				    "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				    "'%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, "range is only allowed "
274						"for int or hex symbols");
275			if (!menu_validate_number(sym, prop->expr->left.sym) ||
276			    !menu_validate_number(sym, prop->expr->right.sym))
277				prop_warn(prop, "range is invalid");
278			break;
279		default:
280			;
281		}
282	}
283}
284
285static void _menu_finalize(struct menu *parent, bool inside_choice)
286{
287	struct menu *menu, *last_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(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(menu->dep);
335			basedep = expr_transform(basedep);
336			basedep = expr_alloc_and(expr_copy(parentdep), basedep);
337			basedep = expr_eliminate_dups(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(prop->visible.expr);
379				dep = expr_transform(dep);
380				dep = expr_alloc_and(expr_copy(basedep), dep);
381				dep = expr_eliminate_dups(dep);
382				if (menu->sym && menu->sym->type != S_TRISTATE)
383					dep = expr_trans_bool(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(es->rev_dep.expr,
393							expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep)));
394				} else if (prop->type == P_IMPLY) {
395					struct symbol *es = prop_get_symbol(prop);
396					es->implied.expr = expr_alloc_or(es->implied.expr,
397							expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep)));
398				}
399			}
400		}
401
402		if (is_choice)
403			expr_free(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(basedep, E_UNEQUAL, &symbol_no);
436		basedep = expr_eliminate_dups(expr_transform(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(dep, E_UNEQUAL, &symbol_no);
459			dep = expr_eliminate_dups(expr_transform(dep));
460			dep2 = expr_copy(basedep);
461			expr_eliminate_eq(&dep, &dep2);
462			expr_free(dep);
463			if (!expr_is_yes(dep2)) {
464				/* Not superset, quit */
465				expr_free(dep2);
466				break;
467			}
468			/* Superset, put in submenu */
469			expr_free(dep2);
470		next:
471			_menu_finalize(menu, false);
472			menu->parent = parent;
473			last_menu = menu;
474		}
475		expr_free(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(sym->dir_dep.expr, 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, "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, "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, "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(E_EQUAL, sym, &symbol_yes);
509				menu->dep = expr_alloc_and(basedep, 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(expr_copy(basedep),
514									    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(parent, "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(sym->rev_dep.expr,
585				expr_alloc_and(parent->prompt->visible.expr,
586					expr_alloc_symbol(&symbol_mod)));
587	}
588}
589
590void menu_finalize(void)
591{
592	_menu_finalize(&rootmenu, false);
593}
594
595bool menu_has_prompt(struct menu *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 */
607bool menu_is_empty(struct menu *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
618bool menu_is_visible(struct menu *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(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
656const char *menu_get_prompt(struct menu *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
665struct menu *menu_get_parent_menu(struct menu *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
677static void get_def_str(struct gstr *r, struct menu *menu)
678{
679	str_printf(r, "Defined at %s:%d\n",
680		   menu->filename, menu->lineno);
681}
682
683static void get_dep_str(struct gstr *r, struct expr *expr, const char *prefix)
684{
685	if (!expr_is_yes(expr)) {
686		str_append(r, prefix);
687		expr_gstr_print(expr, r);
688		str_append(r, "\n");
689	}
690}
691
692int __attribute__((weak)) get_jump_key_char(void)
693{
694	return -1;
695}
696
697static void get_prompt_str(struct gstr *r, struct property *prop,
698			   struct list_head *head)
699{
700	int i, j;
701	struct menu *submenu[8], *menu, *location = NULL;
702	struct jump_key *jump = NULL;
703
704	str_printf(r, "  Prompt: %s\n", prop->text);
705
706	get_dep_str(r, prop->menu->dep, "  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(prop->menu->dep, prop->visible.expr))
716		get_dep_str(r, prop->visible.expr, "  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(&jump->entries, head);
728	}
729
730	str_printf(r, "  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(r, "(%c)", jk);
743			indent -= 3;
744		}
745
746		str_printf(r, "%*c-> %s", indent, ' ', menu_get_prompt(menu));
747		if (menu->sym) {
748			str_printf(r, " (%s [=%s])", menu->sym->name ?
749				menu->sym->name : "<choice>",
750				sym_get_string_value(menu->sym));
751		}
752		str_append(r, "\n");
753	}
754}
755
756static 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(r, prefix);
765			hit = true;
766		} else
767			str_printf(r, " && ");
768		expr_gstr_print(prop->expr, r);
769	}
770	if (hit)
771		str_append(r, "\n");
772}
773
774/*
775 * head is optional and may be NULL
776 */
777static void get_symbol_str(struct gstr *r, struct symbol *sym,
778		    struct list_head *head)
779{
780	struct property *prop;
781	struct menu *menu;
782
783	if (sym && sym->name) {
784		str_printf(r, "Symbol: %s [=%s]\n", sym->name,
785			   sym_get_string_value(sym));
786		str_printf(r, "Type  : %s\n", sym_type_name(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(r, "Range : ");
791				expr_gstr_print(prop->expr, r);
792				str_append(r, "\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, 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, menu->dep, "  Depends on: ");
809		}
810	}
811
812	get_symbol_props_str(r, sym, P_SELECT, "Selects: ");
813	if (sym->rev_dep.expr) {
814		expr_gstr_print_revdep(sym->rev_dep.expr, r, yes, "Selected by [y]:\n");
815		expr_gstr_print_revdep(sym->rev_dep.expr, r, mod, "Selected by [m]:\n");
816		expr_gstr_print_revdep(sym->rev_dep.expr, r, no, "Selected by [n]:\n");
817	}
818
819	get_symbol_props_str(r, sym, P_IMPLY, "Implies: ");
820	if (sym->implied.expr) {
821		expr_gstr_print_revdep(sym->implied.expr, r, yes, "Implied by [y]:\n");
822		expr_gstr_print_revdep(sym->implied.expr, r, mod, "Implied by [m]:\n");
823		expr_gstr_print_revdep(sym->implied.expr, r, no, "Implied by [n]:\n");
824	}
825
826	str_append(r, "\n\n");
827}
828
829struct 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(&res, sym, head);
837	if (!i)
838		str_append(&res, "No matches found.\n");
839	return res;
840}
841
842
843void menu_get_ext_help(struct menu *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(help, "%s%s:\n\n", CONFIG_, sym->name);
851		help_text = menu->help;
852	}
853	str_printf(help, "%s\n", help_text);
854	if (sym)
855		get_symbol_str(help, sym, NULL);
856}
857