1 /* 2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org> 3 * Released under the terms of the GNU GPL v2.0. 4 */ 5 6 #include <stdlib.h> 7 #include <string.h> 8 9 #define LKC_DIRECT_LINK 10 #include "lkc.h" 11 12 struct menu rootmenu; 13 static struct menu **last_entry_ptr; 14 15 struct file *file_list; 16 struct file *current_file; 17 18 static void menu_warn(struct menu *menu, const char *fmt, ...) 19 { 20 va_list ap; 21 va_start(ap, fmt); 22 fprintf(stderr, "%s:%d:warning: ", menu->file->name, menu->lineno); 23 vfprintf(stderr, fmt, ap); 24 fprintf(stderr, "\n"); 25 va_end(ap); 26 } 27 28 static void prop_warn(struct property *prop, const char *fmt, ...) 29 { 30 va_list ap; 31 va_start(ap, fmt); 32 fprintf(stderr, "%s:%d:warning: ", prop->file->name, prop->lineno); 33 vfprintf(stderr, fmt, ap); 34 fprintf(stderr, "\n"); 35 va_end(ap); 36 } 37 38 void menu_init(void) 39 { 40 current_entry = current_menu = &rootmenu; 41 last_entry_ptr = &rootmenu.list; 42 } 43 44 void menu_add_entry(struct symbol *sym) 45 { 46 struct menu *menu; 47 48 menu = malloc(sizeof(*menu)); 49 memset(menu, 0, sizeof(*menu)); 50 menu->sym = sym; 51 menu->parent = current_menu; 52 menu->file = current_file; 53 menu->lineno = zconf_lineno(); 54 55 *last_entry_ptr = menu; 56 last_entry_ptr = &menu->next; 57 current_entry = menu; 58 } 59 60 void menu_end_entry(void) 61 { 62 } 63 64 struct menu *menu_add_menu(void) 65 { 66 menu_end_entry(); 67 last_entry_ptr = ¤t_entry->list; 68 return current_menu = current_entry; 69 } 70 71 void menu_end_menu(void) 72 { 73 last_entry_ptr = ¤t_menu->next; 74 current_menu = current_menu->parent; 75 } 76 77 struct expr *menu_check_dep(struct expr *e) 78 { 79 if (!e) 80 return e; 81 82 switch (e->type) { 83 case E_NOT: 84 e->left.expr = menu_check_dep(e->left.expr); 85 break; 86 case E_OR: 87 case E_AND: 88 e->left.expr = menu_check_dep(e->left.expr); 89 e->right.expr = menu_check_dep(e->right.expr); 90 break; 91 case E_SYMBOL: 92 /* change 'm' into 'm' && MODULES */ 93 if (e->left.sym == &symbol_mod) 94 return expr_alloc_and(e, expr_alloc_symbol(modules_sym)); 95 break; 96 default: 97 break; 98 } 99 return e; 100 } 101 102 void menu_add_dep(struct expr *dep) 103 { 104 current_entry->dep = expr_alloc_and(current_entry->dep, menu_check_dep(dep)); 105 } 106 107 void menu_set_type(int type) 108 { 109 struct symbol *sym = current_entry->sym; 110 111 if (sym->type == type) 112 return; 113 if (sym->type == S_UNKNOWN) { 114 sym->type = type; 115 return; 116 } 117 menu_warn(current_entry, "type of '%s' redefined from '%s' to '%s'", 118 sym->name ? sym->name : "<choice>", 119 sym_type_name(sym->type), sym_type_name(type)); 120 } 121 122 struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep) 123 { 124 struct property *prop = prop_alloc(type, current_entry->sym); 125 126 prop->menu = current_entry; 127 prop->expr = expr; 128 prop->visible.expr = menu_check_dep(dep); 129 130 if (prompt) { 131 if (isspace(*prompt)) { 132 prop_warn(prop, "leading whitespace ignored"); 133 while (isspace(*prompt)) 134 prompt++; 135 } 136 if (current_entry->prompt) 137 prop_warn(prop, "prompt redefined"); 138 current_entry->prompt = prop; 139 } 140 prop->text = prompt; 141 142 return prop; 143 } 144 145 struct property *menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep) 146 { 147 return menu_add_prop(type, prompt, NULL, dep); 148 } 149 150 void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep) 151 { 152 menu_add_prop(type, NULL, expr, dep); 153 } 154 155 void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep) 156 { 157 menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep); 158 } 159 160 void menu_add_option(int token, char *arg) 161 { 162 struct property *prop; 163 164 switch (token) { 165 case T_OPT_MODULES: 166 prop = prop_alloc(P_DEFAULT, modules_sym); 167 prop->expr = expr_alloc_symbol(current_entry->sym); 168 break; 169 case T_OPT_DEFCONFIG_LIST: 170 if (!sym_defconfig_list) 171 sym_defconfig_list = current_entry->sym; 172 else if (sym_defconfig_list != current_entry->sym) 173 zconf_error("trying to redefine defconfig symbol"); 174 break; 175 } 176 } 177 178 static int menu_range_valid_sym(struct symbol *sym, struct symbol *sym2) 179 { 180 return sym2->type == S_INT || sym2->type == S_HEX || 181 (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name)); 182 } 183 184 void sym_check_prop(struct symbol *sym) 185 { 186 struct property *prop; 187 struct symbol *sym2; 188 for (prop = sym->prop; prop; prop = prop->next) { 189 switch (prop->type) { 190 case P_DEFAULT: 191 if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) && 192 prop->expr->type != E_SYMBOL) 193 prop_warn(prop, 194 "default for config symbol '%'" 195 " must be a single symbol", sym->name); 196 break; 197 case P_SELECT: 198 sym2 = prop_get_symbol(prop); 199 if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE) 200 prop_warn(prop, 201 "config symbol '%s' uses select, but is " 202 "not boolean or tristate", sym->name); 203 else if (sym2->type == S_UNKNOWN) 204 prop_warn(prop, 205 "'select' used by config symbol '%s' " 206 "refers to undefined symbol '%s'", 207 sym->name, sym2->name); 208 else if (sym2->type != S_BOOLEAN && sym2->type != S_TRISTATE) 209 prop_warn(prop, 210 "'%s' has wrong type. 'select' only " 211 "accept arguments of boolean and " 212 "tristate type", sym2->name); 213 break; 214 case P_RANGE: 215 if (sym->type != S_INT && sym->type != S_HEX) 216 prop_warn(prop, "range is only allowed " 217 "for int or hex symbols"); 218 if (!menu_range_valid_sym(sym, prop->expr->left.sym) || 219 !menu_range_valid_sym(sym, prop->expr->right.sym)) 220 prop_warn(prop, "range is invalid"); 221 break; 222 default: 223 ; 224 } 225 } 226 } 227 228 void menu_finalize(struct menu *parent) 229 { 230 struct menu *menu, *last_menu; 231 struct symbol *sym; 232 struct property *prop; 233 struct expr *parentdep, *basedep, *dep, *dep2, **ep; 234 235 sym = parent->sym; 236 if (parent->list) { 237 if (sym && sym_is_choice(sym)) { 238 /* find out choice type */ 239 enum symbol_type type = S_UNKNOWN; 240 241 for (menu = parent->list; menu; menu = menu->next) { 242 if (menu->sym && menu->sym->type != S_UNKNOWN) { 243 if (type == S_UNKNOWN) 244 type = menu->sym->type; 245 if (type != S_BOOLEAN) 246 break; 247 if (menu->sym->type == S_TRISTATE) { 248 type = S_TRISTATE; 249 break; 250 } 251 } 252 } 253 current_entry = parent; 254 menu_set_type(type); 255 parentdep = expr_alloc_symbol(sym); 256 } else if (parent->prompt) 257 parentdep = parent->prompt->visible.expr; 258 else 259 parentdep = parent->dep; 260 261 for (menu = parent->list; menu; menu = menu->next) { 262 basedep = expr_transform(menu->dep); 263 dep = parentdep; 264 if (sym && sym_is_choice(sym) && menu->sym) { 265 enum symbol_type type = menu->sym->type; 266 267 if (type == S_UNKNOWN) 268 type = sym->type; 269 if (type != S_TRISTATE) 270 dep = expr_alloc_comp(E_EQUAL, sym, &symbol_yes); 271 } 272 basedep = expr_alloc_and(expr_copy(dep), basedep); 273 basedep = expr_eliminate_dups(basedep); 274 menu->dep = basedep; 275 if (menu->sym) 276 prop = menu->sym->prop; 277 else 278 prop = menu->prompt; 279 for (; prop; prop = prop->next) { 280 if (prop->menu != menu) 281 continue; 282 dep = expr_transform(prop->visible.expr); 283 dep = expr_alloc_and(expr_copy(basedep), dep); 284 dep = expr_eliminate_dups(dep); 285 if (menu->sym && menu->sym->type != S_TRISTATE) 286 dep = expr_trans_bool(dep); 287 prop->visible.expr = dep; 288 if (prop->type == P_SELECT) { 289 struct symbol *es = prop_get_symbol(prop); 290 es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr, 291 expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep))); 292 } 293 } 294 } 295 for (menu = parent->list; menu; menu = menu->next) 296 menu_finalize(menu); 297 } else if (sym) { 298 basedep = parent->prompt ? parent->prompt->visible.expr : NULL; 299 basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no); 300 basedep = expr_eliminate_dups(expr_transform(basedep)); 301 last_menu = NULL; 302 for (menu = parent->next; menu; menu = menu->next) { 303 dep = menu->prompt ? menu->prompt->visible.expr : menu->dep; 304 if (!expr_contains_symbol(dep, sym)) 305 break; 306 if (expr_depends_symbol(dep, sym)) 307 goto next; 308 dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no); 309 dep = expr_eliminate_dups(expr_transform(dep)); 310 dep2 = expr_copy(basedep); 311 expr_eliminate_eq(&dep, &dep2); 312 expr_free(dep); 313 if (!expr_is_yes(dep2)) { 314 expr_free(dep2); 315 break; 316 } 317 expr_free(dep2); 318 next: 319 menu_finalize(menu); 320 menu->parent = parent; 321 last_menu = menu; 322 } 323 if (last_menu) { 324 parent->list = parent->next; 325 parent->next = last_menu->next; 326 last_menu->next = NULL; 327 } 328 } 329 for (menu = parent->list; menu; menu = menu->next) { 330 if (sym && sym_is_choice(sym) && menu->sym) { 331 menu->sym->flags |= SYMBOL_CHOICEVAL; 332 if (!menu->prompt) 333 menu_warn(menu, "choice value must have a prompt"); 334 for (prop = menu->sym->prop; prop; prop = prop->next) { 335 if (prop->type == P_PROMPT && prop->menu != menu) { 336 prop_warn(prop, "choice values " 337 "currently only support a " 338 "single prompt"); 339 } 340 if (prop->type == P_DEFAULT) 341 prop_warn(prop, "defaults for choice " 342 "values not supported"); 343 } 344 current_entry = menu; 345 if (menu->sym->type == S_UNKNOWN) 346 menu_set_type(sym->type); 347 menu_add_symbol(P_CHOICE, sym, NULL); 348 prop = sym_get_choice_prop(sym); 349 for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr) 350 ; 351 *ep = expr_alloc_one(E_CHOICE, NULL); 352 (*ep)->right.sym = menu->sym; 353 } 354 if (menu->list && (!menu->prompt || !menu->prompt->text)) { 355 for (last_menu = menu->list; ; last_menu = last_menu->next) { 356 last_menu->parent = parent; 357 if (!last_menu->next) 358 break; 359 } 360 last_menu->next = menu->next; 361 menu->next = menu->list; 362 menu->list = NULL; 363 } 364 } 365 366 if (sym && !(sym->flags & SYMBOL_WARNED)) { 367 if (sym->type == S_UNKNOWN) 368 menu_warn(parent, "config symbol defined without type"); 369 370 if (sym_is_choice(sym) && !parent->prompt) 371 menu_warn(parent, "choice must have a prompt"); 372 373 /* Check properties connected to this symbol */ 374 sym_check_prop(sym); 375 sym->flags |= SYMBOL_WARNED; 376 } 377 378 if (sym && !sym_is_optional(sym) && parent->prompt) { 379 sym->rev_dep.expr = expr_alloc_or(sym->rev_dep.expr, 380 expr_alloc_and(parent->prompt->visible.expr, 381 expr_alloc_symbol(&symbol_mod))); 382 } 383 } 384 385 bool menu_is_visible(struct menu *menu) 386 { 387 struct menu *child; 388 struct symbol *sym; 389 tristate visible; 390 391 if (!menu->prompt) 392 return false; 393 sym = menu->sym; 394 if (sym) { 395 sym_calc_value(sym); 396 visible = menu->prompt->visible.tri; 397 } else 398 visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr); 399 400 if (visible != no) 401 return true; 402 if (!sym || sym_get_tristate_value(menu->sym) == no) 403 return false; 404 405 for (child = menu->list; child; child = child->next) 406 if (menu_is_visible(child)) 407 return true; 408 return false; 409 } 410 411 const char *menu_get_prompt(struct menu *menu) 412 { 413 if (menu->prompt) 414 return _(menu->prompt->text); 415 else if (menu->sym) 416 return _(menu->sym->name); 417 return NULL; 418 } 419 420 struct menu *menu_get_root_menu(struct menu *menu) 421 { 422 return &rootmenu; 423 } 424 425 struct menu *menu_get_parent_menu(struct menu *menu) 426 { 427 enum prop_type type; 428 429 for (; menu != &rootmenu; menu = menu->parent) { 430 type = menu->prompt ? menu->prompt->type : 0; 431 if (type == P_MENU) 432 break; 433 } 434 return menu; 435 } 436 437 bool menu_has_help(struct menu *menu) 438 { 439 return menu->help != NULL; 440 } 441 442 const char *menu_get_help(struct menu *menu) 443 { 444 if (menu->help) 445 return menu->help; 446 else 447 return ""; 448 } 449