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
 176
 177 %%
 178
 179 XkbFile         :       XkbCompositeMap
 180                         { $$ = param->rtrn = $1; }
 181                 |       XkbMapConfigList
 182                         { $$ = param->rtrn = $1; }
 183                 ;
 184
 185 XkbCompositeMap :       OptFlags XkbCompositeType OptMapName OBRACE
 186                             XkbMapConfigList
 187                         CBRACE SEMI
 188                         { $$ = XkbFileCreate(param->ctx, $2, $3, &$5->common, $1); }
 189                 ;
 190
 191 XkbCompositeType:       XKB_KEYMAP      { $$ = FILE_TYPE_KEYMAP; }
 192                 |       XKB_SEMANTICS   { $$ = FILE_TYPE_KEYMAP; }
 193                 |       XKB_LAYOUT      { $$ = FILE_TYPE_KEYMAP; }
 194                 ;
 195
 196 XkbMapConfigList :      XkbMapConfigList XkbMapConfig
 197                         {
 198                             if (!$2)
 199                                 $$ = $1;
 200                             else
 201                                 $$ = (XkbFile *)AppendStmt(&$1->common, &$2->common);
 202                         }
 203                 |       XkbMapConfig
 204                         { $$ = $1; }
 205                 ;
 206
 207 XkbMapConfig    :       OptFlags FileType OptMapName OBRACE
 208                             DeclList
 209                         CBRACE SEMI
 210                         {
 211                             if ($2 == FILE_TYPE_GEOMETRY) {
 212                                 free($3);
 213                                 FreeStmt($5);
 214                                 $$ = NULL;
 215                             }
 216                             else {
 217                                 $$ = XkbFileCreate(param->ctx, $2, $3, $5, $1);
 218                             }
 219                         }
 220                 ;
 221
 222 FileType        :       XKB_KEYCODES            { $$ = FILE_TYPE_KEYCODES; }
 223                 |       XKB_TYPES               { $$ = FILE_TYPE_TYPES; }
 224                 |       XKB_COMPATMAP           { $$ = FILE_TYPE_COMPAT; }
 225                 |       XKB_SYMBOLS             { $$ = FILE_TYPE_SYMBOLS; }
 226                 |       XKB_GEOMETRY            { $$ = FILE_TYPE_GEOMETRY; }
 227                 ;
 228
 229 OptFlags        :       Flags                   { $$ = $1; }
 230                 |                               { $$ = 0; }
 231                 ;
 232
 233 Flags           :       Flags Flag              { $$ = ($1 | $2); }
 234                 |       Flag                    { $$ = $1; }
 235                 ;
 236
 237 Flag            :       PARTIAL                 { $$ = MAP_IS_PARTIAL; }
 238                 |       DEFAULT                 { $$ = MAP_IS_DEFAULT; }
 239                 |       HIDDEN                  { $$ = MAP_IS_HIDDEN; }
 240                 |       ALPHANUMERIC_KEYS       { $$ = MAP_HAS_ALPHANUMERIC; }
 241                 |       MODIFIER_KEYS           { $$ = MAP_HAS_MODIFIER; }
 242                 |       KEYPAD_KEYS             { $$ = MAP_HAS_KEYPAD; }
 243                 |       FUNCTION_KEYS           { $$ = MAP_HAS_FN; }
 244                 |       ALTERNATE_GROUP         { $$ = MAP_IS_ALTGR; }
 245                 ;
 246
 247 DeclList        :       DeclList Decl
 248                         { $$ = AppendStmt($1, $2); }
 249                 |       { $$ = NULL; }
 250                 ;
 251
 252 Decl            :       OptMergeMode VarDecl
 253                         {
 254                             $2->merge = $1;
 255                             $$ = &$2->common;
 256                         }
 257                 |       OptMergeMode VModDecl
 258                         {
 259                             $2->merge = $1;
 260                             $$ = &$2->common;
 261                         }
 262                 |       OptMergeMode InterpretDecl
 263                         {
 264                             $2->merge = $1;
 265                             $$ = &$2->common;
 266                         }
 267                 |       OptMergeMode KeyNameDecl
 268                         {
 269                             $2->merge = $1;
 270                             $$ = &$2->common;
 271                         }
 272                 |       OptMergeMode KeyAliasDecl
 273                         {
 274                             $2->merge = $1;
 275                             $$ = &$2->common;
 276                         }
 277                 |       OptMergeMode KeyTypeDecl
 278                         {
 279                             $2->merge = $1;
 280                             $$ = &$2->common;
 281                         }
 282                 |       OptMergeMode SymbolsDecl
 283                         {
 284                             $2->merge = $1;
 285                             $$ = &$2->common;
 286                         }
 287                 |       OptMergeMode ModMapDecl
 288                         {
 289                             $2->merge = $1;
 290                             $$ = &$2->common;
 291                         }
 292                 |       OptMergeMode GroupCompatDecl
 293                         {
 294                             $2->merge = $1;
 295                             $$ = &$2->common;
 296                         }
 297                 |       OptMergeMode IndicatorMapDecl
 298                         {
 299                             $2->merge = $1;
 300                             $$ = &$2->common;
 301                         }
 302                 |       OptMergeMode IndicatorNameDecl
 303                         {
 304                             $2->merge = $1;
 305                             $$ = &$2->common;
 306                         }
 307                 |       OptMergeMode ShapeDecl          { }
 308                 |       OptMergeMode SectionDecl        { }
 309                 |       OptMergeMode DoodadDecl         { }
 310                 |       MergeMode STRING
 311                         {
 312                             $$ = &IncludeCreate(param->ctx, $2, $1)->common;
 313                             free($2);
 314                         }
 315                 ;
 316
 317 VarDecl         :       Lhs EQUALS Expr SEMI
 318                         { $$ = VarCreate($1, $3); }
 319                 |       Ident SEMI
 320                         { $$ = BoolVarCreate($1, 1); }
 321                 |       EXCLAM Ident SEMI
 322                         { $$ = BoolVarCreate($2, 0); }
 323                 ;
 324
 325 KeyNameDecl     :       KEYNAME EQUALS KeyCode SEMI
 326                         { $$ = KeycodeCreate($1, $3); }
 327                 ;
 328
 329 KeyAliasDecl    :       ALIAS KEYNAME EQUALS KEYNAME SEMI
 330                         { $$ = KeyAliasCreate($2, $4); }
 331                 ;
 332
 333 VModDecl        :       VIRTUAL_MODS VModDefList SEMI
 334                         { $$ = $2; }
 335                 ;
 336
 337 VModDefList     :       VModDefList COMMA VModDef
 338                         { $$ = (VModDef *)AppendStmt(&$1->common, &$3->common); }
 339                 |       VModDef
 340                         { $$ = $1; }
 341                 ;
 342
 343 VModDef         :       Ident
 344                         { $$ = VModCreate($1, NULL); }
 345                 |       Ident EQUALS Expr
 346                         { $$ = VModCreate($1, $3); }
 347                 ;
 348
 349 InterpretDecl   :       INTERPRET InterpretMatch OBRACE
 350                             VarDeclList
 351                         CBRACE SEMI
 352                         { $2->def = $4; $$ = $2; }
 353                 ;
 354
 355 InterpretMatch  :       KeySym PLUS Expr
 356                         { $$ = InterpCreate($1, $3); }
 357                 |       KeySym
 358                         { $$ = InterpCreate($1, NULL); }
 359                 ;
 360
 361 VarDeclList     :       VarDeclList VarDecl
 362                         { $$ = (VarDef *)AppendStmt(&$1->common, &$2->common); }
 363                 |       VarDecl
 364                         { $$ = $1; }
 365                 ;
 366
 367 KeyTypeDecl     :       TYPE String OBRACE
 368                             VarDeclList
 369                         CBRACE SEMI
 370                         { $$ = KeyTypeCreate($2, $4); }
 371                 ;
 372
 373 SymbolsDecl     :       KEY KEYNAME OBRACE
 374                             SymbolsBody
 375                         CBRACE SEMI
 376                         { $$ = SymbolsCreate($2, (ExprDef *)$4); }
 377                 ;
 378
 379 SymbolsBody     :       SymbolsBody COMMA SymbolsVarDecl
 380                         { $$ = (VarDef *)AppendStmt(&$1->common, &$3->common); }
 381                 |       SymbolsVarDecl
 382                         { $$ = $1; }
 383                 |       { $$ = NULL; }
 384                 ;
 385
 386 SymbolsVarDecl  :       Lhs EQUALS Expr         { $$ = VarCreate($1, $3); }
 387                 |       Lhs EQUALS ArrayInit    { $$ = VarCreate($1, $3); }
 388                 |       Ident                   { $$ = BoolVarCreate($1, 1); }
 389                 |       EXCLAM Ident            { $$ = BoolVarCreate($2, 0); }
 390                 |       ArrayInit               { $$ = VarCreate(NULL, $1); }
 391                 ;
 392
 393 ArrayInit       :       OBRACKET OptKeySymList CBRACKET
 394                         { $$ = $2; }
 395                 |       OBRACKET ActionList CBRACKET
 396                         { $$ = ExprCreateUnary(EXPR_ACTION_LIST, EXPR_TYPE_ACTION, $2); }
 397                 ;
 398
 399 GroupCompatDecl :       GROUP Integer EQUALS Expr SEMI
 400                         { $$ = GroupCompatCreate($2, $4); }
 401                 ;
 402
 403 ModMapDecl      :       MODIFIER_MAP Ident OBRACE ExprList CBRACE SEMI
 404                         { $$ = ModMapCreate($2, $4); }
 405                 ;
 406
 407 IndicatorMapDecl:       INDICATOR String OBRACE VarDeclList CBRACE SEMI
 408                         { $$ = IndicatorMapCreate($2, $4); }
 409                 ;
 410
 411 IndicatorNameDecl:      INDICATOR Integer EQUALS Expr SEMI
 412                         { $$ = IndicatorNameCreate($2, $4, false); }
 413                 |       VIRTUAL INDICATOR Integer EQUALS Expr SEMI
 414                         { $$ = IndicatorNameCreate($3, $5, true); }
 415                 ;
 416
 417 ShapeDecl       :       SHAPE String OBRACE OutlineList CBRACE SEMI
 418                         { $$ = NULL; }
 419                 |       SHAPE String OBRACE CoordList CBRACE SEMI
 420                         { $$ = NULL; }
 421                 ;
 422
 423 SectionDecl     :       SECTION String OBRACE SectionBody CBRACE SEMI
 424                         { $$ = NULL; }
 425                 ;
 426
 427 SectionBody     :       SectionBody SectionBodyItem     { $$ = NULL;}
 428                 |       SectionBodyItem                 { $$ = NULL; }
 429                 ;
 430
 431 SectionBodyItem :       ROW OBRACE RowBody CBRACE SEMI
 432                         { $$ = NULL; }
 433                 |       VarDecl
 434                         { FreeStmt(&$1->common); $$ = NULL; }
 435                 |       DoodadDecl
 436                         { $$ = NULL; }
 437                 |       IndicatorMapDecl
 438                         { FreeStmt(&$1->common); $$ = NULL; }
 439                 |       OverlayDecl
 440                         { $$ = NULL; }
 441                 ;
 442
 443 RowBody         :       RowBody RowBodyItem     { $$ = NULL;}
 444                 |       RowBodyItem             { $$ = NULL; }
 445                 ;
 446
 447 RowBodyItem     :       KEYS OBRACE Keys CBRACE SEMI { $$ = NULL; }
 448                 |       VarDecl
 449                         { FreeStmt(&$1->common); $$ = NULL; }
 450                 ;
 451
 452 Keys            :       Keys COMMA Key          { $$ = NULL; }
 453                 |       Key                     { $$ = NULL; }
 454                 ;
 455
 456 Key             :       KEYNAME
 457                         { $$ = NULL; }
 458                 |       OBRACE ExprList CBRACE
 459                         { FreeStmt(&$2->common); $$ = NULL; }
 460                 ;
 461
 462 OverlayDecl     :       OVERLAY String OBRACE OverlayKeyList CBRACE SEMI
 463                         { $$ = NULL; }
 464                 ;
 465
 466 OverlayKeyList  :       OverlayKeyList COMMA OverlayKey { $$ = NULL; }
 467                 |       OverlayKey                      { $$ = NULL; }
 468                 ;
 469
 470 OverlayKey      :       KEYNAME EQUALS KEYNAME          { $$ = NULL; }
 471                 ;
 472
 473 OutlineList     :       OutlineList COMMA OutlineInList
 474                         { $$ = NULL;}
 475                 |       OutlineInList
 476                         { $$ = NULL; }
 477                 ;
 478
 479 OutlineInList   :       OBRACE CoordList CBRACE
 480                         { $$ = NULL; }
 481                 |       Ident EQUALS OBRACE CoordList CBRACE
 482                         { $$ = NULL; }
 483                 |       Ident EQUALS Expr
 484                         { FreeStmt(&$3->common); $$ = NULL; }
 485                 ;
 486
 487 CoordList       :       CoordList COMMA Coord
 488                         { $$ = NULL; }
 489                 |       Coord
 490                         { $$ = NULL; }
 491                 ;
 492
 493 Coord           :       OBRACKET SignedNumber COMMA SignedNumber CBRACKET
 494                         { $$ = NULL; }
 495                 ;
 496
 497 DoodadDecl      :       DoodadType String OBRACE VarDeclList CBRACE SEMI
 498                         { FreeStmt(&$4->common); $$ = NULL; }
 499                 ;
 500
 501 DoodadType      :       TEXT    { $$ = 0; }
 502                 |       OUTLINE { $$ = 0; }
 503                 |       SOLID   { $$ = 0; }
 504                 |       LOGO    { $$ = 0; }
 505                 ;
 506
 507 FieldSpec       :       Ident   { $$ = $1; }
 508                 |       Element { $$ = $1; }
 509                 ;
 510
 511 Element         :       ACTION_TOK
 512                         { $$ = xkb_atom_intern(param->ctx, "action"); }
 513                 |       INTERPRET
 514                         { $$ = xkb_atom_intern(param->ctx, "interpret"); }
 515                 |       TYPE
 516                         { $$ = xkb_atom_intern(param->ctx, "type"); }
 517                 |       KEY
 518                         { $$ = xkb_atom_intern(param->ctx, "key"); }
 519                 |       GROUP
 520                         { $$ = xkb_atom_intern(param->ctx, "group"); }
 521                 |       MODIFIER_MAP
 522                         {$$ = xkb_atom_intern(param->ctx, "modifier_map");}
 523                 |       INDICATOR
 524                         { $$ = xkb_atom_intern(param->ctx, "indicator"); }
 525                 |       SHAPE
 526                         { $$ = xkb_atom_intern(param->ctx, "shape"); }
 527                 |       ROW
 528                         { $$ = XKB_ATOM_NONE; }
 529                 |       SECTION
 530                         { $$ = XKB_ATOM_NONE; }
 531                 |       TEXT
 532                         { $$ = XKB_ATOM_NONE; }
 533                 ;
 534
 535 OptMergeMode    :       MergeMode       { $$ = $1; }
 536                 |                       { $$ = MERGE_DEFAULT; }
 537                 ;
 538
 539 MergeMode       :       INCLUDE         { $$ = MERGE_DEFAULT; }
 540                 |       AUGMENT         { $$ = MERGE_AUGMENT; }
 541                 |       OVERRIDE        { $$ = MERGE_OVERRIDE; }
 542                 |       REPLACE         { $$ = MERGE_REPLACE; }
 543                 |       ALTERNATE
 544                 {
 545                     /*
 546                      * This used to be MERGE_ALT_FORM. This functionality was
 547                      * unused and has been removed.
 548                      */
 549                     $$ = MERGE_DEFAULT;
 550                 }
 551                 ;
 552
 553 OptExprList     :       ExprList        { $$ = $1; }
 554                 |                       { $$ = NULL; }
 555                 ;
 556
 557 ExprList        :       ExprList COMMA Expr
 558                         { $$ = (ExprDef *)AppendStmt(&$1->common, &$3->common); }
 559                 |       Expr
 560                         { $$ = $1; }
 561                 ;
 562
 563 Expr            :       Expr DIVIDE Expr
 564                         { $$ = ExprCreateBinary(EXPR_DIVIDE, $1, $3); }
 565                 |       Expr PLUS Expr
 566                         { $$ = ExprCreateBinary(EXPR_ADD, $1, $3); }
 567                 |       Expr MINUS Expr
 568                         { $$ = ExprCreateBinary(EXPR_SUBTRACT, $1, $3); }
 569                 |       Expr TIMES Expr
 570                         { $$ = ExprCreateBinary(EXPR_MULTIPLY, $1, $3); }
 571                 |       Lhs EQUALS Expr
 572                         { $$ = ExprCreateBinary(EXPR_ASSIGN, $1, $3); }
 573                 |       Term
 574                         { $$ = $1; }
 575                 ;
 576
 577 Term            :       MINUS Term
 578                         { $$ = ExprCreateUnary(EXPR_NEGATE, $2->value_type, $2); }
 579                 |       PLUS Term
 580                         { $$ = ExprCreateUnary(EXPR_UNARY_PLUS, $2->value_type, $2); }
 581                 |       EXCLAM Term
 582                         { $$ = ExprCreateUnary(EXPR_NOT, EXPR_TYPE_BOOLEAN, $2); }
 583                 |       INVERT Term
 584                         { $$ = ExprCreateUnary(EXPR_INVERT, $2->value_type, $2); }
 585                 |       Lhs
 586                         { $$ = $1;  }
 587                 |       FieldSpec OPAREN OptExprList CPAREN %prec OPAREN
 588                         { $$ = ActionCreate($1, $3); }
 589                 |       Terminal
 590                         { $$ = $1;  }
 591                 |       OPAREN Expr CPAREN
 592                         { $$ = $2;  }
 593                 ;
 594
 595 ActionList      :       ActionList COMMA Action
 596                         { $$ = (ExprDef *)AppendStmt(&$1->common, &$3->common); }
 597                 |       Action
 598                         { $$ = $1; }
 599                 ;
 600
 601 Action          :       FieldSpec OPAREN OptExprList CPAREN
 602                         { $$ = ActionCreate($1, $3); }
 603                 ;
 604
 605 Lhs             :       FieldSpec
 606                         {
 607                             ExprDef *expr;
 608                             expr = ExprCreate(EXPR_IDENT, EXPR_TYPE_UNKNOWN);
 609                             expr->value.str = $1;
 610                             $$ = expr;
 611                         }
 612                 |       FieldSpec DOT FieldSpec
 613                         {
 614                             ExprDef *expr;
 615                             expr = ExprCreate(EXPR_FIELD_REF, EXPR_TYPE_UNKNOWN);
 616                             expr->value.field.element = $1;
 617                             expr->value.field.field = $3;
 618                             $$ = expr;
 619                         }
 620                 |       FieldSpec OBRACKET Expr CBRACKET
 621                         {
 622                             ExprDef *expr;
 623                             expr = ExprCreate(EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
 624                             expr->value.array.element = XKB_ATOM_NONE;
 625                             expr->value.array.field = $1;
 626                             expr->value.array.entry = $3;
 627                             $$ = expr;
 628                         }
 629                 |       FieldSpec DOT FieldSpec OBRACKET Expr CBRACKET
 630                         {
 631                             ExprDef *expr;
 632                             expr = ExprCreate(EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
 633                             expr->value.array.element = $1;
 634                             expr->value.array.field = $3;
 635                             expr->value.array.entry = $5;
 636                             $$ = expr;
 637                         }
 638                 ;
 639
 640 Terminal        :       String
 641                         {
 642                             ExprDef *expr;
 643                             expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_STRING);
 644                             expr->value.str = $1;
 645                             $$ = expr;
 646                         }
 647                 |       Integer
 648                         {
 649                             ExprDef *expr;
 650                             expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_INT);
 651                             expr->value.ival = $1;
 652                             $$ = expr;
 653                         }
 654                 |       Float
 655                         {
 656                             $$ = NULL;
 657                         }
 658                 |       KEYNAME
 659                         {
 660                             ExprDef *expr;
 661                             expr = ExprCreate(EXPR_VALUE, EXPR_TYPE_KEYNAME);
 662                             expr->value.keyName = $1;
 663                             $$ = expr;
 664                         }
 665                 ;
 666
 667 OptKeySymList   :       KeySymList      { $$ = $1; }
 668                 |                       { $$ = NULL; }
 669                 ;
 670
 671 KeySymList      :       KeySymList COMMA KeySym
 672                         { $$ = AppendKeysymList($1, $3); }
 673                 |       KeySymList COMMA KeySyms
 674                         { $$ = AppendMultiKeysymList($1, $3); }
 675                 |       KeySym
 676                         { $$ = CreateKeysymList($1); }
 677                 |       KeySyms
 678                         { $$ = CreateMultiKeysymList($1); }
 679                 ;
 680
 681 KeySyms         :       OBRACE KeySymList CBRACE
 682                         { $$ = $2; }
 683                 ;
 684
 685 KeySym          :       IDENT   { $$ = $1; }
 686                 |       SECTION { $$ = strdup("section"); }
 687                 |       Integer
 688                         {
 689                             if ($1 < 10) {      /* XK_0 .. XK_9 */
 690                                 $$ = malloc(2);
 691                                 $$[0] = $1 + '0';
 692                                 $$[1] = '\0';
 693                             }
 694                             else {
 695                                 $$ = malloc(17);
 696                                 snprintf($$, 17, "0x%x", $1);
 697                             }
 698                         }
 699                 ;
 700
 701 SignedNumber    :       MINUS Number    { $$ = -$2; }
 702                 |       Number          { $$ = $1; }
 703                 ;
 704
 705 Number          :       FLOAT   { $$ = $1; }
 706                 |       INTEGER { $$ = $1; }
 707                 ;
 708
 709 Float           :       FLOAT   { $$ = 0; }
 710                 ;
 711
 712 Integer         :       INTEGER { $$ = $1; }
 713                 ;
 714
 715 KeyCode         :       INTEGER { $$ = $1; }
 716                 ;
 717
 718 Ident           :       IDENT   { $$ = xkb_atom_steal(param->ctx, $1); }
 719                 |       DEFAULT { $$ = xkb_atom_intern(param->ctx, "default"); }
 720                 ;
 721
 722 String          :       STRING  { $$ = xkb_atom_steal(param->ctx, $1); }
 723                 ;
 724
 725 OptMapName      :       MapName { $$ = $1; }
 726                 |               { $$ = NULL; }
 727                 ;
 728
 729 MapName         :       STRING  { $$ = $1; }
 730                 ;
 731
 732 %%
 733
 734 #undef scanner