src/xkbcomp/parser.y

   1 /************************************************************
   2  Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3
   4  Permission to use, copy, modify, and distribute this
   5  software and its documentation for any purpose and without
   6  fee is hereby granted, provided that the above copyright
   7  notice appear in all copies and that both that copyright
   8  notice and this permission notice appear in supporting
   9  documentation, and that the name of Silicon Graphics not be
  10  used in advertising or publicity pertaining to distribution
  11  of the software without specific prior written permission.
  12  Silicon Graphics makes no representation about the suitability
  13  of this software for any purpose. It is provided "as is"
  14  without any express or implied warranty.
  15
  16  SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24
  25  ********************************************************/
  26
  27 %{
  28 #include "xkbcomp-priv.h"
  29 #include "ast-build.h"
  30 #include "parser-priv.h"
  31
  32 static void
  33 _xkbcommon_error(struct YYLTYPE *loc, struct parser_param *param, const char *msg)
  34 {
  35     scanner_error(loc, param->scanner, msg);
  36 }
  37
  38 #define scanner param->scanner
  39 %}
  40
  41 %name-prefix    "_xkbcommon_"
  42 %define         api.pure
  43 %locations
  44 %lex-param      { void *scanner }
  45 %parse-param    { struct parser_param *param }
  46
  47 %token
  48         END_OF_FILE     0
  49         ERROR_TOK       255
  50         XKB_KEYMAP      1
  51         XKB_KEYCODES    2
  52         XKB_TYPES       3
  53         XKB_SYMBOLS     4
  54         XKB_COMPATMAP   5
  55         XKB_GEOMETRY    6
  56         XKB_SEMANTICS   7
  57         XKB_LAYOUT      8
  58         INCLUDE         10
  59         OVERRIDE        11
  60         AUGMENT         12
  61         REPLACE         13
  62         ALTERNATE       14
  63         VIRTUAL_MODS    20
  64         TYPE            21
  65         INTERPRET       22
  66         ACTION_TOK      23
  67         KEY             24
  68         ALIAS           25
  69         GROUP           26
  70         MODIFIER_MAP    27
  71         INDICATOR       28
  72         SHAPE           29
  73         KEYS            30
  74         ROW             31
  75         SECTION         32
  76         OVERLAY         33
  77         TEXT            34
  78         OUTLINE         35
  79         SOLID           36
  80         LOGO            37
  81         VIRTUAL         38
  82         EQUALS          40
  83         PLUS            41
  84         MINUS           42
  85         DIVIDE          43
  86         TIMES           44
  87         OBRACE          45
  88         CBRACE          46
  89         OPAREN          47
  90         CPAREN          48
  91         OBRACKET        49
  92         CBRACKET        50
  93         DOT             51
  94         COMMA           52
  95         SEMI            53
  96         EXCLAM          54
  97         INVERT          55
  98         STRING          60
  99         INTEGER         61
 100         FLOAT           62
 101         IDENT           63
 102         KEYNAME         64
 103         PARTIAL         70
 104         DEFAULT         71
 105         HIDDEN          72
 106         ALPHANUMERIC_KEYS       73
 107         MODIFIER_KEYS           74
 108         KEYPAD_KEYS             75
 109         FUNCTION_KEYS           76
 110         ALTERNATE_GROUP         77
 111
 112 %right  EQUALS
 113 %left   PLUS MINUS
 114 %left   TIMES DIVIDE
 115 %left   EXCLAM INVERT
 116 %left   OPAREN
 117
 118 %start  XkbFile
 119
 120 %union  {
 121         int              ival;
 122         unsigned         uval;
 123         int64_t          num;
 124         enum xkb_file_type file_type;
 125         char            *str;
 126         xkb_atom_t      sval;
 127         enum merge_mode merge;
 128         enum xkb_map_flags mapFlags;
 129         ParseCommon     *any;
 130         ExprDef         *expr;
 131         VarDef          *var;
 132         VModDef         *vmod;
 133         InterpDef       *interp;
 134         KeyTypeDef      *keyType;
 135         SymbolsDef      *syms;
 136         ModMapDef       *modMask;
 137         GroupCompatDef  *groupCompat;
 138         IndicatorMapDef *ledMap;
 139         IndicatorNameDef *ledName;
 140         KeycodeDef      *keyCode;
 141         KeyAliasDef     *keyAlias;
 142         void            *geom;
 143         XkbFile         *file;
 144 }
 145
 146 %type <num>     INTEGER FLOAT
 147 %type <str>     IDENT STRING
 148 %type <sval>    KEYNAME
 149 %type <num>     KeyCode
 150 %type <ival>    Number Integer Float SignedNumber
 151 %type <merge>   MergeMode OptMergeMode
 152 %type <file_type> XkbCompositeType FileType
 153 %type <uval>    DoodadType
 154 %type <mapFlags> Flag Flags OptFlags
 155 %type <str>     MapName OptMapName KeySym
 156 %type <sval>    FieldSpec Ident Element String
 157 %type <any>     DeclList Decl
 158 %type <expr>    OptExprList ExprList Expr Term Lhs Terminal ArrayInit KeySyms
 159 %type <expr>    OptKeySymList KeySymList Action ActionList Coord CoordList
 160 %type <var>     VarDecl VarDeclList SymbolsBody SymbolsVarDecl
 161 %type <vmod>    VModDecl VModDefList VModDef
 162 %type <interp>  InterpretDecl InterpretMatch
 163 %type <keyType> KeyTypeDecl
 164 %type <syms>    SymbolsDecl
 165 %type <modMask> ModMapDecl
 166 %type <groupCompat> GroupCompatDecl
 167 %type <ledMap>  IndicatorMapDecl
 168 %type <ledName> IndicatorNameDecl
 169 %type <keyCode> KeyNameDecl
 170 %type <keyAlias> KeyAliasDecl
 171 %type <geom>    ShapeDecl SectionDecl SectionBody SectionBodyItem RowBody RowBodyItem
 172 %type <geom>    Keys Key OverlayDecl OverlayKeyList OverlayKey OutlineList OutlineInList
 173 %type <geom>    DoodadDecl
 174 %type <file>    XkbFile XkbMapConfigList XkbMapConfig
 175 %type <file>    XkbCompositeMap XkbCompMapList
 176
 177 %%
 178
 179 XkbFile         :       XkbCompMapList
 180                         { $$ = param->rtrn = $1; }
 181                 |       XkbMapConfigList
 182                         { $$ = param->rtrn = $1; }
 183                 ;
 184
 185 XkbCompMapList  :       XkbCompMapList XkbCompositeMap
 186                         { $$ = (XkbFile *)AppendStmt(&$1->common, &$2->common); }
 187                 |       XkbCompositeMap
 188                         { $$ = $1; }
 189                 ;
 190
 191 XkbCompositeMap :       OptFlags XkbCompositeType OptMapName OBRACE
 192                             XkbMapConfigList
 193                         CBRACE SEMI
 194                         { $$ = XkbFileCreate(param->ctx, $2, $3, &$5->common, $1); }
 195                 ;
 196
 197 XkbCompositeType:       XKB_KEYMAP      { $$ = FILE_TYPE_KEYMAP; }
 198                 |       XKB_SEMANTICS   { $$ = FILE_TYPE_KEYMAP; }
 199                 |       XKB_LAYOUT      { $$ = FILE_TYPE_KEYMAP; }
 200                 ;
 201
 202 XkbMapConfigList :      XkbMapConfigList XkbMapConfig
 203                         {
 204                             if (!$2)
 205                                 $$ = $1;
 206                             else
 207                                 $$ = (XkbFile *)AppendStmt(&$1->common, &$2->common);
 208                         }
 209                 |       XkbMapConfig
 210                         { $$ = $1; }
 211                 ;
 212
 213 XkbMapConfig    :       OptFlags FileType OptMapName OBRACE
 214                             DeclList
 215                         CBRACE SEMI
 216                         {
 217                             if ($2 == FILE_TYPE_GEOMETRY) {
 218                                 free($3);
 219                                 FreeStmt($5);
 220                                 $$ = NULL;
 221                             }
 222                             else {
 223                                 $$ = XkbFileCreate(param->ctx, $2, $3, $5, $1);
 224                             }
 225                         }
 226                 ;
 227
 228 FileType        :       XKB_KEYCODES            { $$ = FILE_TYPE_KEYCODES; }
 229                 |       XKB_TYPES               { $$ = FILE_TYPE_TYPES; }
 230                 |       XKB_COMPATMAP           { $$ = FILE_TYPE_COMPAT; }
 231                 |       XKB_SYMBOLS             { $$ = FILE_TYPE_SYMBOLS; }
 232                 |       XKB_GEOMETRY            { $$ = FILE_TYPE_GEOMETRY; }
 233                 ;
 234
 235 OptFlags        :       Flags                   { $$ = $1; }
 236                 |                               { $$ = 0; }
 237                 ;
 238
 239 Flags           :       Flags Flag              { $$ = ($1 | $2); }
 240                 |       Flag                    { $$ = $1; }
 241                 ;
 242
 243 Flag            :       PARTIAL                 { $$ = MAP_IS_PARTIAL; }
 244                 |       DEFAULT                 { $$ = MAP_IS_DEFAULT; }
 245                 |       HIDDEN                  { $$ = MAP_IS_HIDDEN; }
 246                 |       ALPHANUMERIC_KEYS       { $$ = MAP_HAS_ALPHANUMERIC; }
 247                 |       MODIFIER_KEYS           { $$ = MAP_HAS_MODIFIER; }
 248                 |       KEYPAD_KEYS             { $$ = MAP_HAS_KEYPAD; }
 249                 |       FUNCTION_KEYS           { $$ = MAP_HAS_FN; }
 250                 |       ALTERNATE_GROUP         { $$ = MAP_IS_ALTGR; }
 251                 ;
 252
 253 DeclList        :       DeclList Decl
 254                         { $$ = AppendStmt($1, $2); }
 255                 |       { $$ = NULL; }
 256                 ;
 257
 258 Decl            :       OptMergeMode VarDecl
 259                         {
 260                             $2->merge = $1;
 261                             $$ = &$2->common;
 262                         }
 263                 |       OptMergeMode VModDecl
 264                         {
 265                             $2->merge = $1;
 266                             $$ = &$2->common;
 267                         }
 268                 |       OptMergeMode InterpretDecl
 269                         {
 270                             $2->merge = $1;
 271                             $$ = &$2->common;
 272                         }
 273                 |       OptMergeMode KeyNameDecl
 274                         {
 275                             $2->merge = $1;
 276                             $$ = &$2->common;
 277                         }
 278                 |       OptMergeMode KeyAliasDecl
 279                         {
 280                             $2->merge = $1;
 281                             $$ = &$2->common;
 282                         }
 283                 |       OptMergeMode KeyTypeDecl
 284                         {
 285                             $2->merge = $1;
 286                             $$ = &$2->common;
 287                         }
 288                 |       OptMergeMode SymbolsDecl
 289                         {
 290                             $2->merge = $1;
 291                             $$ = &$2->common;
 292                         }
 293                 |       OptMergeMode ModMapDecl
 294                         {
 295                             $2->merge = $1;
 296                             $$ = &$2->common;
 297                         }
 298                 |       OptMergeMode GroupCompatDecl
 299                         {
 300                             $2->merge = $1;
 301                             $$ = &$2->common;
 302                         }
 303                 |       OptMergeMode IndicatorMapDecl
 304                         {
 305                             $2->merge = $1;
 306                             $$ = &$2->common;
 307                         }
 308                 |       OptMergeMode IndicatorNameDecl
 309                         {
 310                             $2->merge = $1;
 311                             $$ = &$2->common;
 312                         }
 313                 |       OptMergeMode ShapeDecl          { }
 314                 |       OptMergeMode SectionDecl        { }
 315                 |       OptMergeMode DoodadDecl         { }
 316                 |       MergeMode STRING
 317                         {
 318                             $$ = &IncludeCreate(param->ctx, $2, $1)->common;
 319                             free($2);
 320                         }
 321                 ;
 322
 323 VarDecl         :       Lhs EQUALS Expr SEMI
 324                         { $$ = VarCreate($1, $3); }
 325                 |       Ident SEMI
 326                         { $$ = BoolVarCreate($1, 1); }
 327                 |       EXCLAM Ident SEMI
 328                         { $$ = BoolVarCreate($2, 0); }
 329                 ;
 330
 331 KeyNameDecl     :       KEYNAME EQUALS KeyCode SEMI
 332                         { $$ = KeycodeCreate($1, $3); }
 333                 ;
 334
 335 KeyAliasDecl    :       ALIAS KEYNAME EQUALS KEYNAME SEMI
 336                         { $$ = KeyAliasCreate($2, $4); }
 337                 ;
 338
 339 VModDecl        :       VIRTUAL_MODS VModDefList SEMI
 340                         { $$ = $2; }
 341                 ;
 342
 343 VModDefList     :       VModDefList COMMA VModDef
 344                         { $$ = (VModDef *)AppendStmt(&$1->common, &$3->common); }
 345                 |       VModDef
 346                         { $$ = $1; }
 347                 ;
 348
 349 VModDef         :       Ident
 350                         { $$ = VModCreate($1, NULL); }
 351                 |       Ident EQUALS Expr
 352                         { $$ = VModCreate($1, $3); }
 353                 ;
 354
 355 InterpretDecl   :       INTERPRET InterpretMatch OBRACE
 356                             VarDeclList
 357                         CBRACE SEMI
 358                         { $2->def = $4; $$ = $2; }
 359                 ;
 360
 361 InterpretMatch  :       KeySym PLUS Expr
 362                         { $$ = InterpCreate($1, $3); }
 363                 |       KeySym
 364                         { $$ = InterpCreate($1, NULL); }
 365                 ;
 366
 367 VarDeclList     :       VarDeclList VarDecl
 368                         { $$ = (VarDef *)AppendStmt(&$1->common, &$2->common); }
 369                 |       VarDecl
 370                         { $$ = $1; }
 371                 ;
 372
 373 KeyTypeDecl     :       TYPE String OBRACE
 374                             VarDeclList
 375                         CBRACE SEMI
 376                         { $$ = KeyTypeCreate($2, $4); }
 377                 ;
 378
 379 SymbolsDecl     :       KEY KEYNAME OBRACE
 380                             SymbolsBody
 381                         CBRACE SEMI
 382                         { $$ = SymbolsCreate($2, (ExprDef *)$4); }
 383                 ;
 384
 385 SymbolsBody     :       SymbolsBody COMMA SymbolsVarDecl
 386                         { $$ = (VarDef *)AppendStmt(&$1->common, &$3->common); }
 387                 |       SymbolsVarDecl
 388                         { $$ = $1; }
 389                 |       { $$ = NULL; }
 390                 ;
 391
 392 SymbolsVarDecl  :       Lhs EQUALS Expr         { $$ = VarCreate($1, $3); }
 393                 |       Lhs EQUALS ArrayInit    { $$ = VarCreate($1, $3); }
 394                 |       Ident                   { $$ = BoolVarCreate($1, 1); }
 395                 |       EXCLAM Ident            { $$ = BoolVarCreate($2, 0); }
 396                 |       ArrayInit               { $$ = VarCreate(NULL, $1); }
 397                 ;
 398
 399 ArrayInit       :       OBRACKET OptKeySymList CBRACKET
 400                         { $$ = $2; }
 401                 |       OBRACKET ActionList CBRACKET
 402                         { $$ = ExprCreateUnary(EXPR_ACTION_LIST, EXPR_TYPE_ACTION, $2); }
 403                 ;
 404
 405 GroupCompatDecl :       GROUP Integer EQUALS Expr SEMI
 406                         { $$ = GroupCompatCreate($2, $4); }
 407                 ;
 408
 409 ModMapDecl      :       MODIFIER_MAP Ident OBRACE ExprList CBRACE SEMI
 410                         { $$ = ModMapCreate($2, $4); }
 411                 ;
 412
 413 IndicatorMapDecl:       INDICATOR String OBRACE VarDeclList CBRACE SEMI
 414                         { $$ = IndicatorMapCreate($2, $4); }
 415                 ;
 416
 417 IndicatorNameDecl:      INDICATOR Integer EQUALS Expr SEMI
 418                         { $$ = IndicatorNameCreate($2, $4, false); }
 419                 |       VIRTUAL INDICATOR Integer EQUALS Expr SEMI
 420                         { $$ = IndicatorNameCreate($3, $5, true); }
 421                 ;
 422
 423 ShapeDecl       :       SHAPE String OBRACE OutlineList CBRACE SEMI
 424                         { $$ = NULL; }
 425                 |       SHAPE String OBRACE CoordList CBRACE SEMI
 426                         { $$ = NULL; }
 427                 ;
 428
 429 SectionDecl     :       SECTION String OBRACE SectionBody CBRACE SEMI
 430                         { $$ = NULL; }
 431                 ;
 432
 433 SectionBody     :       SectionBody SectionBodyItem     { $$ = NULL;}
 434                 |       SectionBodyItem                 { $$ = NULL; }
 435                 ;
 436
 437 SectionBodyItem :       ROW OBRACE RowBody CBRACE SEMI
 438                         { $$ = NULL; }
 439                 |       VarDecl
 440                         { FreeStmt(&$1->common); $$ = NULL; }
 441                 |       DoodadDecl
 442                         { $$ = NULL; }
 443                 |       IndicatorMapDecl
 444                         { FreeStmt(&$1->common); $$ = NULL; }
 445                 |       OverlayDecl
 446                         { $$ = NULL; }
 447                 ;
 448
 449 RowBody         :       RowBody RowBodyItem     { $$ = NULL;}
 450                 |       RowBodyItem             { $$ = NULL; }
 451                 ;
 452
 453 RowBodyItem     :       KEYS OBRACE Keys CBRACE SEMI { $$ = NULL; }
 454                 |       VarDecl
 455                         { FreeStmt(&$1->common); $$ = NULL; }
 456                 ;
 457
 458 Keys            :       Keys COMMA Key          { $$ = NULL; }
 459                 |       Key                     { $$ = NULL; }
 460                 ;
 461
 462 Key             :       KEYNAME
 463                         { $$ = NULL; }
 464                 |       OBRACE ExprList CBRACE
 465                         { FreeStmt(&$2->common); $$ = NULL; }
 466                 ;
 467
 468 OverlayDecl     :       OVERLAY String OBRACE OverlayKeyList CBRACE SEMI
 469                         { $$ = NULL; }
 470                 ;
 471
 472 OverlayKeyList  :       OverlayKeyList COMMA OverlayKey { $$ = NULL; }
 473                 |       OverlayKey                      { $$ = NULL; }
 474                 ;
 475
 476 OverlayKey      :       KEYNAME EQUALS KEYNAME          { $$ = NULL; }
 477                 ;
 478
 479 OutlineList     :       OutlineList COMMA OutlineInList
 480                         { $$ = NULL;}
 481                 |       OutlineInList
 482                         { $$ = NULL; }
 483                 ;
 484
 485 OutlineInList   :       OBRACE CoordList CBRACE
 486                         { $$ = NULL; }
 487                 |       Ident EQUALS OBRACE CoordList CBRACE
 488                         { $$ = NULL; }
 489                 |       Ident EQUALS Expr
 490                         { FreeStmt(&$3->common); $$ = NULL; }
 491                 ;
 492
 493 CoordList       :       CoordList COMMA Coord
 494                         { $$ = NULL; }
 495                 |       Coord
 496                         { $$ = NULL; }
 497                 ;
 498
 499 Coord           :       OBRACKET SignedNumber COMMA SignedNumber CBRACKET
 500                         { $$ = NULL; }
 501                 ;
 502
 503 DoodadDecl      :       DoodadType String OBRACE VarDeclList CBRACE SEMI
 504                         { FreeStmt(&$4->common); $$ = NULL; }
 505                 ;
 506
 507 DoodadType      :       TEXT    { $$ = 0; }
 508                 |       OUTLINE { $$ = 0; }
 509                 |       SOLID   { $$ = 0; }
 510                 |       LOGO    { $$ = 0; }
 511                 ;
 512
 513 FieldSpec       :       Ident   { $$ = $1; }
 514                 |       Element { $$ = $1; }
 515                 ;
 516
 517 Element         :       ACTION_TOK
 518                         { $$ = xkb_atom_intern(param->ctx, "action"); }
 519                 |       INTERPRET
 520                         { $$ = xkb_atom_intern(param->ctx, "interpret"); }
 521                 |       TYPE
 522                         { $$ = xkb_atom_intern(param->ctx, "type"); }
 523                 |       KEY
 524                         { $$ = xkb_atom_intern(param->ctx, "key"); }
 525                 |       GROUP
 526                         { $$ = xkb_atom_intern(param->ctx, "group"); }
 527                 |       MODIFIER_MAP
 528                         {$$ = xkb_atom_intern(param->ctx, "modifier_map");}
 529                 |       INDICATOR
 530                         { $$ = xkb_atom_intern(param->ctx, "indicator"); }
 531                 |       SHAPE
 532                         { $$ = xkb_atom_intern(param->ctx, "shape"); }
 533                 |       ROW
 534                         { $$ = XKB_ATOM_NONE; }
 535                 |       SECTION
 536                         { $$ = XKB_ATOM_NONE; }
 537                 |       TEXT
 538                         { $$ = XKB_ATOM_NONE; }
 539                 ;
 540
 541 OptMergeMode    :       MergeMode       { $$ = $1; }
 542                 |                       { $$ = MERGE_DEFAULT; }
 543                 ;
 544
 545 MergeMode       :       INCLUDE         { $$ = MERGE_DEFAULT; }
 546                 |       AUGMENT         { $$ = MERGE_AUGMENT; }
 547                 |       OVERRIDE        { $$ = MERGE_OVERRIDE; }
 548                 |       REPLACE         { $$ = MERGE_REPLACE; }
 549                 |       ALTERNATE
 550                 {
 551                     /*
 552                      * This used to be MERGE_ALT_FORM. This functionality was
 553                      * unused and has been removed.
 554                      */
 555                     $$ = MERGE_DEFAULT;
 556                 }
 557                 ;
 558
 559 OptExprList     :       ExprList        { $$ = $1; }
 560                 |                       { $$ = NULL; }
 561                 ;
 562
 563 ExprList        :       ExprList COMMA Expr
 564                         { $$ = (ExprDef *)AppendStmt(&$1->common, &$3->common); }
 565                 |       Expr
 566                         { $$ = $1; }
 567                 ;
 568
 569 Expr            :       Expr DIVIDE Expr
 570                         { $$ = ExprCreateBinary(EXPR_DIVIDE, $1, $3); }
 571                 |       Expr PLUS Expr
 572                         { $$ = ExprCreateBinary(EXPR_ADD, $1, $3); }
 573                 |       Expr MINUS Expr
 574                         { $$ = ExprCreateBinary(EXPR_SUBTRACT, $1, $3); }
 575                 |       Expr TIMES Expr
 576                         { $$ = ExprCreateBinary(EXPR_MULTIPLY, $1, $3); }
 577                 |       Lhs EQUALS Expr
 578                         { $$ = ExprCreateBinary(EXPR_ASSIGN, $1, $3); }
 579                 |       Term
 580                         { $$ = $1; }
 581                 ;
 582
 583 Term            :       MINUS Term
 584                         { $$ = ExprCreateUnary(EXPR_NEGATE, $2->value_type, $2); }
 585                 |       PLUS Term
 586                         { $$ = ExprCreateUnary(EXPR_UNARY_PLUS, $2->value_type, $2); }
 587                 |       EXCLAM Term
 588                         { $$ = ExprCreateUnary(EXPR_NOT, EXPR_TYPE_BOOLEAN, $2); }
 589                 |       INVERT Term
 590                         { $$ = ExprCreateUnary(EXPR_INVERT, $2->value_type, $2); }
 591                 |       Lhs
 592                         { $$ = $1;  }
 593                 |       FieldSpec OPAREN OptExprList CPAREN %prec OPAREN
 594                         { $$ = ActionCreate($1, $3); }
 595                 |       Terminal
 596                         { $$ = $1;  }
 597                 |       OPAREN Expr CPAREN
 598                         { $$ = $2;  }
 599                 ;
 600
 601 ActionList      :       ActionList COMMA Action
 602                         { $$ = (ExprDef *)AppendStmt(&$1->common, &$3->common); }
 603                 |       Action
 604                         { $$ = $1; }
 605                 ;
 606
 607 Action          :       FieldSpec OPAREN OptExprList CPAREN
 608                         { $$ = ActionCreate($1, $3); }
 609                 ;
 610
 611 Lhs             :       FieldSpec
 612                         {
 613                             ExprDef *expr;
 614                             expr = ExprCreate(EXPR_IDENT, EXPR_TYPE_UNKNOWN);
 615                             expr->value.str = $1;
 616                             $$ = expr;
 617                         }
 618                 |       FieldSpec DOT FieldSpec
 619                         {
 620                             ExprDef *expr;
 621                             expr = ExprCreate(EXPR_FIELD_REF, EXPR_TYPE_UNKNOWN);
 622                             expr->value.field.element = $1;
 623                             expr->value.field.field = $3;
 624                             $$ = expr;
 625                         }
 626                 |       FieldSpec OBRACKET Expr CBRACKET
 627                         {
 628                             ExprDef *expr;
 629                             expr = ExprCreate(EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
 630                             expr->value.array.element = XKB_ATOM_NONE;
 631                             expr->value.array.field = $1;
 632                             expr->value.array.entry = $3;
 633                             $$ = expr;
 634                         }
 635                 |       FieldSpec DOT FieldSpec OBRACKET Expr CBRACKET
 636                         {
 637                             ExprDef *expr;
 638                             expr = ExprCreate(EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
 639                             expr->value.array.element = $1;
 640                             expr->value.array.field = $3;
 641                             expr->value.array.entry = $5;
 642                             $$ = expr;
 643                         }
 644                 ;
 645
 646 Terminal        :       String
 647                         {
 648                             ExprDef *expr;
 649                             expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_STRING);
 650                             expr->value.str = $1;
 651                             $$ = expr;
 652                         }
 653                 |       Integer
 654                         {
 655                             ExprDef *expr;
 656                             expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_INT);
 657                             expr->value.ival = $1;
 658                             $$ = expr;
 659                         }
 660                 |       Float
 661                         {
 662                             $$ = NULL;
 663                         }
 664                 |       KEYNAME
 665                         {
 666                             ExprDef *expr;
 667                             expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_KEYNAME);
 668                             expr->value.keyName = $1;
 669                             $$ = expr;
 670                         }
 671                 ;
 672
 673 OptKeySymList   :       KeySymList      { $$ = $1; }
 674                 |                       { $$ = NULL; }
 675                 ;
 676
 677 KeySymList      :       KeySymList COMMA KeySym
 678                         { $$ = AppendKeysymList($1, $3); }
 679                 |       KeySymList COMMA KeySyms
 680                         { $$ = AppendMultiKeysymList($1, $3); }
 681                 |       KeySym
 682                         { $$ = CreateKeysymList($1); }
 683                 |       KeySyms
 684                         { $$ = CreateMultiKeysymList($1); }
 685                 ;
 686
 687 KeySyms         :       OBRACE KeySymList CBRACE
 688                         { $$ = $2; }
 689                 ;
 690
 691 KeySym          :       IDENT   { $$ = $1; }
 692                 |       SECTION { $$ = strdup("section"); }
 693                 |       Integer
 694                         {
 695                             if ($1 < 10) {      /* XK_0 .. XK_9 */
 696                                 $$ = malloc(2);
 697                                 $$[0] = $1 + '0';
 698                                 $$[1] = '\0';
 699                             }
 700                             else {
 701                                 $$ = malloc(17);
 702                                 snprintf($$, 17, "0x%x", $1);
 703                             }
 704                         }
 705                 ;
 706
 707 SignedNumber    :       MINUS Number    { $$ = -$2; }
 708                 |       Number          { $$ = $1; }
 709                 ;
 710
 711 Number          :       FLOAT   { $$ = $1; }
 712                 |       INTEGER { $$ = $1; }
 713                 ;
 714
 715 Float           :       FLOAT   { $$ = 0; }
 716                 ;
 717
 718 Integer         :       INTEGER { $$ = $1; }
 719                 ;
 720
 721 KeyCode         :       INTEGER { $$ = $1; }
 722                 ;
 723
 724 Ident           :       IDENT   { $$ = xkb_atom_steal(param->ctx, $1); }
 725                 |       DEFAULT { $$ = xkb_atom_intern(param->ctx, "default"); }
 726                 ;
 727
 728 String          :       STRING  { $$ = xkb_atom_steal(param->ctx, $1); }
 729                 ;
 730
 731 OptMapName      :       MapName { $$ = $1; }
 732                 |               { $$ = NULL; }
 733                 ;
 734
 735 MapName         :       STRING  { $$ = $1; }
 736                 ;
 737
 738 %%
 739
 740 #undef scanner