Chameleon

Chameleon Svn Source Tree

Root/tags/2.0/i386/config/menu.c

Source at commit 1808 created 12 years 3 months ago.
By blackosx, Revise layout of package installer 'Welcome' file so it looks cleaner. Change the copyright notice to begin from 2009 as seen in the Chameleon 2.0 r431 installer. Should this date be set earlier?
1/*␊
2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>␊
3 * Released under the terms of the GNU GPL v2.0.␊
4 */␊
5#include <stdlib.h>␊
6#include <string.h>␊
7␊
8#define LKC_DIRECT_LINK␊
9#include "lkc.h"␊
10␊
11static const char nohelp_text[] = N_(␊
12␉"There is no help available for this option.\n");␊
13␊
14struct menu rootmenu;␊
15static struct menu **last_entry_ptr;␊
16␊
17struct file *file_list;␊
18struct file *current_file;␊
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->file->name, 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->file->name, 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 = malloc(sizeof(*menu));␊
51␉memset(menu, 0, sizeof(*menu));␊
52␉menu->sym = sym;␊
53␉menu->parent = current_menu;␊
54␉menu->file = current_file;␊
55␉menu->lineno = zconf_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}␊
63␊
64void menu_end_entry(void)␊
65{␊
66}␊
67␊
68struct menu *menu_add_menu(void)␊
69{␊
70␉menu_end_entry();␊
71␉last_entry_ptr = &current_entry->list;␊
72␉return current_menu = current_entry;␊
73}␊
74␊
75void menu_end_menu(void)␊
76{␊
77␉last_entry_ptr = &current_menu->next;␊
78␉current_menu = current_menu->parent;␊
79}␊
80␊
81static struct expr *menu_check_dep(struct expr *e)␊
82{␊
83␉if (!e)␊
84␉␉return e;␊
85␊
86␉switch (e->type) {␊
87␉case E_NOT:␊
88␉␉e->left.expr = menu_check_dep(e->left.expr);␊
89␉␉break;␊
90␉case E_OR:␊
91␉case E_AND:␊
92␉␉e->left.expr = menu_check_dep(e->left.expr);␊
93␉␉e->right.expr = menu_check_dep(e->right.expr);␊
94␉␉break;␊
95␉case E_SYMBOL:␊
96␉␉/* change 'm' into 'm' && MODULES */␊
97␉␉if (e->left.sym == &symbol_mod)␊
98␉␉␉return expr_alloc_and(e, expr_alloc_symbol(modules_sym));␊
99␉␉break;␊
100␉default:␊
101␉␉break;␊
102␉}␊
103␉return e;␊
104}␊
105␊
106void menu_add_dep(struct expr *dep)␊
107{␊
108␉current_entry->dep = expr_alloc_and(current_entry->dep, menu_check_dep(dep));␊
109}␊
110␊
111void menu_set_type(int type)␊
112{␊
113␉struct symbol *sym = current_entry->sym;␊
114␊
115␉if (sym->type == type)␊
116␉␉return;␊
117␉if (sym->type == S_UNKNOWN) {␊
118␉␉sym->type = type;␊
119␉␉return;␊
120␉}␊
121␉menu_warn(current_entry, "type of '%s' redefined from '%s' to '%s'",␊
122␉ sym->name ? sym->name : "<choice>",␊
123␉ sym_type_name(sym->type), sym_type_name(type));␊
124}␊
125␊
126struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep)␊
127{␊
128␉struct property *prop = prop_alloc(type, current_entry->sym);␊
129␊
130␉prop->menu = current_entry;␊
131␉prop->expr = expr;␊
132␉prop->visible.expr = menu_check_dep(dep);␊
133␊
134␉if (prompt) {␊
135␉␉if (isspace(*prompt)) {␊
136␉␉␉prop_warn(prop, "leading whitespace ignored");␊
137␉␉␉while (isspace(*prompt))␊
138␉␉␉␉prompt++;␊
139␉␉}␊
140␉␉if (current_entry->prompt && current_entry != &rootmenu)␊
141␉␉␉prop_warn(prop, "prompt redefined");␊
142␊
143␉␉/* Apply all upper menus' visibilities to actual prompts. */␊
144␉␉if(type == P_PROMPT) {␊
145␉␉␉struct menu *menu = current_entry;␊
146␊
147␉␉␉while ((menu = menu->parent) != NULL) {␊
148␉␉␉␉if (!menu->visibility)␊
149␉␉␉␉␉continue;␊
150␉␉␉␉prop->visible.expr␊
151␉␉␉␉␉= expr_alloc_and(prop->visible.expr,␊
152␉␉␉␉␉␉␉ menu->visibility);␊
153␉␉␉}␊
154␉␉}␊
155␊
156␉␉current_entry->prompt = prop;␊
157␉}␊
158␉prop->text = prompt;␊
159␊
160␉return prop;␊
161}␊
162␊
163struct property *menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep)␊
164{␊
165␉return menu_add_prop(type, prompt, NULL, dep);␊
166}␊
167␊
168void menu_add_visibility(struct expr *expr)␊
169{␊
170␉current_entry->visibility = expr_alloc_and(current_entry->visibility,␊
171␉ expr);␊
172}␊
173␊
174void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep)␊
175{␊
176␉menu_add_prop(type, NULL, expr, dep);␊
177}␊
178␊
179void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep)␊
180{␊
181␉menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep);␊
182}␊
183␊
184void menu_add_option(int token, char *arg)␊
185{␊
186␉struct property *prop;␊
187␊
188␉switch (token) {␊
189␉case T_OPT_MODULES:␊
190␉␉prop = prop_alloc(P_DEFAULT, modules_sym);␊
191␉␉prop->expr = expr_alloc_symbol(current_entry->sym);␊
192␉␉break;␊
193␉case T_OPT_DEFCONFIG_LIST:␊
194␉␉if (!sym_defconfig_list)␊
195␉␉␉sym_defconfig_list = current_entry->sym;␊
196␉␉else if (sym_defconfig_list != current_entry->sym)␊
197␉␉␉zconf_error("trying to redefine defconfig symbol");␊
198␉␉break;␊
199␉case T_OPT_ENV:␊
200␉␉//prop_add_env(arg);␊
201␉␉break;␊
202␉}␊
203}␊
204␊
205static int menu_validate_number(struct symbol *sym, struct symbol *sym2)␊
206{␊
207␉return sym2->type == S_INT || sym2->type == S_HEX ||␊
208␉ (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name));␊
209}␊
210␊
211static void sym_check_prop(struct symbol *sym)␊
212{␊
213␉struct property *prop;␊
214␉struct symbol *sym2;␊
215␉for (prop = sym->prop; prop; prop = prop->next) {␊
216␉␉switch (prop->type) {␊
217␉␉case P_DEFAULT:␊
218␉␉␉if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) &&␊
219␉␉␉ prop->expr->type != E_SYMBOL)␊
220␉␉␉␉prop_warn(prop,␊
221␉␉␉␉ "default for config symbol '%s'"␊
222␉␉␉␉ " must be a single symbol", sym->name);␊
223␉␉␉if (prop->expr->type != E_SYMBOL)␊
224␉␉␉␉break;␊
225␉␉␉sym2 = prop_get_symbol(prop);␊
226␉␉␉if (sym->type == S_HEX || sym->type == S_INT) {␊
227␉␉␉␉if (!menu_validate_number(sym, sym2))␊
228␉␉␉␉␉prop_warn(prop,␊
229␉␉␉␉␉ "'%s': number is invalid",␊
230␉␉␉␉␉ sym->name);␊
231␉␉␉}␊
232␉␉␉break;␊
233␉␉case P_SELECT:␊
234␉␉␉sym2 = prop_get_symbol(prop);␊
235␉␉␉if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE)␊
236␉␉␉␉prop_warn(prop,␊
237␉␉␉␉ "config symbol '%s' uses select, but is "␊
238␉␉␉␉ "not boolean or tristate", sym->name);␊
239␉␉␉else if (sym2->type != S_UNKNOWN &&␊
240␉␉␉ sym2->type != S_BOOLEAN &&␊
241␉␉␉ sym2->type != S_TRISTATE)␊
242␉␉␉␉prop_warn(prop,␊
243␉␉␉␉ "'%s' has wrong type. 'select' only "␊
244␉␉␉␉ "accept arguments of boolean and "␊
245␉␉␉␉ "tristate type", sym2->name);␊
246␉␉␉break;␊
247␉␉case P_RANGE:␊
248␉␉␉if (sym->type != S_INT && sym->type != S_HEX)␊
249␉␉␉␉prop_warn(prop, "range is only allowed "␊
250␉␉␉␉ "for int or hex symbols");␊
251␉␉␉if (!menu_validate_number(sym, prop->expr->left.sym) ||␊
252␉␉␉ !menu_validate_number(sym, prop->expr->right.sym))␊
253␉␉␉␉prop_warn(prop, "range is invalid");␊
254␉␉␉break;␊
255␉␉default:␊
256␉␉␉;␊
257␉␉}␊
258␉}␊
259}␊
260␊
261void menu_finalize(struct menu *parent)␊
262{␊
263␉struct menu *menu, *last_menu;␊
264␉struct symbol *sym;␊
265␉struct property *prop;␊
266␉struct expr *parentdep, *basedep, *dep, *dep2, **ep;␊
267␊
268␉sym = parent->sym;␊
269␉if (parent->list) {␊
270␉␉if (sym && sym_is_choice(sym)) {␊
271␉␉␉if (sym->type == S_UNKNOWN) {␊
272␉␉␉␉/* find the first choice value to find out choice type */␊
273␉␉␉␉current_entry = parent;␊
274␉␉␉␉for (menu = parent->list; menu; menu = menu->next) {␊
275␉␉␉␉␉if (menu->sym && menu->sym->type != S_UNKNOWN) {␊
276␉␉␉␉␉␉menu_set_type(menu->sym->type);␊
277␉␉␉␉␉␉break;␊
278␉␉␉␉␉}␊
279␉␉␉␉}␊
280␉␉␉}␊
281␉␉␉/* set the type of the remaining choice values */␊
282␉␉␉for (menu = parent->list; menu; menu = menu->next) {␊
283␉␉␉␉current_entry = menu;␊
284␉␉␉␉if (menu->sym && menu->sym->type == S_UNKNOWN)␊
285␉␉␉␉␉menu_set_type(sym->type);␊
286␉␉␉}␊
287␉␉␉parentdep = expr_alloc_symbol(sym);␊
288␉␉} else if (parent->prompt)␊
289␉␉␉parentdep = parent->prompt->visible.expr;␊
290␉␉else␊
291␉␉␉parentdep = parent->dep;␊
292␊
293␉␉for (menu = parent->list; menu; menu = menu->next) {␊
294␉␉␉basedep = expr_transform(menu->dep);␊
295␉␉␉basedep = expr_alloc_and(expr_copy(parentdep), basedep);␊
296␉␉␉basedep = expr_eliminate_dups(basedep);␊
297␉␉␉menu->dep = basedep;␊
298␉␉␉if (menu->sym)␊
299␉␉␉␉prop = menu->sym->prop;␊
300␉␉␉else␊
301␉␉␉␉prop = menu->prompt;␊
302␉␉␉for (; prop; prop = prop->next) {␊
303␉␉␉␉if (prop->menu != menu)␊
304␉␉␉␉␉continue;␊
305␉␉␉␉dep = expr_transform(prop->visible.expr);␊
306␉␉␉␉dep = expr_alloc_and(expr_copy(basedep), dep);␊
307␉␉␉␉dep = expr_eliminate_dups(dep);␊
308␉␉␉␉if (menu->sym && menu->sym->type != S_TRISTATE)␊
309␉␉␉␉␉dep = expr_trans_bool(dep);␊
310␉␉␉␉prop->visible.expr = dep;␊
311␉␉␉␉if (prop->type == P_SELECT) {␊
312␉␉␉␉␉struct symbol *es = prop_get_symbol(prop);␊
313␉␉␉␉␉es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr,␊
314␉␉␉␉␉␉␉expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep)));␊
315␉␉␉␉}␊
316␉␉␉}␊
317␉␉}␊
318␉␉for (menu = parent->list; menu; menu = menu->next)␊
319␉␉␉menu_finalize(menu);␊
320␉} else if (sym) {␊
321␉␉basedep = parent->prompt ? parent->prompt->visible.expr : NULL;␊
322␉␉basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no);␊
323␉␉basedep = expr_eliminate_dups(expr_transform(basedep));␊
324␉␉last_menu = NULL;␊
325␉␉for (menu = parent->next; menu; menu = menu->next) {␊
326␉␉␉dep = menu->prompt ? menu->prompt->visible.expr : menu->dep;␊
327␉␉␉if (!expr_contains_symbol(dep, sym))␊
328␉␉␉␉break;␊
329␉␉␉if (expr_depends_symbol(dep, sym))␊
330␉␉␉␉goto next;␊
331␉␉␉dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no);␊
332␉␉␉dep = expr_eliminate_dups(expr_transform(dep));␊
333␉␉␉dep2 = expr_copy(basedep);␊
334␉␉␉expr_eliminate_eq(&dep, &dep2);␊
335␉␉␉expr_free(dep);␊
336␉␉␉if (!expr_is_yes(dep2)) {␊
337␉␉␉␉expr_free(dep2);␊
338␉␉␉␉break;␊
339␉␉␉}␊
340␉␉␉expr_free(dep2);␊
341␉␉next:␊
342␉␉␉menu_finalize(menu);␊
343␉␉␉menu->parent = parent;␊
344␉␉␉last_menu = menu;␊
345␉␉}␊
346␉␉if (last_menu) {␊
347␉␉␉parent->list = parent->next;␊
348␉␉␉parent->next = last_menu->next;␊
349␉␉␉last_menu->next = NULL;␊
350␉␉}␊
351␊
352␉␉sym->dir_dep.expr = parent->dep;␊
353␉}␊
354␉for (menu = parent->list; menu; menu = menu->next) {␊
355␉␉if (sym && sym_is_choice(sym) &&␊
356␉␉ menu->sym && !sym_is_choice_value(menu->sym)) {␊
357␉␉␉current_entry = menu;␊
358␉␉␉menu->sym->flags |= SYMBOL_CHOICEVAL;␊
359␉␉␉if (!menu->prompt)␊
360␉␉␉␉menu_warn(menu, "choice value must have a prompt");␊
361␉␉␉for (prop = menu->sym->prop; prop; prop = prop->next) {␊
362␉␉␉␉if (prop->type == P_DEFAULT)␊
363␉␉␉␉␉prop_warn(prop, "defaults for choice "␊
364␉␉␉␉␉␉ "values not supported");␊
365␉␉␉␉if (prop->menu == menu)␊
366␉␉␉␉␉continue;␊
367␉␉␉␉if (prop->type == P_PROMPT &&␊
368␉␉␉␉ prop->menu->parent->sym != sym)␊
369␉␉␉␉␉prop_warn(prop, "choice value used outside its choice group");␊
370␉␉␉}␊
371␉␉␉/* Non-tristate choice values of tristate choices must␊
372␉␉␉ * depend on the choice being set to Y. The choice␊
373␉␉␉ * values' dependencies were propagated to their␊
374␉␉␉ * properties above, so the change here must be re-␊
375␉␉␉ * propagated.␊
376␉␉␉ */␊
377␉␉␉if (sym->type == S_TRISTATE && menu->sym->type != S_TRISTATE) {␊
378␉␉␉␉basedep = expr_alloc_comp(E_EQUAL, sym, &symbol_yes);␊
379␉␉␉␉menu->dep = expr_alloc_and(basedep, menu->dep);␊
380␉␉␉␉for (prop = menu->sym->prop; prop; prop = prop->next) {␊
381␉␉␉␉␉if (prop->menu != menu)␊
382␉␉␉␉␉␉continue;␊
383␉␉␉␉␉prop->visible.expr = expr_alloc_and(expr_copy(basedep),␊
384␉␉␉␉␉␉␉␉␉ prop->visible.expr);␊
385␉␉␉␉}␊
386␉␉␉}␊
387␉␉␉menu_add_symbol(P_CHOICE, sym, NULL);␊
388␉␉␉prop = sym_get_choice_prop(sym);␊
389␉␉␉for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr)␊
390␉␉␉␉;␊
391␉␉␉*ep = expr_alloc_one(E_LIST, NULL);␊
392␉␉␉(*ep)->right.sym = menu->sym;␊
393␉␉}␊
394␉␉if (menu->list && (!menu->prompt || !menu->prompt->text)) {␊
395␉␉␉for (last_menu = menu->list; ; last_menu = last_menu->next) {␊
396␉␉␉␉last_menu->parent = parent;␊
397␉␉␉␉if (!last_menu->next)␊
398␉␉␉␉␉break;␊
399␉␉␉}␊
400␉␉␉last_menu->next = menu->next;␊
401␉␉␉menu->next = menu->list;␊
402␉␉␉menu->list = NULL;␊
403␉␉}␊
404␉}␊
405␊
406␉if (sym && !(sym->flags & SYMBOL_WARNED)) {␊
407␉␉if (sym->type == S_UNKNOWN)␊
408␉␉␉menu_warn(parent, "config symbol defined without type");␊
409␊
410␉␉if (sym_is_choice(sym) && !parent->prompt)␊
411␉␉␉menu_warn(parent, "choice must have a prompt");␊
412␊
413␉␉/* Check properties connected to this symbol */␊
414␉␉sym_check_prop(sym);␊
415␉␉sym->flags |= SYMBOL_WARNED;␊
416␉}␊
417␊
418␉if (sym && !sym_is_optional(sym) && parent->prompt) {␊
419␉␉sym->rev_dep.expr = expr_alloc_or(sym->rev_dep.expr,␊
420␉␉␉␉expr_alloc_and(parent->prompt->visible.expr,␊
421␉␉␉␉␉expr_alloc_symbol(&symbol_mod)));␊
422␉}␊
423}␊
424␊
425bool menu_has_prompt(struct menu *menu)␊
426{␊
427␉if (!menu->prompt)␊
428␉␉return false;␊
429␉return true;␊
430}␊
431␊
432bool menu_is_visible(struct menu *menu)␊
433{␊
434␉struct menu *child;␊
435␉struct symbol *sym;␊
436␉tristate visible;␊
437␊
438␉if (!menu->prompt)␊
439␉␉return false;␊
440␊
441␉if (menu->visibility) {␊
442␉␉if (expr_calc_value(menu->visibility) == no)␊
443␉␉␉return no;␊
444␉}␊
445␊
446␉sym = menu->sym;␊
447␉if (sym) {␊
448␉␉sym_calc_value(sym);␊
449␉␉visible = menu->prompt->visible.tri;␊
450␉} else␊
451␉␉visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr);␊
452␊
453␉if (visible != no)␊
454␉␉return true;␊
455␊
456␉if (!sym || sym_get_tristate_value(menu->sym) == no)␊
457␉␉return false;␊
458␊
459␉for (child = menu->list; child; child = child->next) {␊
460␉␉if (menu_is_visible(child)) {␊
461␉␉␉if (sym)␊
462␉␉␉␉sym->flags |= SYMBOL_DEF_USER;␊
463␉␉␉return true;␊
464␉␉}␊
465␉}␊
466␊
467␉return false;␊
468}␊
469␊
470const char *menu_get_prompt(struct menu *menu)␊
471{␊
472␉if (menu->prompt)␊
473␉␉return menu->prompt->text;␊
474␉else if (menu->sym)␊
475␉␉return menu->sym->name;␊
476␉return NULL;␊
477}␊
478␊
479struct menu *menu_get_root_menu(struct menu *menu)␊
480{␊
481␉return &rootmenu;␊
482}␊
483␊
484struct menu *menu_get_parent_menu(struct menu *menu)␊
485{␊
486␉enum prop_type type;␊
487␊
488␉for (; menu != &rootmenu; menu = menu->parent) {␊
489␉␉type = menu->prompt ? menu->prompt->type : 0;␊
490␉␉if (type == P_MENU)␊
491␉␉␉break;␊
492␉}␊
493␉return menu;␊
494}␊
495␊
496bool menu_has_help(struct menu *menu)␊
497{␊
498␉return menu->help != NULL;␊
499}␊
500␊
501const char *menu_get_help(struct menu *menu)␊
502{␊
503␉if (menu->help)␊
504␉␉return menu->help;␊
505␉else␊
506␉␉return "";␊
507}␊
508␊
509static void get_prompt_str(struct gstr *r, struct property *prop)␊
510{␊
511␉int i, j;␊
512␉struct menu *submenu[8], *menu;␊
513␊
514␉str_printf(r, _("Prompt: %s\n"), _(prop->text));␊
515␉str_printf(r, _(" Defined at %s:%d\n"), prop->menu->file->name,␊
516␉␉prop->menu->lineno);␊
517␉if (!expr_is_yes(prop->visible.expr)) {␊
518␉␉str_append(r, _(" Depends on: "));␊
519␉␉expr_gstr_print(prop->visible.expr, r);␊
520␉␉str_append(r, "\n");␊
521␉}␊
522␉menu = prop->menu->parent;␊
523␉for (i = 0; menu != &rootmenu && i < 8; menu = menu->parent)␊
524␉␉submenu[i++] = menu;␊
525␉if (i > 0) {␊
526␉␉str_printf(r, _(" Location:\n"));␊
527␉␉for (j = 4; --i >= 0; j += 2) {␊
528␉␉␉menu = submenu[i];␊
529␉␉␉str_printf(r, "%*c-> %s", j, ' ', _(menu_get_prompt(menu)));␊
530␉␉␉if (menu->sym) {␊
531␉␉␉␉str_printf(r, " (%s [=%s])", menu->sym->name ?␊
532␉␉␉␉␉menu->sym->name : _("<choice>"),␊
533␉␉␉␉␉sym_get_string_value(menu->sym));␊
534␉␉␉}␊
535␉␉␉str_append(r, "\n");␊
536␉␉}␊
537␉}␊
538}␊
539␊
540void get_symbol_str(struct gstr *r, struct symbol *sym)␊
541{␊
542␉bool hit;␊
543␉struct property *prop;␊
544␊
545␉if (sym && sym->name) {␊
546␉␉str_printf(r, "Symbol: %s [=%s]\n", sym->name,␊
547␉␉␉ sym_get_string_value(sym));␊
548␉␉str_printf(r, "Type : %s\n", sym_type_name(sym->type));␊
549␉␉if (sym->type == S_INT || sym->type == S_HEX) {␊
550␉␉␉prop = sym_get_range_prop(sym);␊
551␉␉␉if (prop) {␊
552␉␉␉␉str_printf(r, "Range : ");␊
553␉␉␉␉expr_gstr_print(prop->expr, r);␊
554␉␉␉␉str_append(r, "\n");␊
555␉␉␉}␊
556␉␉}␊
557␉}␊
558␉for_all_prompts(sym, prop)␊
559␉␉get_prompt_str(r, prop);␊
560␉hit = false;␊
561␉for_all_properties(sym, prop, P_SELECT) {␊
562␉␉if (!hit) {␊
563␉␉␉str_append(r, " Selects: ");␊
564␉␉␉hit = true;␊
565␉␉} else␊
566␉␉␉str_printf(r, " && ");␊
567␉␉expr_gstr_print(prop->expr, r);␊
568␉}␊
569␉if (hit)␊
570␉␉str_append(r, "\n");␊
571␉if (sym->rev_dep.expr) {␊
572␉␉str_append(r, _(" Selected by: "));␊
573␉␉expr_gstr_print(sym->rev_dep.expr, r);␊
574␉␉str_append(r, "\n");␊
575␉}␊
576␉str_append(r, "\n\n");␊
577}␊
578␊
579struct gstr get_relations_str(struct symbol **sym_arr)␊
580{␊
581␉struct symbol *sym;␊
582␉struct gstr res = str_new();␊
583␉int i;␊
584␊
585␉for (i = 0; sym_arr && (sym = sym_arr[i]); i++)␊
586␉␉get_symbol_str(&res, sym);␊
587␉if (!i)␊
588␉␉str_append(&res, _("No matches found.\n"));␊
589␉return res;␊
590}␊
591␊
592␊
593void menu_get_ext_help(struct menu *menu, struct gstr *help)␊
594{␊
595␉struct symbol *sym = menu->sym;␊
596␊
597␉if (menu_has_help(menu)) {␊
598␉␉if (sym->name) {␊
599␉␉␉str_printf(help, "%s%s:\n\n", CONFIG_, sym->name);␊
600␉␉␉str_append(help, _(menu_get_help(menu)));␊
601␉␉␉str_append(help, "\n");␊
602␉␉}␊
603␉} else {␊
604␉␉str_append(help, nohelp_text);␊
605␉}␊
606␉if (sym)␊
607␉␉get_symbol_str(help, sym);␊
608}␊
609

Archive Download this file

Revision: 1808