src/xkbcomp/xkbparse.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 %token
  28         END_OF_FILE     0
  29         ERROR_TOK       255
  30         XKB_KEYMAP      1
  31         XKB_KEYCODES    2
  32         XKB_TYPES       3
  33         XKB_SYMBOLS     4
  34         XKB_COMPATMAP   5
  35         XKB_GEOMETRY    6
  36         XKB_SEMANTICS   7
  37         XKB_LAYOUT      8
  38         INCLUDE         10
  39         OVERRIDE        11
  40         AUGMENT         12
  41         REPLACE         13
  42         ALTERNATE       14
  43         VIRTUAL_MODS    20
  44         TYPE            21
  45         INTERPRET       22
  46         ACTION_TOK      23
  47         KEY             24
  48         ALIAS           25
  49         GROUP           26
  50         MODIFIER_MAP    27
  51         INDICATOR       28
  52         SHAPE           29
  53         KEYS            30
  54         ROW             31
  55         SECTION         32
  56         OVERLAY         33
  57         TEXT            34
  58         OUTLINE         35
  59         SOLID           36
  60         LOGO            37
  61         VIRTUAL         38
  62         EQUALS          40
  63         PLUS            41
  64         MINUS           42
  65         DIVIDE          43
  66         TIMES           44
  67         OBRACE          45
  68         CBRACE          46
  69         OPAREN          47
  70         CPAREN          48
  71         OBRACKET        49
  72         CBRACKET        50
  73         DOT             51
  74         COMMA           52
  75         SEMI            53
  76         EXCLAM          54
  77         INVERT          55
  78         STRING          60
  79         INTEGER         61
  80         FLOAT           62
  81         IDENT           63
  82         KEYNAME         64
  83         PARTIAL         70
  84         DEFAULT         71
  85         HIDDEN          72
  86         ALPHANUMERIC_KEYS       73
  87         MODIFIER_KEYS           74
  88         KEYPAD_KEYS             75
  89         FUNCTION_KEYS           76
  90         ALTERNATE_GROUP         77
  91 %{
  92 #ifdef DEBUG
  93 #define YYDEBUG 1
  94 #endif
  95 #define DEBUG_VAR parseDebug
  96 #include "parseutils.h"
  97 #include <X11/keysym.h>
  98 #include <X11/extensions/XKBgeomcommon.h>
  99 #include <stdlib.h>
 100
 101 unsigned int parseDebug;
 102
 103 %}
 104 %right  EQUALS
 105 %left   PLUS MINUS
 106 %left   TIMES DIVIDE
 107 %left   EXCLAM INVERT
 108 %left   OPAREN
 109 %start  XkbFile
 110 %union  {
 111         int              ival;
 112         unsigned         uval;
 113         char            *str;
 114         Atom            sval;
 115         ParseCommon     *any;
 116         ExprDef         *expr;
 117         VarDef          *var;
 118         VModDef         *vmod;
 119         InterpDef       *interp;
 120         KeyTypeDef      *keyType;
 121         SymbolsDef      *syms;
 122         ModMapDef       *modMask;
 123         GroupCompatDef  *groupCompat;
 124         IndicatorMapDef *ledMap;
 125         IndicatorNameDef *ledName;
 126         KeycodeDef      *keyName;
 127         KeyAliasDef     *keyAlias;
 128         ShapeDef        *shape;
 129         SectionDef      *section;
 130         RowDef          *row;
 131         KeyDef          *key;
 132         OverlayDef      *overlay;
 133         OverlayKeyDef   *olKey;
 134         OutlineDef      *outline;
 135         DoodadDef       *doodad;
 136         XkbFile         *file;
 137 }
 138 %type <ival>    Number Integer Float SignedNumber
 139 %type <uval>    XkbCompositeType FileType MergeMode OptMergeMode KeySym
 140 %type <uval>    DoodadType Flag Flags OptFlags
 141 %type <str>     KeyName MapName OptMapName
 142 %type <sval>    FieldSpec Ident Element String
 143 %type <any>     DeclList Decl
 144 %type <expr>    OptExprList ExprList Expr Term Lhs Terminal ArrayInit
 145 %type <expr>    OptKeySymList KeySymList Action ActionList Coord CoordList
 146 %type <var>     VarDecl VarDeclList SymbolsBody SymbolsVarDecl
 147 %type <vmod>    VModDecl VModDefList VModDef
 148 %type <interp>  InterpretDecl InterpretMatch
 149 %type <keyType> KeyTypeDecl
 150 %type <syms>    SymbolsDecl
 151 %type <modMask> ModMapDecl
 152 %type <groupCompat> GroupCompatDecl
 153 %type <ledMap>  IndicatorMapDecl
 154 %type <ledName> IndicatorNameDecl
 155 %type <keyName> KeyNameDecl
 156 %type <keyAlias> KeyAliasDecl
 157 %type <shape>   ShapeDecl
 158 %type <section> SectionDecl
 159 %type <row>     SectionBody SectionBodyItem
 160 %type <key>     RowBody RowBodyItem Keys Key
 161 %type <overlay> OverlayDecl
 162 %type <olKey>   OverlayKeyList OverlayKey
 163 %type <outline> OutlineList OutlineInList
 164 %type <doodad>  DoodadDecl
 165 %type <file>    XkbFile XkbMapConfigList XkbMapConfig XkbConfig
 166 %type <file>    XkbCompositeMap XkbCompMapList
 167 %%
 168 XkbFile         :       XkbCompMapList
 169                         { $$= rtrnValue= $1; }
 170                 |       XkbMapConfigList
 171                         { $$= rtrnValue= $1;  }
 172                 |       XkbConfig
 173                         { $$= rtrnValue= $1; }
 174                 ;
 175
 176 XkbCompMapList  :       XkbCompMapList XkbCompositeMap
 177                         { $$= (XkbFile *)AppendStmt(&$1->common,&$2->common); }
 178                 |       XkbCompositeMap
 179                         { $$= $1; }
 180                 ;
 181
 182 XkbCompositeMap :       OptFlags XkbCompositeType OptMapName OBRACE
 183                             XkbMapConfigList
 184                         CBRACE SEMI
 185                         { $$= CreateXKBFile($2,$3,&$5->common,$1); }
 186                 ;
 187
 188 XkbCompositeType:       XKB_KEYMAP      { $$= XkmKeymapFile; }
 189                 |       XKB_SEMANTICS   { $$= XkmSemanticsFile; }
 190                 |       XKB_LAYOUT      { $$= XkmLayoutFile; }
 191                 ;
 192
 193 XkbMapConfigList :      XkbMapConfigList XkbMapConfig
 194                         { $$= (XkbFile *)AppendStmt(&$1->common,&$2->common); }
 195                 |       XkbMapConfig
 196                         { $$= $1; }
 197                 ;
 198
 199 XkbMapConfig    :       OptFlags FileType OptMapName OBRACE
 200                             DeclList
 201                         CBRACE SEMI
 202                         { $$= CreateXKBFile($2,$3,$5,$1); }
 203                 ;
 204
 205 XkbConfig       :       OptFlags FileType OptMapName DeclList
 206                         { $$= CreateXKBFile($2,$3,$4,$1); }
 207                 ;
 208
 209
 210 FileType        :       XKB_KEYCODES            { $$= XkmKeyNamesIndex; }
 211                 |       XKB_TYPES               { $$= XkmTypesIndex; }
 212                 |       XKB_COMPATMAP           { $$= XkmCompatMapIndex; }
 213                 |       XKB_SYMBOLS             { $$= XkmSymbolsIndex; }
 214                 |       XKB_GEOMETRY            { $$= XkmGeometryIndex; }
 215                 ;
 216
 217 OptFlags        :       Flags                   { $$= $1; }
 218                 |                               { $$= 0; }
 219                 ;
 220
 221 Flags           :       Flags Flag              { $$= (($1)|($2)); }
 222                 |       Flag                    { $$= $1; }
 223                 ;
 224
 225 Flag            :       PARTIAL                 { $$= XkbLC_Partial; }
 226                 |       DEFAULT                 { $$= XkbLC_Default; }
 227                 |       HIDDEN                  { $$= XkbLC_Hidden; }
 228                 |       ALPHANUMERIC_KEYS       { $$= XkbLC_AlphanumericKeys; }
 229                 |       MODIFIER_KEYS           { $$= XkbLC_ModifierKeys; }
 230                 |       KEYPAD_KEYS             { $$= XkbLC_KeypadKeys; }
 231                 |       FUNCTION_KEYS           { $$= XkbLC_FunctionKeys; }
 232                 |       ALTERNATE_GROUP         { $$= XkbLC_AlternateGroup; }
 233                 ;
 234
 235 DeclList        :       DeclList Decl
 236                         { $$= AppendStmt($1,$2); }
 237                 |       { $$= NULL; }
 238                 ;
 239
 240 Decl            :       OptMergeMode VarDecl
 241                         {
 242                             $2->merge= StmtSetMerge(&$2->common,$1);
 243                             $$= &$2->common;
 244                         }
 245                 |       OptMergeMode VModDecl
 246                         {
 247                             $2->merge= StmtSetMerge(&$2->common,$1);
 248                             $$= &$2->common;
 249                         }
 250                 |       OptMergeMode InterpretDecl
 251                         {
 252                             $2->merge= StmtSetMerge(&$2->common,$1);
 253                             $$= &$2->common;
 254                         }
 255                 |       OptMergeMode KeyNameDecl
 256                         {
 257                             $2->merge= StmtSetMerge(&$2->common,$1);
 258                             $$= &$2->common;
 259                         }
 260                 |       OptMergeMode KeyAliasDecl
 261                         {
 262                             $2->merge= StmtSetMerge(&$2->common,$1);
 263                             $$= &$2->common;
 264                         }
 265                 |       OptMergeMode KeyTypeDecl
 266                         {
 267                             $2->merge= StmtSetMerge(&$2->common,$1);
 268                             $$= &$2->common;
 269                         }
 270                 |       OptMergeMode SymbolsDecl
 271                         {
 272                             $2->merge= StmtSetMerge(&$2->common,$1);
 273                             $$= &$2->common;
 274                         }
 275                 |       OptMergeMode ModMapDecl
 276                         {
 277                             $2->merge= StmtSetMerge(&$2->common,$1);
 278                             $$= &$2->common;
 279                         }
 280                 |       OptMergeMode GroupCompatDecl
 281                         {
 282                             $2->merge= StmtSetMerge(&$2->common,$1);
 283                             $$= &$2->common;
 284                         }
 285                 |       OptMergeMode IndicatorMapDecl
 286                         {
 287                             $2->merge= StmtSetMerge(&$2->common,$1);
 288                             $$= &$2->common;
 289                         }
 290                 |       OptMergeMode IndicatorNameDecl
 291                         {
 292                             $2->merge= StmtSetMerge(&$2->common,$1);
 293                             $$= &$2->common;
 294                         }
 295                 |       OptMergeMode ShapeDecl
 296                         {
 297                             $2->merge= StmtSetMerge(&$2->common,$1);
 298                             $$= &$2->common;
 299                         }
 300                 |       OptMergeMode SectionDecl
 301                         {
 302                             $2->merge= StmtSetMerge(&$2->common,$1);
 303                             $$= &$2->common;
 304                         }
 305                 |       OptMergeMode DoodadDecl
 306                         {
 307                             $2->merge= StmtSetMerge(&$2->common,$1);
 308                             $$= &$2->common;
 309                         }
 310                 |       MergeMode STRING
 311                         {
 312                             if ($1==MergeAltForm) {
 313                                 yyerror("cannot use 'alternate' to include other maps");
 314                                 $$= &IncludeCreate(scanStr,MergeDefault)->common;
 315                             }
 316                             else {
 317                                 $$= &IncludeCreate(scanStr,$1)->common;
 318                             }
 319                         }
 320                 ;
 321
 322 VarDecl         :       Lhs EQUALS Expr SEMI
 323                         { $$= VarCreate($1,$3); }
 324                 |       Ident SEMI
 325                         { $$= BoolVarCreate($1,1); }
 326                 |       EXCLAM Ident SEMI
 327                         { $$= BoolVarCreate($2,0); }
 328                 ;
 329
 330 KeyNameDecl     :       KeyName EQUALS Expr SEMI
 331                         {
 332                             KeycodeDef *def;
 333
 334                             def= KeycodeCreate($1,$3);
 335                             if ($1)
 336                                 free($1);
 337                             $$= def;
 338                         }
 339                 ;
 340
 341 KeyAliasDecl    :       ALIAS KeyName EQUALS KeyName SEMI
 342                         {
 343                             KeyAliasDef *def;
 344                             def= KeyAliasCreate($2,$4);
 345                             if ($2)     free($2);
 346                             if ($4)     free($4);
 347                             $$= def;
 348                         }
 349                 ;
 350
 351 VModDecl        :       VIRTUAL_MODS VModDefList SEMI
 352                         { $$= $2; }
 353                 ;
 354
 355 VModDefList     :       VModDefList COMMA VModDef
 356                         { $$= (VModDef *)AppendStmt(&$1->common,&$3->common); }
 357                 |       VModDef
 358                         { $$= $1; }
 359                 ;
 360
 361 VModDef         :       Ident
 362                         { $$= VModCreate($1,NULL); }
 363                 |       Ident EQUALS Expr
 364                         { $$= VModCreate($1,$3); }
 365                 ;
 366
 367 InterpretDecl   :       INTERPRET InterpretMatch OBRACE
 368                             VarDeclList
 369                         CBRACE SEMI
 370                         {
 371                             $2->def= $4;
 372                             $$= $2;
 373                         }
 374                 ;
 375
 376 InterpretMatch  :       KeySym PLUS Expr
 377                         { $$= InterpCreate((KeySym)$1,$3); }
 378                 |       KeySym
 379                         { $$= InterpCreate((KeySym)$1,NULL); }
 380                 ;
 381
 382 VarDeclList     :       VarDeclList VarDecl
 383                         { $$= (VarDef *)AppendStmt(&$1->common,&$2->common); }
 384                 |       VarDecl
 385                         { $$= $1; }
 386                 ;
 387
 388 KeyTypeDecl     :       TYPE String OBRACE
 389                             VarDeclList
 390                         CBRACE SEMI
 391                         { $$= KeyTypeCreate($2,$4); }
 392                 ;
 393
 394 SymbolsDecl     :       KEY KeyName OBRACE
 395                             SymbolsBody
 396                         CBRACE SEMI
 397                         { $$= SymbolsCreate($2,(ExprDef *)$4); }
 398                 ;
 399
 400 SymbolsBody     :       SymbolsBody COMMA SymbolsVarDecl
 401                         { $$= (VarDef *)AppendStmt(&$1->common,&$3->common); }
 402                 |       SymbolsVarDecl
 403                         { $$= $1; }
 404                 |       { $$= NULL; }
 405                 ;
 406
 407 SymbolsVarDecl  :       Lhs EQUALS Expr
 408                         { $$= VarCreate($1,$3); }
 409                 |       Lhs EQUALS ArrayInit
 410                         { $$= VarCreate($1,$3); }
 411                 |       Ident
 412                         { $$= BoolVarCreate($1,1); }
 413                 |       EXCLAM Ident
 414                         { $$= BoolVarCreate($2,0); }
 415                 |       ArrayInit
 416                         { $$= VarCreate(NULL,$1); }
 417                 ;
 418
 419 ArrayInit       :       OBRACKET OptKeySymList CBRACKET
 420                         { $$= $2; }
 421                 |       OBRACKET ActionList CBRACKET
 422                         { $$= ExprCreateUnary(ExprActionList,TypeAction,$2); }
 423                 ;
 424
 425 GroupCompatDecl :       GROUP Integer EQUALS Expr SEMI
 426                         { $$= GroupCompatCreate($2,$4); }
 427                 ;
 428
 429 ModMapDecl      :       MODIFIER_MAP Ident OBRACE ExprList CBRACE SEMI
 430                         { $$= ModMapCreate($2,$4); }
 431                 ;
 432
 433 IndicatorMapDecl:       INDICATOR String OBRACE VarDeclList CBRACE SEMI
 434                         { $$= IndicatorMapCreate($2,$4); }
 435                 ;
 436
 437 IndicatorNameDecl:      INDICATOR Integer EQUALS Expr SEMI
 438                         { $$= IndicatorNameCreate($2,$4,False); }
 439                 |       VIRTUAL INDICATOR Integer EQUALS Expr SEMI
 440                         { $$= IndicatorNameCreate($3,$5,True); }
 441                 ;
 442
 443 ShapeDecl       :       SHAPE String OBRACE OutlineList CBRACE SEMI
 444                         { $$= ShapeDeclCreate($2,(OutlineDef *)&$4->common); }
 445                 |       SHAPE String OBRACE CoordList CBRACE SEMI
 446                         {
 447                             OutlineDef *outlines;
 448                             outlines= OutlineCreate(None,$4);
 449                             $$= ShapeDeclCreate($2,outlines);
 450                         }
 451                 ;
 452
 453 SectionDecl     :       SECTION String OBRACE SectionBody CBRACE SEMI
 454                         { $$= SectionDeclCreate($2,$4); }
 455                 ;
 456
 457 SectionBody     :       SectionBody SectionBodyItem
 458                         { $$=(RowDef *)AppendStmt(&$1->common,&$2->common);}
 459                 |       SectionBodyItem
 460                         { $$= $1; }
 461                 ;
 462
 463 SectionBodyItem :       ROW OBRACE RowBody CBRACE SEMI
 464                         { $$= RowDeclCreate($3); }
 465                 |       VarDecl
 466                         { $$= (RowDef *)$1; }
 467                 |       DoodadDecl
 468                         { $$= (RowDef *)$1; }
 469                 |       IndicatorMapDecl
 470                         { $$= (RowDef *)$1; }
 471                 |       OverlayDecl
 472                         { $$= (RowDef *)$1; }
 473                 ;
 474
 475 RowBody         :       RowBody RowBodyItem
 476                         { $$=(KeyDef *)AppendStmt(&$1->common,&$2->common);}
 477                 |       RowBodyItem
 478                         { $$= $1; }
 479                 ;
 480
 481 RowBodyItem     :       KEYS OBRACE Keys CBRACE SEMI
 482                         { $$= $3; }
 483                 |       VarDecl
 484                         { $$= (KeyDef *)$1; }
 485                 ;
 486
 487 Keys            :       Keys COMMA Key
 488                         { $$=(KeyDef *)AppendStmt(&$1->common,&$3->common);}
 489                 |       Key
 490                         { $$= $1; }
 491                 ;
 492
 493 Key             :       KeyName
 494                         { $$= KeyDeclCreate($1,NULL); }
 495                 |       OBRACE ExprList CBRACE
 496                         { $$= KeyDeclCreate(NULL,$2); }
 497                 ;
 498
 499 OverlayDecl     :       OVERLAY String OBRACE OverlayKeyList CBRACE SEMI
 500                         { $$= OverlayDeclCreate($2,$4); }
 501                 ;
 502
 503 OverlayKeyList  :       OverlayKeyList COMMA OverlayKey
 504                         {
 505                             $$= (OverlayKeyDef *)
 506                                 AppendStmt(&$1->common,&$3->common);
 507                         }
 508                 |       OverlayKey
 509                         { $$= $1; }
 510                 ;
 511
 512 OverlayKey      :       KeyName EQUALS KeyName
 513                         { $$= OverlayKeyCreate($1,$3); }
 514                 ;
 515
 516 OutlineList     :       OutlineList COMMA OutlineInList
 517                         { $$=(OutlineDef *)AppendStmt(&$1->common,&$3->common);}
 518                 |       OutlineInList
 519                         { $$= $1; }
 520                 ;
 521
 522 OutlineInList   :       OBRACE CoordList CBRACE
 523                         { $$= OutlineCreate(None,$2); }
 524                 |       Ident EQUALS OBRACE CoordList CBRACE
 525                         { $$= OutlineCreate($1,$4); }
 526                 |       Ident EQUALS Expr
 527                         { $$= OutlineCreate($1,$3); }
 528                 ;
 529
 530 CoordList       :       CoordList COMMA Coord
 531                         { $$= (ExprDef *)AppendStmt(&$1->common,&$3->common); }
 532                 |       Coord
 533                         { $$= $1; }
 534                 ;
 535
 536 Coord           :       OBRACKET SignedNumber COMMA SignedNumber CBRACKET
 537                         {
 538                             ExprDef *expr;
 539                             expr= ExprCreate(ExprCoord,TypeUnknown);
 540                             expr->value.coord.x= $2;
 541                             expr->value.coord.y= $4;
 542                             $$= expr;
 543                         }
 544                 ;
 545
 546 DoodadDecl      :       DoodadType String OBRACE VarDeclList CBRACE SEMI
 547                         { $$= DoodadCreate($1,$2,$4); }
 548                 ;
 549
 550 DoodadType      :       TEXT                    { $$= XkbTextDoodad; }
 551                 |       OUTLINE                 { $$= XkbOutlineDoodad; }
 552                 |       SOLID                   { $$= XkbSolidDoodad; }
 553                 |       LOGO                    { $$= XkbLogoDoodad; }
 554                 ;
 555
 556 FieldSpec       :       Ident                   { $$= $1; }
 557                 |       Element                 { $$= $1; }
 558                 ;
 559
 560 Element         :       ACTION_TOK
 561                         { $$= XkbInternAtom(NULL,"action",False); }
 562                 |       INTERPRET
 563                         { $$= XkbInternAtom(NULL,"interpret",False); }
 564                 |       TYPE
 565                         { $$= XkbInternAtom(NULL,"type",False); }
 566                 |       KEY
 567                         { $$= XkbInternAtom(NULL,"key",False); }
 568                 |       GROUP
 569                         { $$= XkbInternAtom(NULL,"group",False); }
 570                 |       MODIFIER_MAP
 571                         {$$=XkbInternAtom(NULL,"modifier_map",False);}
 572                 |       INDICATOR
 573                         { $$= XkbInternAtom(NULL,"indicator",False); }
 574                 |       SHAPE
 575                         { $$= XkbInternAtom(NULL,"shape",False); }
 576                 |       ROW
 577                         { $$= XkbInternAtom(NULL,"row",False); }
 578                 |       SECTION
 579                         { $$= XkbInternAtom(NULL,"section",False); }
 580                 |       TEXT
 581                         { $$= XkbInternAtom(NULL,"text",False); }
 582                 ;
 583
 584 OptMergeMode    :       MergeMode               { $$= $1; }
 585                 |                               { $$= MergeDefault; }
 586                 ;
 587
 588 MergeMode       :       INCLUDE                 { $$= MergeDefault; }
 589                 |       AUGMENT                 { $$= MergeAugment; }
 590                 |       OVERRIDE                { $$= MergeOverride; }
 591                 |       REPLACE                 { $$= MergeReplace; }
 592                 |       ALTERNATE               { $$= MergeAltForm; }
 593                 ;
 594
 595 OptExprList     :       ExprList                        { $$= $1; }
 596                 |                               { $$= NULL; }
 597                 ;
 598
 599 ExprList        :       ExprList COMMA Expr
 600                         { $$= (ExprDef *)AppendStmt(&$1->common,&$3->common); }
 601                 |       Expr
 602                         { $$= $1; }
 603                 ;
 604
 605 Expr            :       Expr DIVIDE Expr
 606                         { $$= ExprCreateBinary(OpDivide,$1,$3); }
 607                 |       Expr PLUS Expr
 608                         { $$= ExprCreateBinary(OpAdd,$1,$3); }
 609                 |       Expr MINUS Expr
 610                         { $$= ExprCreateBinary(OpSubtract,$1,$3); }
 611                 |       Expr TIMES Expr
 612                         { $$= ExprCreateBinary(OpMultiply,$1,$3); }
 613                 |       Lhs EQUALS Expr
 614                         { $$= ExprCreateBinary(OpAssign,$1,$3); }
 615                 |       Term
 616                         { $$= $1; }
 617                 ;
 618
 619 Term            :       MINUS Term
 620                         { $$= ExprCreateUnary(OpNegate,$2->type,$2); }
 621                 |       PLUS Term
 622                         { $$= ExprCreateUnary(OpUnaryPlus,$2->type,$2); }
 623                 |       EXCLAM Term
 624                         { $$= ExprCreateUnary(OpNot,TypeBoolean,$2); }
 625                 |       INVERT Term
 626                         { $$= ExprCreateUnary(OpInvert,$2->type,$2); }
 627                 |       Lhs
 628                         { $$= $1;  }
 629                 |       FieldSpec OPAREN OptExprList CPAREN %prec OPAREN
 630                         { $$= ActionCreate($1,$3); }
 631                 |       Terminal
 632                         { $$= $1;  }
 633                 |       OPAREN Expr CPAREN
 634                         { $$= $2;  }
 635                 ;
 636
 637 ActionList      :       ActionList COMMA Action
 638                         { $$= (ExprDef *)AppendStmt(&$1->common,&$3->common); }
 639                 |       Action
 640                         { $$= $1; }
 641                 ;
 642
 643 Action          :       FieldSpec OPAREN OptExprList CPAREN
 644                         { $$= ActionCreate($1,$3); }
 645                 ;
 646
 647 Lhs             :       FieldSpec
 648                         {
 649                             ExprDef *expr;
 650                             expr= ExprCreate(ExprIdent,TypeUnknown);
 651                             expr->value.str= $1;
 652                             $$= expr;
 653                         }
 654                 |       FieldSpec DOT FieldSpec
 655                         {
 656                             ExprDef *expr;
 657                             expr= ExprCreate(ExprFieldRef,TypeUnknown);
 658                             expr->value.field.element= $1;
 659                             expr->value.field.field= $3;
 660                             $$= expr;
 661                         }
 662                 |       FieldSpec OBRACKET Expr CBRACKET
 663                         {
 664                             ExprDef *expr;
 665                             expr= ExprCreate(ExprArrayRef,TypeUnknown);
 666                             expr->value.array.element= None;
 667                             expr->value.array.field= $1;
 668                             expr->value.array.entry= $3;
 669                             $$= expr;
 670                         }
 671                 |       FieldSpec DOT FieldSpec OBRACKET Expr CBRACKET
 672                         {
 673                             ExprDef *expr;
 674                             expr= ExprCreate(ExprArrayRef,TypeUnknown);
 675                             expr->value.array.element= $1;
 676                             expr->value.array.field= $3;
 677                             expr->value.array.entry= $5;
 678                             $$= expr;
 679                         }
 680                 ;
 681
 682 Terminal        :       String
 683                         {
 684                             ExprDef *expr;
 685                             expr= ExprCreate(ExprValue,TypeString);
 686                             expr->value.str= $1;
 687                             $$= expr;
 688                         }
 689                 |       Integer
 690                         {
 691                             ExprDef *expr;
 692                             expr= ExprCreate(ExprValue,TypeInt);
 693                             expr->value.ival= $1;
 694                             $$= expr;
 695                         }
 696                 |       Float
 697                         {
 698                             ExprDef *expr;
 699                             expr= ExprCreate(ExprValue,TypeFloat);
 700                             expr->value.ival= $1;
 701                             $$= expr;
 702                         }
 703                 |       KeyName
 704                         {
 705                             ExprDef *expr;
 706                             expr= ExprCreate(ExprValue,TypeKeyName);
 707                             memset(expr->value.keyName,0,5);
 708                             strncpy(expr->value.keyName,$1,4);
 709                             free($1);
 710                             $$= expr;
 711                         }
 712                 ;
 713
 714 OptKeySymList   :       KeySymList                      { $$= $1; }
 715                 |                                       { $$= NULL; }
 716                 ;
 717
 718 KeySymList      :       KeySymList COMMA KeySym
 719                         { $$= AppendKeysymList($1,(KeySym)$3); }
 720                 |       KeySym
 721                         { $$= CreateKeysymList((KeySym)$1); }
 722                 ;
 723
 724 KeySym          :       IDENT
 725                         {
 726                             KeySym sym;
 727                             if (LookupKeysym(scanStr,&sym))
 728                                 $$= sym;
 729                             else {
 730                                 char buf[120];
 731                                 snprintf(buf, sizeof(buf),
 732                                          "expected keysym, got %s",
 733                                          uStringText(scanStr));
 734                                 yyerror(buf);
 735                                 yynerrs++;
 736                                 $$= NoSymbol;
 737                             }
 738                         }
 739                 |       SECTION
 740                         {
 741                             $$= XK_section;
 742                         }
 743                 |       Integer
 744                         {
 745                             if ($1<10)  $$= $1+'0';     /* XK_0 .. XK_9 */
 746                             else        $$= $1;
 747                         }
 748                 ;
 749
 750 SignedNumber    :       MINUS Number    { $$= -$2; }
 751                 |       Number              { $$= $1; }
 752                 ;
 753
 754 Number          :       FLOAT           { $$= scanInt; }
 755                 |       INTEGER         { $$= scanInt*XkbGeomPtsPerMM; }
 756                 ;
 757
 758 Float           :       FLOAT           { $$= scanInt; }
 759                 ;
 760
 761 Integer         :       INTEGER         { $$= scanInt; }
 762                 ;
 763
 764 KeyName         :       KEYNAME         { $$= scanStr; scanStr= NULL; }
 765                 ;
 766
 767 Ident           :       IDENT   { $$= XkbInternAtom(NULL,scanStr,False); }
 768                 |       DEFAULT { $$= XkbInternAtom(NULL,"default",False); }
 769                 ;
 770
 771 String          :       STRING  { $$= XkbInternAtom(NULL,scanStr,False); }
 772                 ;
 773
 774 OptMapName      :       MapName { $$= $1; }
 775                 |               { $$= NULL; }
 776                 ;
 777
 778 MapName         :       STRING  { $$= scanStr; scanStr= NULL; }
 779                 ;
 780 %%
 781 void
 782 yyerror(const char *s)
 783 {
 784     if (warningLevel>0) {
 785         (void)fprintf(stderr,"%s: line %d of %s\n",s,lineNum,
 786                                         (scanFile?scanFile:"(unknown)"));
 787         if ((scanStr)&&(warningLevel>3))
 788             (void)fprintf(stderr,"last scanned symbol is: %s\n",scanStr);
 789     }
 790     return;
 791 }
 792
 793
 794 int
 795 yywrap(void)
 796 {
 797    return 1;
 798 }
 799