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