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 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 case T_OPT_ENV: 176 prop_add_env(arg); 177 break; 178 } 179 } 180 181 static int menu_range_valid_sym(struct symbol *sym, struct symbol *sym2) 182 { 183 return sym2->type == S_INT || sym2->type == S_HEX || 184 (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name)); 185 } 186 187 void sym_check_prop(struct symbol *sym) 188 { 189 struct property *prop; 190 struct symbol *sym2; 191 for (prop = sym->prop; prop; prop = prop->next) { 192 switch (prop->type) { 193 case P_DEFAULT: 194 if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) && 195 prop->expr->type != E_SYMBOL) 196 prop_warn(prop, 197 "default for config symbol '%'" 198 " must be a single symbol", sym->name); 199 break; 200 case P_SELECT: 201 sym2 = prop_get_symbol(prop); 202 if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE) 203 prop_warn(prop, 204 "config symbol '%s' uses select, but is " 205 "not boolean or tristate", sym->name); 206 else if (sym2->type != S_UNKNOWN && 207 sym2->type != S_BOOLEAN && 208 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 if (sym->type == S_UNKNOWN) { 239 /* find the first choice value to find out choice type */ 240 current_entry = parent; 241 for (menu = parent->list; menu; menu = menu->next) { 242 if (menu->sym && menu->sym->type != S_UNKNOWN) { 243 menu_set_type(menu->sym->type); 244 break; 245 } 246 } 247 } 248 /* set the type of the remaining choice values */ 249 for (menu = parent->list; menu; menu = menu->next) { 250 current_entry = menu; 251 if (menu->sym && menu->sym->type == S_UNKNOWN) 252 menu_set_type(sym->type); 253 } 254 parentdep = expr_alloc_symbol(sym); 255 } else if (parent->prompt) 256 parentdep = parent->prompt->visible.expr; 257 else 258 parentdep = parent->dep; 259 260 for (menu = parent->list; menu; menu = menu->next) { 261 basedep = expr_transform(menu->dep); 262 basedep = expr_alloc_and(expr_copy(parentdep), basedep); 263 basedep = expr_eliminate_dups(basedep); 264 menu->dep = basedep; 265 if (menu->sym) 266 prop = menu->sym->prop; 267 else 268 prop = menu->prompt; 269 for (; prop; prop = prop->next) { 270 if (prop->menu != menu) 271 continue; 272 dep = expr_transform(prop->visible.expr); 273 dep = expr_alloc_and(expr_copy(basedep), dep); 274 dep = expr_eliminate_dups(dep); 275 if (menu->sym && menu->sym->type != S_TRISTATE) 276 dep = expr_trans_bool(dep); 277 prop->visible.expr = dep; 278 if (prop->type == P_SELECT) { 279 struct symbol *es = prop_get_symbol(prop); 280 es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr, 281 expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep))); 282 } 283 } 284 } 285 for (menu = parent->list; menu; menu = menu->next) 286 menu_finalize(menu); 287 } else if (sym) { 288 basedep = parent->prompt ? parent->prompt->visible.expr : NULL; 289 basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no); 290 basedep = expr_eliminate_dups(expr_transform(basedep)); 291 last_menu = NULL; 292 for (menu = parent->next; menu; menu = menu->next) { 293 dep = menu->prompt ? menu->prompt->visible.expr : menu->dep; 294 if (!expr_contains_symbol(dep, sym)) 295 break; 296 if (expr_depends_symbol(dep, sym)) 297 goto next; 298 dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no); 299 dep = expr_eliminate_dups(expr_transform(dep)); 300 dep2 = expr_copy(basedep); 301 expr_eliminate_eq(&dep, &dep2); 302 expr_free(dep); 303 if (!expr_is_yes(dep2)) { 304 expr_free(dep2); 305 break; 306 } 307 expr_free(dep2); 308 next: 309 menu_finalize(menu); 310 menu->parent = parent; 311 last_menu = menu; 312 } 313 if (last_menu) { 314 parent->list = parent->next; 315 parent->next = last_menu->next; 316 last_menu->next = NULL; 317 } 318 } 319 for (menu = parent->list; menu; menu = menu->next) { 320 if (sym && sym_is_choice(sym) && 321 menu->sym && !sym_is_choice_value(menu->sym)) { 322 current_entry = menu; 323 menu->sym->flags |= SYMBOL_CHOICEVAL; 324 if (!menu->prompt) 325 menu_warn(menu, "choice value must have a prompt"); 326 for (prop = menu->sym->prop; prop; prop = prop->next) { 327 if (prop->type == P_DEFAULT) 328 prop_warn(prop, "defaults for choice " 329 "values not supported"); 330 if (prop->menu == menu) 331 continue; 332 if (prop->type == P_PROMPT && 333 prop->menu->parent->sym != sym) 334 prop_warn(prop, "choice value used outside its choice group"); 335 } 336 /* Non-tristate choice values of tristate choices must 337 * depend on the choice being set to Y. The choice 338 * values' dependencies were propagated to their 339 * properties above, so the change here must be re- 340 * propagated. 341 */ 342 if (sym->type == S_TRISTATE && menu->sym->type != S_TRISTATE) { 343 basedep = expr_alloc_comp(E_EQUAL, sym, &symbol_yes); 344 menu->dep = expr_alloc_and(basedep, menu->dep); 345 for (prop = menu->sym->prop; prop; prop = prop->next) { 346 if (prop->menu != menu) 347 continue; 348 prop->visible.expr = expr_alloc_and(expr_copy(basedep), 349 prop->visible.expr); 350 } 351 } 352 menu_add_symbol(P_CHOICE, sym, NULL); 353 prop = sym_get_choice_prop(sym); 354 for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr) 355 ; 356 *ep = expr_alloc_one(E_LIST, NULL); 357 (*ep)->right.sym = menu->sym; 358 } 359 if (menu->list && (!menu->prompt || !menu->prompt->text)) { 360 for (last_menu = menu->list; ; last_menu = last_menu->next) { 361 last_menu->parent = parent; 362 if (!last_menu->next) 363 break; 364 } 365 last_menu->next = menu->next; 366 menu->next = menu->list; 367 menu->list = NULL; 368 } 369 } 370 371 if (sym && !(sym->flags & SYMBOL_WARNED)) { 372 if (sym->type == S_UNKNOWN) 373 menu_warn(parent, "config symbol defined without type"); 374 375 if (sym_is_choice(sym) && !parent->prompt) 376 menu_warn(parent, "choice must have a prompt"); 377 378 /* Check properties connected to this symbol */ 379 sym_check_prop(sym); 380 sym->flags |= SYMBOL_WARNED; 381 } 382 383 if (sym && !sym_is_optional(sym) && parent->prompt) { 384 sym->rev_dep.expr = expr_alloc_or(sym->rev_dep.expr, 385 expr_alloc_and(parent->prompt->visible.expr, 386 expr_alloc_symbol(&symbol_mod))); 387 } 388 } 389 390 bool menu_is_visible(struct menu *menu) 391 { 392 struct menu *child; 393 struct symbol *sym; 394 tristate visible; 395 396 if (!menu->prompt) 397 return false; 398 sym = menu->sym; 399 if (sym) { 400 sym_calc_value(sym); 401 visible = menu->prompt->visible.tri; 402 } else 403 visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr); 404 405 if (visible != no) 406 return true; 407 if (!sym || sym_get_tristate_value(menu->sym) == no) 408 return false; 409 410 for (child = menu->list; child; child = child->next) 411 if (menu_is_visible(child)) 412 return true; 413 return false; 414 } 415 416 const char *menu_get_prompt(struct menu *menu) 417 { 418 if (menu->prompt) 419 return menu->prompt->text; 420 else if (menu->sym) 421 return menu->sym->name; 422 return NULL; 423 } 424 425 struct menu *menu_get_root_menu(struct menu *menu) 426 { 427 return &rootmenu; 428 } 429 430 struct menu *menu_get_parent_menu(struct menu *menu) 431 { 432 enum prop_type type; 433 434 for (; menu != &rootmenu; menu = menu->parent) { 435 type = menu->prompt ? menu->prompt->type : 0; 436 if (type == P_MENU) 437 break; 438 } 439 return menu; 440 } 441 442 bool menu_has_help(struct menu *menu) 443 { 444 return menu->help != NULL; 445 } 446 447 const char *menu_get_help(struct menu *menu) 448 { 449 if (menu->help) 450 return menu->help; 451 else 452 return ""; 453 } 454