linux/scripts/kconfig/zconf.y
<<
>>
Prefs
   1%{
   2/*
   3 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
   4 * Released under the terms of the GNU GPL v2.0.
   5 */
   6
   7#include <ctype.h>
   8#include <stdarg.h>
   9#include <stdio.h>
  10#include <stdlib.h>
  11#include <string.h>
  12#include <stdbool.h>
  13
  14#include "lkc.h"
  15
  16#define printd(mask, fmt...) if (cdebug & (mask)) printf(fmt)
  17
  18#define PRINTD          0x0001
  19#define DEBUG_PARSE     0x0002
  20
  21int cdebug = PRINTD;
  22
  23extern int zconflex(void);
  24static void zconfprint(const char *err, ...);
  25static void zconf_error(const char *err, ...);
  26static void zconferror(const char *err);
  27static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken);
  28
  29struct symbol *symbol_hash[SYMBOL_HASHSIZE];
  30
  31static struct menu *current_menu, *current_entry;
  32
  33%}
  34%expect 30
  35
  36%union
  37{
  38        char *string;
  39        struct file *file;
  40        struct symbol *symbol;
  41        struct expr *expr;
  42        struct menu *menu;
  43        const struct kconf_id *id;
  44}
  45
  46%token <id>T_MAINMENU
  47%token <id>T_MENU
  48%token <id>T_ENDMENU
  49%token <id>T_SOURCE
  50%token <id>T_CHOICE
  51%token <id>T_ENDCHOICE
  52%token <id>T_COMMENT
  53%token <id>T_CONFIG
  54%token <id>T_MENUCONFIG
  55%token <id>T_HELP
  56%token <string> T_HELPTEXT
  57%token <id>T_IF
  58%token <id>T_ENDIF
  59%token <id>T_DEPENDS
  60%token <id>T_OPTIONAL
  61%token <id>T_PROMPT
  62%token <id>T_TYPE
  63%token <id>T_DEFAULT
  64%token <id>T_SELECT
  65%token <id>T_RANGE
  66%token <id>T_VISIBLE
  67%token <id>T_OPTION
  68%token <id>T_ON
  69%token <string> T_WORD
  70%token <string> T_WORD_QUOTE
  71%token T_UNEQUAL
  72%token T_CLOSE_PAREN
  73%token T_OPEN_PAREN
  74%token T_EOL
  75
  76%left T_OR
  77%left T_AND
  78%left T_EQUAL T_UNEQUAL
  79%nonassoc T_NOT
  80
  81%type <string> prompt
  82%type <symbol> symbol
  83%type <expr> expr
  84%type <expr> if_expr
  85%type <id> end
  86%type <id> option_name
  87%type <menu> if_entry menu_entry choice_entry
  88%type <string> symbol_option_arg word_opt
  89
  90%destructor {
  91        fprintf(stderr, "%s:%d: missing end statement for this entry\n",
  92                $$->file->name, $$->lineno);
  93        if (current_menu == $$)
  94                menu_end_menu();
  95} if_entry menu_entry choice_entry
  96
  97%{
  98/* Include zconf.hash.c here so it can see the token constants. */
  99#include "zconf.hash.c"
 100%}
 101
 102%%
 103input: nl start | start;
 104
 105start: mainmenu_stmt stmt_list | stmt_list;
 106
 107stmt_list:
 108          /* empty */
 109        | stmt_list common_stmt
 110        | stmt_list choice_stmt
 111        | stmt_list menu_stmt
 112        | stmt_list end                 { zconf_error("unexpected end statement"); }
 113        | stmt_list T_WORD error T_EOL  { zconf_error("unknown statement \"%s\"", $2); }
 114        | stmt_list option_name error T_EOL
 115{
 116        zconf_error("unexpected option \"%s\"", kconf_id_strings + $2->name);
 117}
 118        | stmt_list error T_EOL         { zconf_error("invalid statement"); }
 119;
 120
 121option_name:
 122        T_DEPENDS | T_PROMPT | T_TYPE | T_SELECT | T_OPTIONAL | T_RANGE | T_DEFAULT | T_VISIBLE
 123;
 124
 125common_stmt:
 126          T_EOL
 127        | if_stmt
 128        | comment_stmt
 129        | config_stmt
 130        | menuconfig_stmt
 131        | source_stmt
 132;
 133
 134option_error:
 135          T_WORD error T_EOL            { zconf_error("unknown option \"%s\"", $1); }
 136        | error T_EOL                   { zconf_error("invalid option"); }
 137;
 138
 139
 140/* config/menuconfig entry */
 141
 142config_entry_start: T_CONFIG T_WORD T_EOL
 143{
 144        struct symbol *sym = sym_lookup($2, 0);
 145        sym->flags |= SYMBOL_OPTIONAL;
 146        menu_add_entry(sym);
 147        printd(DEBUG_PARSE, "%s:%d:config %s\n", zconf_curname(), zconf_lineno(), $2);
 148};
 149
 150config_stmt: config_entry_start config_option_list
 151{
 152        menu_end_entry();
 153        printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
 154};
 155
 156menuconfig_entry_start: T_MENUCONFIG T_WORD T_EOL
 157{
 158        struct symbol *sym = sym_lookup($2, 0);
 159        sym->flags |= SYMBOL_OPTIONAL;
 160        menu_add_entry(sym);
 161        printd(DEBUG_PARSE, "%s:%d:menuconfig %s\n", zconf_curname(), zconf_lineno(), $2);
 162};
 163
 164menuconfig_stmt: menuconfig_entry_start config_option_list
 165{
 166        if (current_entry->prompt)
 167                current_entry->prompt->type = P_MENU;
 168        else
 169                zconfprint("warning: menuconfig statement without prompt");
 170        menu_end_entry();
 171        printd(DEBUG_PARSE, "%s:%d:endconfig\n", zconf_curname(), zconf_lineno());
 172};
 173
 174config_option_list:
 175          /* empty */
 176        | config_option_list config_option
 177        | config_option_list symbol_option
 178        | config_option_list depends
 179        | config_option_list help
 180        | config_option_list option_error
 181        | config_option_list T_EOL
 182;
 183
 184config_option: T_TYPE prompt_stmt_opt T_EOL
 185{
 186        menu_set_type($1->stype);
 187        printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
 188                zconf_curname(), zconf_lineno(),
 189                $1->stype);
 190};
 191
 192config_option: T_PROMPT prompt if_expr T_EOL
 193{
 194        menu_add_prompt(P_PROMPT, $2, $3);
 195        printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
 196};
 197
 198config_option: T_DEFAULT expr if_expr T_EOL
 199{
 200        menu_add_expr(P_DEFAULT, $2, $3);
 201        if ($1->stype != S_UNKNOWN)
 202                menu_set_type($1->stype);
 203        printd(DEBUG_PARSE, "%s:%d:default(%u)\n",
 204                zconf_curname(), zconf_lineno(),
 205                $1->stype);
 206};
 207
 208config_option: T_SELECT T_WORD if_expr T_EOL
 209{
 210        menu_add_symbol(P_SELECT, sym_lookup($2, 0), $3);
 211        printd(DEBUG_PARSE, "%s:%d:select\n", zconf_curname(), zconf_lineno());
 212};
 213
 214config_option: T_RANGE symbol symbol if_expr T_EOL
 215{
 216        menu_add_expr(P_RANGE, expr_alloc_comp(E_RANGE,$2, $3), $4);
 217        printd(DEBUG_PARSE, "%s:%d:range\n", zconf_curname(), zconf_lineno());
 218};
 219
 220symbol_option: T_OPTION symbol_option_list T_EOL
 221;
 222
 223symbol_option_list:
 224          /* empty */
 225        | symbol_option_list T_WORD symbol_option_arg
 226{
 227        const struct kconf_id *id = kconf_id_lookup($2, strlen($2));
 228        if (id && id->flags & TF_OPTION)
 229                menu_add_option(id->token, $3);
 230        else
 231                zconfprint("warning: ignoring unknown option %s", $2);
 232        free($2);
 233};
 234
 235symbol_option_arg:
 236          /* empty */           { $$ = NULL; }
 237        | T_EQUAL prompt        { $$ = $2; }
 238;
 239
 240/* choice entry */
 241
 242choice: T_CHOICE word_opt T_EOL
 243{
 244        struct symbol *sym = sym_lookup($2, SYMBOL_CHOICE);
 245        sym->flags |= SYMBOL_AUTO;
 246        menu_add_entry(sym);
 247        menu_add_expr(P_CHOICE, NULL, NULL);
 248        printd(DEBUG_PARSE, "%s:%d:choice\n", zconf_curname(), zconf_lineno());
 249};
 250
 251choice_entry: choice choice_option_list
 252{
 253        $$ = menu_add_menu();
 254};
 255
 256choice_end: end
 257{
 258        if (zconf_endtoken($1, T_CHOICE, T_ENDCHOICE)) {
 259                menu_end_menu();
 260                printd(DEBUG_PARSE, "%s:%d:endchoice\n", zconf_curname(), zconf_lineno());
 261        }
 262};
 263
 264choice_stmt: choice_entry choice_block choice_end
 265;
 266
 267choice_option_list:
 268          /* empty */
 269        | choice_option_list choice_option
 270        | choice_option_list depends
 271        | choice_option_list help
 272        | choice_option_list T_EOL
 273        | choice_option_list option_error
 274;
 275
 276choice_option: T_PROMPT prompt if_expr T_EOL
 277{
 278        menu_add_prompt(P_PROMPT, $2, $3);
 279        printd(DEBUG_PARSE, "%s:%d:prompt\n", zconf_curname(), zconf_lineno());
 280};
 281
 282choice_option: T_TYPE prompt_stmt_opt T_EOL
 283{
 284        if ($1->stype == S_BOOLEAN || $1->stype == S_TRISTATE) {
 285                menu_set_type($1->stype);
 286                printd(DEBUG_PARSE, "%s:%d:type(%u)\n",
 287                        zconf_curname(), zconf_lineno(),
 288                        $1->stype);
 289        } else
 290                YYERROR;
 291};
 292
 293choice_option: T_OPTIONAL T_EOL
 294{
 295        current_entry->sym->flags |= SYMBOL_OPTIONAL;
 296        printd(DEBUG_PARSE, "%s:%d:optional\n", zconf_curname(), zconf_lineno());
 297};
 298
 299choice_option: T_DEFAULT T_WORD if_expr T_EOL
 300{
 301        if ($1->stype == S_UNKNOWN) {
 302                menu_add_symbol(P_DEFAULT, sym_lookup($2, 0), $3);
 303                printd(DEBUG_PARSE, "%s:%d:default\n",
 304                        zconf_curname(), zconf_lineno());
 305        } else
 306                YYERROR;
 307};
 308
 309choice_block:
 310          /* empty */
 311        | choice_block common_stmt
 312;
 313
 314/* if entry */
 315
 316if_entry: T_IF expr nl
 317{
 318        printd(DEBUG_PARSE, "%s:%d:if\n", zconf_curname(), zconf_lineno());
 319        menu_add_entry(NULL);
 320        menu_add_dep($2);
 321        $$ = menu_add_menu();
 322};
 323
 324if_end: end
 325{
 326        if (zconf_endtoken($1, T_IF, T_ENDIF)) {
 327                menu_end_menu();
 328                printd(DEBUG_PARSE, "%s:%d:endif\n", zconf_curname(), zconf_lineno());
 329        }
 330};
 331
 332if_stmt: if_entry if_block if_end
 333;
 334
 335if_block:
 336          /* empty */
 337        | if_block common_stmt
 338        | if_block menu_stmt
 339        | if_block choice_stmt
 340;
 341
 342/* mainmenu entry */
 343
 344mainmenu_stmt: T_MAINMENU prompt nl
 345{
 346        menu_add_prompt(P_MENU, $2, NULL);
 347};
 348
 349/* menu entry */
 350
 351menu: T_MENU prompt T_EOL
 352{
 353        menu_add_entry(NULL);
 354        menu_add_prompt(P_MENU, $2, NULL);
 355        printd(DEBUG_PARSE, "%s:%d:menu\n", zconf_curname(), zconf_lineno());
 356};
 357
 358menu_entry: menu visibility_list depends_list
 359{
 360        $$ = menu_add_menu();
 361};
 362
 363menu_end: end
 364{
 365        if (zconf_endtoken($1, T_MENU, T_ENDMENU)) {
 366                menu_end_menu();
 367                printd(DEBUG_PARSE, "%s:%d:endmenu\n", zconf_curname(), zconf_lineno());
 368        }
 369};
 370
 371menu_stmt: menu_entry menu_block menu_end
 372;
 373
 374menu_block:
 375          /* empty */
 376        | menu_block common_stmt
 377        | menu_block menu_stmt
 378        | menu_block choice_stmt
 379;
 380
 381source_stmt: T_SOURCE prompt T_EOL
 382{
 383        printd(DEBUG_PARSE, "%s:%d:source %s\n", zconf_curname(), zconf_lineno(), $2);
 384        zconf_nextfile($2);
 385};
 386
 387/* comment entry */
 388
 389comment: T_COMMENT prompt T_EOL
 390{
 391        menu_add_entry(NULL);
 392        menu_add_prompt(P_COMMENT, $2, NULL);
 393        printd(DEBUG_PARSE, "%s:%d:comment\n", zconf_curname(), zconf_lineno());
 394};
 395
 396comment_stmt: comment depends_list
 397{
 398        menu_end_entry();
 399};
 400
 401/* help option */
 402
 403help_start: T_HELP T_EOL
 404{
 405        printd(DEBUG_PARSE, "%s:%d:help\n", zconf_curname(), zconf_lineno());
 406        zconf_starthelp();
 407};
 408
 409help: help_start T_HELPTEXT
 410{
 411        current_entry->help = $2;
 412};
 413
 414/* depends option */
 415
 416depends_list:
 417          /* empty */
 418        | depends_list depends
 419        | depends_list T_EOL
 420        | depends_list option_error
 421;
 422
 423depends: T_DEPENDS T_ON expr T_EOL
 424{
 425        menu_add_dep($3);
 426        printd(DEBUG_PARSE, "%s:%d:depends on\n", zconf_curname(), zconf_lineno());
 427};
 428
 429/* visibility option */
 430
 431visibility_list:
 432          /* empty */
 433        | visibility_list visible
 434        | visibility_list T_EOL
 435;
 436
 437visible: T_VISIBLE if_expr
 438{
 439        menu_add_visibility($2);
 440};
 441
 442/* prompt statement */
 443
 444prompt_stmt_opt:
 445          /* empty */
 446        | prompt if_expr
 447{
 448        menu_add_prompt(P_PROMPT, $1, $2);
 449};
 450
 451prompt:   T_WORD
 452        | T_WORD_QUOTE
 453;
 454
 455end:      T_ENDMENU T_EOL       { $$ = $1; }
 456        | T_ENDCHOICE T_EOL     { $$ = $1; }
 457        | T_ENDIF T_EOL         { $$ = $1; }
 458;
 459
 460nl:
 461          T_EOL
 462        | nl T_EOL
 463;
 464
 465if_expr:  /* empty */                   { $$ = NULL; }
 466        | T_IF expr                     { $$ = $2; }
 467;
 468
 469expr:     symbol                                { $$ = expr_alloc_symbol($1); }
 470        | symbol T_EQUAL symbol                 { $$ = expr_alloc_comp(E_EQUAL, $1, $3); }
 471        | symbol T_UNEQUAL symbol               { $$ = expr_alloc_comp(E_UNEQUAL, $1, $3); }
 472        | T_OPEN_PAREN expr T_CLOSE_PAREN       { $$ = $2; }
 473        | T_NOT expr                            { $$ = expr_alloc_one(E_NOT, $2); }
 474        | expr T_OR expr                        { $$ = expr_alloc_two(E_OR, $1, $3); }
 475        | expr T_AND expr                       { $$ = expr_alloc_two(E_AND, $1, $3); }
 476;
 477
 478symbol:   T_WORD        { $$ = sym_lookup($1, 0); free($1); }
 479        | T_WORD_QUOTE  { $$ = sym_lookup($1, SYMBOL_CONST); free($1); }
 480;
 481
 482word_opt: /* empty */                   { $$ = NULL; }
 483        | T_WORD
 484
 485%%
 486
 487void conf_parse(const char *name)
 488{
 489        struct symbol *sym;
 490        int i;
 491
 492        zconf_initscan(name);
 493
 494        sym_init();
 495        _menu_init();
 496        modules_sym = sym_lookup(NULL, 0);
 497        modules_sym->type = S_BOOLEAN;
 498        modules_sym->flags |= SYMBOL_AUTO;
 499        rootmenu.prompt = menu_add_prompt(P_MENU, "Linux Kernel Configuration", NULL);
 500
 501        if (getenv("ZCONF_DEBUG"))
 502                zconfdebug = 1;
 503        zconfparse();
 504        if (zconfnerrs)
 505                exit(1);
 506        if (!modules_sym->prop) {
 507                struct property *prop;
 508
 509                prop = prop_alloc(P_DEFAULT, modules_sym);
 510                prop->expr = expr_alloc_symbol(sym_lookup("MODULES", 0));
 511        }
 512
 513        rootmenu.prompt->text = _(rootmenu.prompt->text);
 514        rootmenu.prompt->text = sym_expand_string_value(rootmenu.prompt->text);
 515
 516        menu_finalize(&rootmenu);
 517        for_all_symbols(i, sym) {
 518                if (sym_check_deps(sym))
 519                        zconfnerrs++;
 520        }
 521        if (zconfnerrs)
 522                exit(1);
 523        sym_set_change_count(1);
 524}
 525
 526static const char *zconf_tokenname(int token)
 527{
 528        switch (token) {
 529        case T_MENU:            return "menu";
 530        case T_ENDMENU:         return "endmenu";
 531        case T_CHOICE:          return "choice";
 532        case T_ENDCHOICE:       return "endchoice";
 533        case T_IF:              return "if";
 534        case T_ENDIF:           return "endif";
 535        case T_DEPENDS:         return "depends";
 536        case T_VISIBLE:         return "visible";
 537        }
 538        return "<token>";
 539}
 540
 541static bool zconf_endtoken(const struct kconf_id *id, int starttoken, int endtoken)
 542{
 543        if (id->token != endtoken) {
 544                zconf_error("unexpected '%s' within %s block",
 545                        kconf_id_strings + id->name, zconf_tokenname(starttoken));
 546                zconfnerrs++;
 547                return false;
 548        }
 549        if (current_menu->file != current_file) {
 550                zconf_error("'%s' in different file than '%s'",
 551                        kconf_id_strings + id->name, zconf_tokenname(starttoken));
 552                fprintf(stderr, "%s:%d: location of the '%s'\n",
 553                        current_menu->file->name, current_menu->lineno,
 554                        zconf_tokenname(starttoken));
 555                zconfnerrs++;
 556                return false;
 557        }
 558        return true;
 559}
 560
 561static void zconfprint(const char *err, ...)
 562{
 563        va_list ap;
 564
 565        fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
 566        va_start(ap, err);
 567        vfprintf(stderr, err, ap);
 568        va_end(ap);
 569        fprintf(stderr, "\n");
 570}
 571
 572static void zconf_error(const char *err, ...)
 573{
 574        va_list ap;
 575
 576        zconfnerrs++;
 577        fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno());
 578        va_start(ap, err);
 579        vfprintf(stderr, err, ap);
 580        va_end(ap);
 581        fprintf(stderr, "\n");
 582}
 583
 584static void zconferror(const char *err)
 585{
 586        fprintf(stderr, "%s:%d: %s\n", zconf_curname(), zconf_lineno() + 1, err);
 587}
 588
 589static void print_quoted_string(FILE *out, const char *str)
 590{
 591        const char *p;
 592        int len;
 593
 594        putc('"', out);
 595        while ((p = strchr(str, '"'))) {
 596                len = p - str;
 597                if (len)
 598                        fprintf(out, "%.*s", len, str);
 599                fputs("\\\"", out);
 600                str = p + 1;
 601        }
 602        fputs(str, out);
 603        putc('"', out);
 604}
 605
 606static void print_symbol(FILE *out, struct menu *menu)
 607{
 608        struct symbol *sym = menu->sym;
 609        struct property *prop;
 610
 611        if (sym_is_choice(sym))
 612                fprintf(out, "\nchoice\n");
 613        else
 614                fprintf(out, "\nconfig %s\n", sym->name);
 615        switch (sym->type) {
 616        case S_BOOLEAN:
 617                fputs("  boolean\n", out);
 618                break;
 619        case S_TRISTATE:
 620                fputs("  tristate\n", out);
 621                break;
 622        case S_STRING:
 623                fputs("  string\n", out);
 624                break;
 625        case S_INT:
 626                fputs("  integer\n", out);
 627                break;
 628        case S_HEX:
 629                fputs("  hex\n", out);
 630                break;
 631        default:
 632                fputs("  ???\n", out);
 633                break;
 634        }
 635        for (prop = sym->prop; prop; prop = prop->next) {
 636                if (prop->menu != menu)
 637                        continue;
 638                switch (prop->type) {
 639                case P_PROMPT:
 640                        fputs("  prompt ", out);
 641                        print_quoted_string(out, prop->text);
 642                        if (!expr_is_yes(prop->visible.expr)) {
 643                                fputs(" if ", out);
 644                                expr_fprint(prop->visible.expr, out);
 645                        }
 646                        fputc('\n', out);
 647                        break;
 648                case P_DEFAULT:
 649                        fputs( "  default ", out);
 650                        expr_fprint(prop->expr, out);
 651                        if (!expr_is_yes(prop->visible.expr)) {
 652                                fputs(" if ", out);
 653                                expr_fprint(prop->visible.expr, out);
 654                        }
 655                        fputc('\n', out);
 656                        break;
 657                case P_CHOICE:
 658                        fputs("  #choice value\n", out);
 659                        break;
 660                case P_SELECT:
 661                        fputs( "  select ", out);
 662                        expr_fprint(prop->expr, out);
 663                        fputc('\n', out);
 664                        break;
 665                case P_RANGE:
 666                        fputs( "  range ", out);
 667                        expr_fprint(prop->expr, out);
 668                        fputc('\n', out);
 669                        break;
 670                case P_MENU:
 671                        fputs( "  menu ", out);
 672                        print_quoted_string(out, prop->text);
 673                        fputc('\n', out);
 674                        break;
 675                default:
 676                        fprintf(out, "  unknown prop %d!\n", prop->type);
 677                        break;
 678                }
 679        }
 680        if (menu->help) {
 681                int len = strlen(menu->help);
 682                while (menu->help[--len] == '\n')
 683                        menu->help[len] = 0;
 684                fprintf(out, "  help\n%s\n", menu->help);
 685        }
 686}
 687
 688void zconfdump(FILE *out)
 689{
 690        struct property *prop;
 691        struct symbol *sym;
 692        struct menu *menu;
 693
 694        menu = rootmenu.list;
 695        while (menu) {
 696                if ((sym = menu->sym))
 697                        print_symbol(out, menu);
 698                else if ((prop = menu->prompt)) {
 699                        switch (prop->type) {
 700                        case P_COMMENT:
 701                                fputs("\ncomment ", out);
 702                                print_quoted_string(out, prop->text);
 703                                fputs("\n", out);
 704                                break;
 705                        case P_MENU:
 706                                fputs("\nmenu ", out);
 707                                print_quoted_string(out, prop->text);
 708                                fputs("\n", out);
 709                                break;
 710                        default:
 711                                ;
 712                        }
 713                        if (!expr_is_yes(prop->visible.expr)) {
 714                                fputs("  depends ", out);
 715                                expr_fprint(prop->visible.expr, out);
 716                                fputc('\n', out);
 717                        }
 718                }
 719
 720                if (menu->list)
 721                        menu = menu->list;
 722                else if (menu->next)
 723                        menu = menu->next;
 724                else while ((menu = menu->parent)) {
 725                        if (menu->prompt && menu->prompt->type == P_MENU)
 726                                fputs("\nendmenu\n", out);
 727                        if (menu->next) {
 728                                menu = menu->next;
 729                                break;
 730                        }
 731                }
 732        }
 733}
 734
 735#include "zconf.lex.c"
 736#include "util.c"
 737#include "confdata.c"
 738#include "expr.c"
 739#include "symbol.c"
 740#include "menu.c"
 741
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.