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