xkbcomp/xkbparse.c

   1 /* A Bison parser, made by GNU Bison 2.3.  */
   2
   3 /* Skeleton implementation for Bison's Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   6    Free Software Foundation, Inc.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 /* As a special exception, you may create a larger work that contains
  24    part or all of the Bison parser skeleton and distribute that work
  25    under terms of your choice, so long as that work isn't itself a
  26    parser generator using the skeleton or a modified version thereof
  27    as a parser skeleton.  Alternatively, if you modify or redistribute
  28    the parser skeleton itself, you may (at your option) remove this
  29    special exception, which will cause the skeleton and the resulting
  30    Bison output files to be licensed under the GNU General Public
  31    License without this special exception.
  32
  33    This special exception was added by the Free Software Foundation in
  34    version 2.2 of Bison.  */
  35
  36 /* C LALR(1) parser skeleton written by Richard Stallman, by
  37    simplifying the original so-called "semantic" parser.  */
  38
  39 /* All symbols defined below should begin with yy or YY, to avoid
  40    infringing on user name space.  This should be done even for local
  41    variables, as they might otherwise be expanded by user macros.
  42    There are some unavoidable exceptions within include files to
  43    define necessary library symbols; they are noted "INFRINGES ON
  44    USER NAME SPACE" below.  */
  45
  46 /* Identify Bison output.  */
  47 #define YYBISON 1
  48
  49 /* Bison version.  */
  50 #define YYBISON_VERSION "2.3"
  51
  52 /* Skeleton name.  */
  53 #define YYSKELETON_NAME "yacc.c"
  54
  55 /* Pure parsers.  */
  56 #define YYPURE 0
  57
  58 /* Using locations.  */
  59 #define YYLSP_NEEDED 0
  60
  61
  62
  63 /* Tokens.  */
  64 #ifndef YYTOKENTYPE
  65 # define YYTOKENTYPE
  66    /* Put the tokens into the symbol table, so that GDB and other debuggers
  67       know about them.  */
  68    enum yytokentype {
  69      END_OF_FILE = 0,
  70      ERROR_TOK = 255,
  71      XKB_KEYMAP = 1,
  72      XKB_KEYCODES = 2,
  73      XKB_TYPES = 3,
  74      XKB_SYMBOLS = 4,
  75      XKB_COMPATMAP = 5,
  76      XKB_GEOMETRY = 6,
  77      XKB_SEMANTICS = 7,
  78      XKB_LAYOUT = 8,
  79      INCLUDE = 10,
  80      OVERRIDE = 11,
  81      AUGMENT = 12,
  82      REPLACE = 13,
  83      ALTERNATE = 14,
  84      VIRTUAL_MODS = 20,
  85      TYPE = 21,
  86      INTERPRET = 22,
  87      ACTION_TOK = 23,
  88      KEY = 24,
  89      ALIAS = 25,
  90      GROUP = 26,
  91      MODIFIER_MAP = 27,
  92      INDICATOR = 28,
  93      SHAPE = 29,
  94      KEYS = 30,
  95      ROW = 31,
  96      SECTION = 32,
  97      OVERLAY = 33,
  98      TEXT = 34,
  99      OUTLINE = 35,
 100      SOLID = 36,
 101      LOGO = 37,
 102      VIRTUAL = 38,
 103      EQUALS = 40,
 104      PLUS = 41,
 105      MINUS = 42,
 106      DIVIDE = 43,
 107      TIMES = 44,
 108      OBRACE = 45,
 109      CBRACE = 46,
 110      OPAREN = 47,
 111      CPAREN = 48,
 112      OBRACKET = 49,
 113      CBRACKET = 50,
 114      DOT = 51,
 115      COMMA = 52,
 116      SEMI = 53,
 117      EXCLAM = 54,
 118      INVERT = 55,
 119      STRING = 60,
 120      INTEGER = 61,
 121      FLOAT = 62,
 122      IDENT = 63,
 123      KEYNAME = 64,
 124      PARTIAL = 70,
 125      DEFAULT = 71,
 126      HIDDEN = 72,
 127      ALPHANUMERIC_KEYS = 73,
 128      MODIFIER_KEYS = 74,
 129      KEYPAD_KEYS = 75,
 130      FUNCTION_KEYS = 76,
 131      ALTERNATE_GROUP = 77
 132    };
 133 #endif
 134 /* Tokens.  */
 135 #define END_OF_FILE 0
 136 #define ERROR_TOK 255
 137 #define XKB_KEYMAP 1
 138 #define XKB_KEYCODES 2
 139 #define XKB_TYPES 3
 140 #define XKB_SYMBOLS 4
 141 #define XKB_COMPATMAP 5
 142 #define XKB_GEOMETRY 6
 143 #define XKB_SEMANTICS 7
 144 #define XKB_LAYOUT 8
 145 #define INCLUDE 10
 146 #define OVERRIDE 11
 147 #define AUGMENT 12
 148 #define REPLACE 13
 149 #define ALTERNATE 14
 150 #define VIRTUAL_MODS 20
 151 #define TYPE 21
 152 #define INTERPRET 22
 153 #define ACTION_TOK 23
 154 #define KEY 24
 155 #define ALIAS 25
 156 #define GROUP 26
 157 #define MODIFIER_MAP 27
 158 #define INDICATOR 28
 159 #define SHAPE 29
 160 #define KEYS 30
 161 #define ROW 31
 162 #define SECTION 32
 163 #define OVERLAY 33
 164 #define TEXT 34
 165 #define OUTLINE 35
 166 #define SOLID 36
 167 #define LOGO 37
 168 #define VIRTUAL 38
 169 #define EQUALS 40
 170 #define PLUS 41
 171 #define MINUS 42
 172 #define DIVIDE 43
 173 #define TIMES 44
 174 #define OBRACE 45
 175 #define CBRACE 46
 176 #define OPAREN 47
 177 #define CPAREN 48
 178 #define OBRACKET 49
 179 #define CBRACKET 50
 180 #define DOT 51
 181 #define COMMA 52
 182 #define SEMI 53
 183 #define EXCLAM 54
 184 #define INVERT 55
 185 #define STRING 60
 186 #define INTEGER 61
 187 #define FLOAT 62
 188 #define IDENT 63
 189 #define KEYNAME 64
 190 #define PARTIAL 70
 191 #define DEFAULT 71
 192 #define HIDDEN 72
 193 #define ALPHANUMERIC_KEYS 73
 194 #define MODIFIER_KEYS 74
 195 #define KEYPAD_KEYS 75
 196 #define FUNCTION_KEYS 76
 197 #define ALTERNATE_GROUP 77
 198
 199
 200
 201
 202 /* Copy the first part of user declarations.  */
 203 #line 91 "xkbparse.y"
 204
 205 #ifdef DEBUG
 206 #define YYDEBUG 1
 207 #endif
 208 #define DEBUG_VAR parseDebug
 209 #include "parseutils.h"
 210 #include <X11/keysym.h>
 211 #include <X11/extensions/XKBgeom.h>
 212 #include <stdlib.h>
 213
 214 unsigned int parseDebug;
 215
 216
 217
 218 /* Enabling traces.  */
 219 #ifndef YYDEBUG
 220 # define YYDEBUG 0
 221 #endif
 222
 223 /* Enabling verbose error messages.  */
 224 #ifdef YYERROR_VERBOSE
 225 # undef YYERROR_VERBOSE
 226 # define YYERROR_VERBOSE 1
 227 #else
 228 # define YYERROR_VERBOSE 0
 229 #endif
 230
 231 /* Enabling the token table.  */
 232 #ifndef YYTOKEN_TABLE
 233 # define YYTOKEN_TABLE 0
 234 #endif
 235
 236 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 237 typedef union YYSTYPE
 238 #line 110 "xkbparse.y"
 239 {
 240         int              ival;
 241         unsigned         uval;
 242         char            *str;
 243         Atom            sval;
 244         ParseCommon     *any;
 245         ExprDef         *expr;
 246         VarDef          *var;
 247         VModDef         *vmod;
 248         InterpDef       *interp;
 249         KeyTypeDef      *keyType;
 250         SymbolsDef      *syms;
 251         ModMapDef       *modMask;
 252         GroupCompatDef  *groupCompat;
 253         IndicatorMapDef *ledMap;
 254         IndicatorNameDef *ledName;
 255         KeycodeDef      *keyName;
 256         KeyAliasDef     *keyAlias;
 257         ShapeDef        *shape;
 258         SectionDef      *section;
 259         RowDef          *row;
 260         KeyDef          *key;
 261         OverlayDef      *overlay;
 262         OverlayKeyDef   *olKey;
 263         OutlineDef      *outline;
 264         DoodadDef       *doodad;
 265         XkbFile         *file;
 266 }
 267 /* Line 187 of yacc.c.  */
 268 #line 269 "xkbparse.c"
 269         YYSTYPE;
 270 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 271 # define YYSTYPE_IS_DECLARED 1
 272 # define YYSTYPE_IS_TRIVIAL 1
 273 #endif
 274
 275
 276
 277 /* Copy the second part of user declarations.  */
 278
 279
 280 /* Line 216 of yacc.c.  */
 281 #line 282 "xkbparse.c"
 282
 283 #ifdef short
 284 # undef short
 285 #endif
 286
 287 #ifdef YYTYPE_UINT8
 288 typedef YYTYPE_UINT8 yytype_uint8;
 289 #else
 290 typedef unsigned char yytype_uint8;
 291 #endif
 292
 293 #ifdef YYTYPE_INT8
 294 typedef YYTYPE_INT8 yytype_int8;
 295 #elif (defined __STDC__ || defined __C99__FUNC__ \
 296      || defined __cplusplus || defined _MSC_VER)
 297 typedef signed char yytype_int8;
 298 #else
 299 typedef short int yytype_int8;
 300 #endif
 301
 302 #ifdef YYTYPE_UINT16
 303 typedef YYTYPE_UINT16 yytype_uint16;
 304 #else
 305 typedef unsigned short int yytype_uint16;
 306 #endif
 307
 308 #ifdef YYTYPE_INT16
 309 typedef YYTYPE_INT16 yytype_int16;
 310 #else
 311 typedef short int yytype_int16;
 312 #endif
 313
 314 #ifndef YYSIZE_T
 315 # ifdef __SIZE_TYPE__
 316 #  define YYSIZE_T __SIZE_TYPE__
 317 # elif defined size_t
 318 #  define YYSIZE_T size_t
 319 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 320      || defined __cplusplus || defined _MSC_VER)
 321 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 322 #  define YYSIZE_T size_t
 323 # else
 324 #  define YYSIZE_T unsigned int
 325 # endif
 326 #endif
 327
 328 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 329
 330 #ifndef YY_
 331 # if YYENABLE_NLS
 332 #  if ENABLE_NLS
 333 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 334 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 335 #  endif
 336 # endif
 337 # ifndef YY_
 338 #  define YY_(msgid) msgid
 339 # endif
 340 #endif
 341
 342 /* Suppress unused-variable warnings by "using" E.  */
 343 #if ! defined lint || defined __GNUC__
 344 # define YYUSE(e) ((void) (e))
 345 #else
 346 # define YYUSE(e) /* empty */
 347 #endif
 348
 349 /* Identity function, used to suppress warnings about constant conditions.  */
 350 #ifndef lint
 351 # define YYID(n) (n)
 352 #else
 353 #if (defined __STDC__ || defined __C99__FUNC__ \
 354      || defined __cplusplus || defined _MSC_VER)
 355 static int
 356 YYID (int i)
 357 #else
 358 static int
 359 YYID (i)
 360     int i;
 361 #endif
 362 {
 363   return i;
 364 }
 365 #endif
 366
 367 #if ! defined yyoverflow || YYERROR_VERBOSE
 368
 369 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 370
 371 # ifdef YYSTACK_USE_ALLOCA
 372 #  if YYSTACK_USE_ALLOCA
 373 #   ifdef __GNUC__
 374 #    define YYSTACK_ALLOC __builtin_alloca
 375 #   elif defined __BUILTIN_VA_ARG_INCR
 376 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 377 #   elif defined _AIX
 378 #    define YYSTACK_ALLOC __alloca
 379 #   elif defined _MSC_VER
 380 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 381 #    define alloca _alloca
 382 #   else
 383 #    define YYSTACK_ALLOC alloca
 384 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 385      || defined __cplusplus || defined _MSC_VER)
 386 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 387 #     ifndef _STDLIB_H
 388 #      define _STDLIB_H 1
 389 #     endif
 390 #    endif
 391 #   endif
 392 #  endif
 393 # endif
 394
 395 # ifdef YYSTACK_ALLOC
 396    /* Pacify GCC's `empty if-body' warning.  */
 397 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 398 #  ifndef YYSTACK_ALLOC_MAXIMUM
 399     /* The OS might guarantee only one guard page at the bottom of the stack,
 400        and a page size can be as small as 4096 bytes.  So we cannot safely
 401        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 402        to allow for a few compiler-allocated temporary stack slots.  */
 403 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 404 #  endif
 405 # else
 406 #  define YYSTACK_ALLOC YYMALLOC
 407 #  define YYSTACK_FREE YYFREE
 408 #  ifndef YYSTACK_ALLOC_MAXIMUM
 409 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 410 #  endif
 411 #  if (defined __cplusplus && ! defined _STDLIB_H \
 412        && ! ((defined YYMALLOC || defined malloc) \
 413              && (defined YYFREE || defined free)))
 414 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 415 #   ifndef _STDLIB_H
 416 #    define _STDLIB_H 1
 417 #   endif
 418 #  endif
 419 #  ifndef YYMALLOC
 420 #   define YYMALLOC malloc
 421 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 422      || defined __cplusplus || defined _MSC_VER)
 423 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 424 #   endif
 425 #  endif
 426 #  ifndef YYFREE
 427 #   define YYFREE free
 428 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 429      || defined __cplusplus || defined _MSC_VER)
 430 void free (void *); /* INFRINGES ON USER NAME SPACE */
 431 #   endif
 432 #  endif
 433 # endif
 434 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 435
 436
 437 #if (! defined yyoverflow \
 438      && (! defined __cplusplus \
 439          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 440
 441 /* A type that is properly aligned for any stack member.  */
 442 union yyalloc
 443 {
 444   yytype_int16 yyss;
 445   YYSTYPE yyvs;
 446   };
 447
 448 /* The size of the maximum gap between one aligned stack and the next.  */
 449 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 450
 451 /* The size of an array large to enough to hold all stacks, each with
 452    N elements.  */
 453 # define YYSTACK_BYTES(N) \
 454      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 455       + YYSTACK_GAP_MAXIMUM)
 456
 457 /* Copy COUNT objects from FROM to TO.  The source and destination do
 458    not overlap.  */
 459 # ifndef YYCOPY
 460 #  if defined __GNUC__ && 1 < __GNUC__
 461 #   define YYCOPY(To, From, Count) \
 462       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 463 #  else
 464 #   define YYCOPY(To, From, Count)              \
 465       do                                        \
 466         {                                       \
 467           YYSIZE_T yyi;                         \
 468           for (yyi = 0; yyi < (Count); yyi++)   \
 469             (To)[yyi] = (From)[yyi];            \
 470         }                                       \
 471       while (YYID (0))
 472 #  endif
 473 # endif
 474
 475 /* Relocate STACK from its old location to the new one.  The
 476    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 477    elements in the stack, and YYPTR gives the new location of the
 478    stack.  Advance YYPTR to a properly aligned location for the next
 479    stack.  */
 480 # define YYSTACK_RELOCATE(Stack)                                        \
 481     do                                                                  \
 482       {                                                                 \
 483         YYSIZE_T yynewbytes;                                            \
 484         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 485         Stack = &yyptr->Stack;                                          \
 486         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 487         yyptr += yynewbytes / sizeof (*yyptr);                          \
 488       }                                                                 \
 489     while (YYID (0))
 490
 491 #endif
 492
 493 /* YYFINAL -- State number of the termination state.  */
 494 #define YYFINAL  18
 495 /* YYLAST -- Last index in YYTABLE.  */
 496 #define YYLAST   706
 497
 498 /* YYNTOKENS -- Number of terminals.  */
 499 #define YYNTOKENS  65
 500 /* YYNNTS -- Number of nonterminals.  */
 501 #define YYNNTS  73
 502 /* YYNRULES -- Number of rules.  */
 503 #define YYNRULES  184
 504 /* YYNRULES -- Number of states.  */
 505 #define YYNSTATES  335
 506
 507 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 508 #define YYUNDEFTOK  2
 509 #define YYMAXUTOK   257
 510
 511 #define YYTRANSLATE(YYX)                                                \
 512   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 513
 514 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 515 static const yytype_uint8 yytranslate[] =
 516 {
 517        0,     4,     5,     6,     7,     8,     9,    10,    11,     2,
 518       12,    13,    14,    15,    16,     2,     2,     2,     2,     2,
 519       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
 520       27,    28,    29,    30,    31,    32,    33,    34,    35,     2,
 521       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
 522       46,    47,    48,    49,    50,    51,     2,     2,     2,     2,
 523       52,    53,    54,    55,    56,     2,     2,     2,     2,     2,
 524       57,    58,    59,    60,    61,    62,    63,    64,     2,     2,
 525        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 526        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 527        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 528        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 529        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 530        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 531        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 532        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 533        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 534        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 535        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 536        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 537        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 538        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 539        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 540        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 541        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 542        2,     2,     2,     2,     2,     3,     1,     2
 543 };
 544
 545 #if YYDEBUG
 546 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 547    YYRHS.  */
 548 static const yytype_uint16 yyprhs[] =
 549 {
 550        0,     0,     3,     5,     7,     9,    12,    14,    22,    24,
 551       26,    28,    31,    33,    41,    46,    48,    50,    52,    54,
 552       56,    58,    59,    62,    64,    66,    68,    70,    72,    74,
 553       76,    78,    80,    83,    84,    87,    90,    93,    96,    99,
 554      102,   105,   108,   111,   114,   117,   120,   123,   126,   129,
 555      134,   137,   141,   146,   152,   156,   160,   162,   164,   168,
 556      175,   179,   181,   184,   186,   193,   200,   204,   206,   207,
 557      211,   215,   217,   220,   222,   226,   230,   236,   243,   250,
 558      256,   263,   270,   277,   284,   287,   289,   295,   297,   299,
 559      301,   303,   306,   308,   314,   316,   320,   322,   324,   328,
 560      335,   339,   341,   345,   349,   351,   355,   361,   365,   369,
 561      371,   377,   384,   386,   388,   390,   392,   394,   396,   398,
 562      400,   402,   404,   406,   408,   410,   412,   414,   416,   418,
 563      420,   421,   423,   425,   427,   429,   431,   433,   434,   438,
 564      440,   444,   448,   452,   456,   460,   462,   465,   468,   471,
 565      474,   476,   481,   483,   487,   491,   493,   498,   500,   504,
 566      509,   516,   518,   520,   522,   524,   526,   527,   531,   533,
 567      535,   537,   539,   542,   544,   546,   548,   550,   552,   554,
 568      556,   558,   560,   562,   563
 569 };
 570
 571 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 572 static const yytype_int16 yyrhs[] =
 573 {
 574       66,     0,    -1,    67,    -1,    70,    -1,    72,    -1,    67,
 575       68,    -1,    68,    -1,    74,    69,   136,    41,    70,    42,
 576       49,    -1,     4,    -1,    10,    -1,    11,    -1,    70,    71,
 577       -1,    71,    -1,    74,    73,   136,    41,    77,    42,    49,
 578       -1,    74,    73,   136,    77,    -1,     5,    -1,     6,    -1,
 579        8,    -1,     7,    -1,     9,    -1,    75,    -1,    -1,    75,
 580       76,    -1,    76,    -1,    57,    -1,    58,    -1,    59,    -1,
 581       60,    -1,    61,    -1,    62,    -1,    63,    -1,    64,    -1,
 582       77,    78,    -1,    -1,   116,    79,    -1,   116,    82,    -1,
 583      116,    85,    -1,   116,    80,    -1,   116,    81,    -1,   116,
 584       88,    -1,   116,    89,    -1,   116,    94,    -1,   116,    93,
 585       -1,   116,    95,    -1,   116,    96,    -1,   116,    97,    -1,
 586      116,    98,    -1,   116,   112,    -1,   117,    52,    -1,   124,
 587       36,   120,    49,    -1,   134,    49,    -1,    50,   134,    49,
 588       -1,   133,    36,   120,    49,    -1,    22,   133,    36,   133,
 589       49,    -1,    17,    83,    49,    -1,    83,    48,    84,    -1,
 590       84,    -1,   134,    -1,   134,    36,   120,    -1,    19,    86,
 591       41,    87,    42,    49,    -1,   128,    37,   120,    -1,   128,
 592       -1,    87,    79,    -1,    79,    -1,    18,   135,    41,    87,
 593       42,    49,    -1,    21,   133,    41,    90,    42,    49,    -1,
 594       90,    48,    91,    -1,    91,    -1,    -1,   124,    36,   120,
 595       -1,   124,    36,    92,    -1,   134,    -1,    50,   134,    -1,
 596       92,    -1,    45,   126,    46,    -1,    45,   122,    46,    -1,
 597       23,   132,    36,   120,    49,    -1,    24,   134,    41,   119,
 598       42,    49,    -1,    25,   135,    41,    87,    42,    49,    -1,
 599       25,   132,    36,   120,    49,    -1,    35,    25,   132,    36,
 600      120,    49,    -1,    26,   135,    41,   108,    42,    49,    -1,
 601       26,   135,    41,   110,    42,    49,    -1,    29,   135,    41,
 602       99,    42,    49,    -1,    99,   100,    -1,   100,    -1,    28,
 603       41,   101,    42,    49,    -1,    79,    -1,   112,    -1,    95,
 604       -1,   105,    -1,   101,   102,    -1,   102,    -1,    27,    41,
 605      103,    42,    49,    -1,    79,    -1,   103,    48,   104,    -1,
 606      104,    -1,   133,    -1,    41,   119,    42,    -1,    30,   135,
 607       41,   106,    42,    49,    -1,   106,    48,   107,    -1,   107,
 608       -1,   133,    36,   133,    -1,   108,    48,   109,    -1,   109,
 609       -1,    41,   110,    42,    -1,   134,    36,    41,   110,    42,
 610       -1,   134,    36,   120,    -1,   110,    48,   111,    -1,   111,
 611       -1,    45,   129,    48,   129,    46,    -1,   113,   135,    41,
 612       87,    42,    49,    -1,    31,    -1,    32,    -1,    33,    -1,
 613       34,    -1,   134,    -1,   115,    -1,    20,    -1,    19,    -1,
 614       18,    -1,    21,    -1,    23,    -1,    24,    -1,    25,    -1,
 615       26,    -1,    28,    -1,    29,    -1,    31,    -1,   117,    -1,
 616       -1,    12,    -1,    14,    -1,    13,    -1,    15,    -1,    16,
 617       -1,   119,    -1,    -1,   119,    48,   120,    -1,   120,    -1,
 618      120,    39,   120,    -1,   120,    37,   120,    -1,   120,    38,
 619      120,    -1,   120,    40,   120,    -1,   124,    36,   120,    -1,
 620      121,    -1,    38,   121,    -1,    37,   121,    -1,    50,   121,
 621       -1,    51,   121,    -1,   124,    -1,   114,    43,   118,    44,
 622       -1,   125,    -1,    43,   120,    44,    -1,   122,    48,   123,
 623       -1,   123,    -1,   114,    43,   118,    44,    -1,   114,    -1,
 624      114,    47,   114,    -1,   114,    45,   120,    46,    -1,   114,
 625       47,   114,    45,   120,    46,    -1,   135,    -1,   132,    -1,
 626      131,    -1,   133,    -1,   127,    -1,    -1,   127,    48,   128,
 627       -1,   128,    -1,    55,    -1,    29,    -1,   132,    -1,    38,
 628      130,    -1,   130,    -1,    54,    -1,    53,    -1,    54,    -1,
 629       53,    -1,    56,    -1,    55,    -1,    58,    -1,    52,    -1,
 630      137,    -1,    -1,    52,    -1
 631 };
 632
 633 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 634 static const yytype_uint16 yyrline[] =
 635 {
 636        0,   168,   168,   170,   172,   176,   178,   182,   188,   189,
 637      190,   193,   195,   199,   205,   210,   211,   212,   213,   214,
 638      217,   218,   221,   222,   225,   226,   227,   228,   229,   230,
 639      231,   232,   235,   237,   240,   245,   250,   255,   260,   265,
 640      270,   275,   280,   285,   290,   295,   300,   305,   310,   322,
 641      324,   326,   330,   341,   351,   355,   357,   361,   363,   367,
 642      376,   378,   382,   384,   388,   394,   400,   402,   404,   407,
 643      409,   411,   413,   415,   419,   421,   425,   429,   433,   437,
 644      439,   443,   445,   453,   457,   459,   463,   465,   467,   469,
 645      471,   475,   477,   481,   483,   487,   489,   493,   495,   499,
 646      503,   508,   512,   516,   518,   522,   524,   526,   530,   532,
 647      536,   546,   550,   551,   552,   553,   556,   557,   560,   562,
 648      564,   566,   568,   570,   572,   574,   576,   578,   580,   584,
 649      585,   588,   589,   590,   591,   592,   595,   596,   599,   601,
 650      605,   607,   609,   611,   613,   615,   619,   621,   623,   625,
 651      627,   629,   631,   633,   637,   639,   643,   647,   654,   662,
 652      671,   682,   689,   696,   703,   714,   715,   718,   720,   724,
 653      725,   726,   733,   734,   737,   738,   741,   744,   747,   750,
 654      751,   754,   757,   758,   761
 655 };
 656 #endif
 657
 658 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 659 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 660    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 661 static const char *const yytname[] =
 662 {
 663   "END_OF_FILE", "error", "$undefined", "ERROR_TOK", "XKB_KEYMAP",
 664   "XKB_KEYCODES", "XKB_TYPES", "XKB_SYMBOLS", "XKB_COMPATMAP",
 665   "XKB_GEOMETRY", "XKB_SEMANTICS", "XKB_LAYOUT", "INCLUDE", "OVERRIDE",
 666   "AUGMENT", "REPLACE", "ALTERNATE", "VIRTUAL_MODS", "TYPE", "INTERPRET",
 667   "ACTION_TOK", "KEY", "ALIAS", "GROUP", "MODIFIER_MAP", "INDICATOR",
 668   "SHAPE", "KEYS", "ROW", "SECTION", "OVERLAY", "TEXT", "OUTLINE", "SOLID",
 669   "LOGO", "VIRTUAL", "EQUALS", "PLUS", "MINUS", "DIVIDE", "TIMES",
 670   "OBRACE", "CBRACE", "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "DOT",
 671   "COMMA", "SEMI", "EXCLAM", "INVERT", "STRING", "INTEGER", "FLOAT",
 672   "IDENT", "KEYNAME", "PARTIAL", "DEFAULT", "HIDDEN", "ALPHANUMERIC_KEYS",
 673   "MODIFIER_KEYS", "KEYPAD_KEYS", "FUNCTION_KEYS", "ALTERNATE_GROUP",
 674   "$accept", "XkbFile", "XkbCompMapList", "XkbCompositeMap",
 675   "XkbCompositeType", "XkbMapConfigList", "XkbMapConfig", "XkbConfig",
 676   "FileType", "OptFlags", "Flags", "Flag", "DeclList", "Decl", "VarDecl",
 677   "KeyNameDecl", "KeyAliasDecl", "VModDecl", "VModDefList", "VModDef",
 678   "InterpretDecl", "InterpretMatch", "VarDeclList", "KeyTypeDecl",
 679   "SymbolsDecl", "SymbolsBody", "SymbolsVarDecl", "ArrayInit",
 680   "GroupCompatDecl", "ModMapDecl", "IndicatorMapDecl", "IndicatorNameDecl",
 681   "ShapeDecl", "SectionDecl", "SectionBody", "SectionBodyItem", "RowBody",
 682   "RowBodyItem", "Keys", "Key", "OverlayDecl", "OverlayKeyList",
 683   "OverlayKey", "OutlineList", "OutlineInList", "CoordList", "Coord",
 684   "DoodadDecl", "DoodadType", "FieldSpec", "Element", "OptMergeMode",
 685   "MergeMode", "OptExprList", "ExprList", "Expr", "Term", "ActionList",
 686   "Action", "Lhs", "Terminal", "OptKeySymList", "KeySymList", "KeySym",
 687   "SignedNumber", "Number", "Float", "Integer", "KeyName", "Ident",
 688   "String", "OptMapName", "MapName", 0
 689 };
 690 #endif
 691
 692 # ifdef YYPRINT
 693 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 694    token YYLEX-NUM.  */
 695 static const yytype_uint16 yytoknum[] =
 696 {
 697        0,   256,   257,   255,     1,     2,     3,     4,     5,     6,
 698        7,     8,    10,    11,    12,    13,    14,    20,    21,    22,
 699       23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
 700       33,    34,    35,    36,    37,    38,    40,    41,    42,    43,
 701       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
 702       54,    55,    60,    61,    62,    63,    64,    70,    71,    72,
 703       73,    74,    75,    76,    77
 704 };
 705 # endif
 706
 707 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 708 static const yytype_uint8 yyr1[] =
 709 {
 710        0,    65,    66,    66,    66,    67,    67,    68,    69,    69,
 711       69,    70,    70,    71,    72,    73,    73,    73,    73,    73,
 712       74,    74,    75,    75,    76,    76,    76,    76,    76,    76,
 713       76,    76,    77,    77,    78,    78,    78,    78,    78,    78,
 714       78,    78,    78,    78,    78,    78,    78,    78,    78,    79,
 715       79,    79,    80,    81,    82,    83,    83,    84,    84,    85,
 716       86,    86,    87,    87,    88,    89,    90,    90,    90,    91,
 717       91,    91,    91,    91,    92,    92,    93,    94,    95,    96,
 718       96,    97,    97,    98,    99,    99,   100,   100,   100,   100,
 719      100,   101,   101,   102,   102,   103,   103,   104,   104,   105,
 720      106,   106,   107,   108,   108,   109,   109,   109,   110,   110,
 721      111,   112,   113,   113,   113,   113,   114,   114,   115,   115,
 722      115,   115,   115,   115,   115,   115,   115,   115,   115,   116,
 723      116,   117,   117,   117,   117,   117,   118,   118,   119,   119,
 724      120,   120,   120,   120,   120,   120,   121,   121,   121,   121,
 725      121,   121,   121,   121,   122,   122,   123,   124,   124,   124,
 726      124,   125,   125,   125,   125,   126,   126,   127,   127,   128,
 727      128,   128,   129,   129,   130,   130,   131,   132,   133,   134,
 728      134,   135,   136,   136,   137
 729 };
 730
 731 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 732 static const yytype_uint8 yyr2[] =
 733 {
 734        0,     2,     1,     1,     1,     2,     1,     7,     1,     1,
 735        1,     2,     1,     7,     4,     1,     1,     1,     1,     1,
 736        1,     0,     2,     1,     1,     1,     1,     1,     1,     1,
 737        1,     1,     2,     0,     2,     2,     2,     2,     2,     2,
 738        2,     2,     2,     2,     2,     2,     2,     2,     2,     4,
 739        2,     3,     4,     5,     3,     3,     1,     1,     3,     6,
 740        3,     1,     2,     1,     6,     6,     3,     1,     0,     3,
 741        3,     1,     2,     1,     3,     3,     5,     6,     6,     5,
 742        6,     6,     6,     6,     2,     1,     5,     1,     1,     1,
 743        1,     2,     1,     5,     1,     3,     1,     1,     3,     6,
 744        3,     1,     3,     3,     1,     3,     5,     3,     3,     1,
 745        5,     6,     1,     1,     1,     1,     1,     1,     1,     1,
 746        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
 747        0,     1,     1,     1,     1,     1,     1,     0,     3,     1,
 748        3,     3,     3,     3,     3,     1,     2,     2,     2,     2,
 749        1,     4,     1,     3,     3,     1,     4,     1,     3,     4,
 750        6,     1,     1,     1,     1,     1,     0,     3,     1,     1,
 751        1,     1,     2,     1,     1,     1,     1,     1,     1,     1,
 752        1,     1,     1,     0,     1
 753 };
 754
 755 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 756    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 757    means the default is an error.  */
 758 static const yytype_uint8 yydefact[] =
 759 {
 760       21,    24,    25,    26,    27,    28,    29,    30,    31,     0,
 761       21,     6,    21,    12,     4,     0,    20,    23,     1,     5,
 762        0,    11,     0,     8,    15,    16,    18,    17,    19,     9,
 763       10,   183,   183,    22,   183,   184,     0,   182,    33,     0,
 764       21,    33,   130,    21,   130,   131,   133,   132,   134,   135,
 765       32,     0,   129,     0,     0,     0,   120,   119,   118,   121,
 766        0,   122,   123,   124,   125,   126,   127,   128,   113,   114,
 767      115,     0,     0,   179,   178,   180,    34,    37,    38,    35,
 768       36,    39,    40,    42,    41,    43,    44,    45,    46,    47,
 769        0,   157,   117,     0,     0,   116,    48,     7,    13,     0,
 770       56,    57,   181,     0,   170,   177,   169,     0,    61,   171,
 771        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 772        0,     0,     0,     0,     0,    50,     0,    54,     0,     0,
 773        0,     0,    68,     0,     0,     0,     0,     0,     0,     0,
 774        0,    51,     0,   120,   119,   121,   122,   123,   124,   125,
 775      127,   128,     0,     0,     0,     0,     0,   176,   157,     0,
 776      145,   150,   152,   163,   162,   164,   116,   161,   158,     0,
 777        0,    55,    58,    63,     0,     0,    60,   166,     0,     0,
 778       67,    73,     0,   116,     0,     0,     0,   139,     0,     0,
 779        0,     0,     0,   104,     0,   109,     0,   124,   126,     0,
 780       87,    89,     0,    85,    90,    88,     0,     0,   147,   150,
 781      146,     0,   148,   149,   137,     0,     0,     0,     0,   159,
 782        0,     0,    49,    52,     0,    62,     0,   170,   169,     0,
 783        0,   155,     0,   165,   168,    72,     0,     0,     0,    53,
 784       76,     0,     0,    79,     0,     0,     0,   175,   174,     0,
 785      173,     0,     0,     0,     0,     0,     0,     0,     0,    84,
 786        0,     0,   153,     0,   136,   141,   142,   140,   143,   144,
 787        0,    64,    59,   137,    75,     0,    74,     0,    65,    66,
 788       70,    69,    77,   138,    78,   105,   172,     0,    81,   103,
 789       82,   108,     0,   107,     0,    94,     0,    92,     0,    83,
 790       80,   111,   151,   160,     0,   154,   167,     0,     0,     0,
 791        0,    91,     0,   101,     0,   156,   110,   106,     0,     0,
 792       96,    97,    86,     0,     0,     0,     0,     0,     0,    99,
 793      100,   102,    98,    93,    95
 794 };
 795
 796 /* YYDEFGOTO[NTERM-NUM].  */
 797 static const yytype_int16 yydefgoto[] =
 798 {
 799       -1,     9,    10,    11,    31,    12,    13,    14,    32,    22,
 800       16,    17,    42,    50,   173,    77,    78,    79,    99,   100,
 801       80,   107,   174,    81,    82,   179,   180,   181,    83,    84,
 802      201,    86,    87,    88,   202,   203,   296,   297,   319,   320,
 803      204,   312,   313,   192,   193,   194,   195,   205,    90,   158,
 804       92,    51,    52,   263,   264,   187,   160,   230,   231,   161,
 805      162,   232,   233,   108,   249,   250,   163,   164,   165,   166,
 806      167,    36,    37
 807 };
 808
 809 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 810    STATE-NUM.  */
 811 #define YYPACT_NINF -188
 812 static const yytype_int16 yypact[] =
 813 {
 814      628,  -188,  -188,  -188,  -188,  -188,  -188,  -188,  -188,    12,
 815        4,  -188,    58,  -188,  -188,   695,   628,  -188,  -188,  -188,
 816      121,  -188,   408,  -188,  -188,  -188,  -188,  -188,  -188,  -188,
 817     -188,    -9,    -9,  -188,    -9,  -188,    19,  -188,    45,    45,
 818      628,  -188,   174,   620,   137,  -188,  -188,  -188,  -188,  -188,
 819     -188,   317,    39,   -15,    50,     1,    59,   -18,  -188,    72,
 820       72,   106,     1,   -27,    59,  -188,    59,    62,  -188,  -188,
 821     -188,   117,     1,  -188,  -188,  -188,  -188,  -188,  -188,  -188,
 822     -188,  -188,  -188,  -188,  -188,  -188,  -188,  -188,  -188,  -188,
 823       59,    51,  -188,   125,   146,   134,  -188,  -188,  -188,   132,
 824     -188,   163,  -188,   168,  -188,  -188,  -188,   173,   179,  -188,
 825      178,   186,   190,   194,   206,   204,   208,   221,   106,   216,
 826      225,   265,   640,   265,   265,  -188,     1,  -188,   265,   599,
 827      599,   265,   470,    72,   265,   265,   265,   599,   -26,    21,
 828      239,  -188,   599,  -188,  -188,  -188,  -188,  -188,  -188,  -188,
 829     -188,  -188,   265,   265,   265,   265,   265,  -188,   159,   232,
 830     -188,   240,  -188,  -188,  -188,  -188,  -188,  -188,   223,    98,
 831      156,  -188,   260,  -188,   485,   513,   260,   617,     1,    30,
 832     -188,  -188,   243,    32,   231,   192,    64,   260,   199,   528,
 833      236,    35,   127,  -188,   128,  -188,   251,    59,   270,    59,
 834     -188,  -188,   422,  -188,  -188,  -188,   265,   556,  -188,  -188,
 835     -188,   342,  -188,  -188,   265,   265,   265,   265,   265,  -188,
 836      265,   265,  -188,  -188,   263,  -188,   264,   249,   271,   281,
 837       61,  -188,   279,   278,  -188,  -188,   280,   470,   340,  -188,
 838     -188,   283,   265,  -188,   284,   129,    16,  -188,  -188,   282,
 839     -188,   298,   -34,   308,   236,   381,   576,   287,   321,  -188,
 840      215,   325,  -188,   332,   336,   158,   158,  -188,  -188,   260,
 841      316,  -188,  -188,   265,  -188,   640,  -188,   -18,  -188,  -188,
 842     -188,   260,  -188,   260,  -188,  -188,  -188,    35,  -188,  -188,
 843     -188,  -188,   236,   260,   346,  -188,   442,  -188,    72,  -188,
 844     -188,  -188,  -188,  -188,   344,  -188,  -188,   343,   143,   -28,
 845      348,  -188,   176,  -188,   367,  -188,  -188,  -188,   265,   198,
 846     -188,  -188,  -188,   359,    72,    72,   202,   362,   -28,  -188,
 847     -188,  -188,  -188,  -188,  -188
 848 };
 849
 850 /* YYPGOTO[NTERM-NUM].  */
 851 static const yytype_int16 yypgoto[] =
 852 {
 853     -188,  -188,  -188,   410,  -188,   383,    -7,  -188,   399,    38,
 854     -188,   409,   385,  -188,   -35,  -188,  -188,  -188,  -188,   301,
 855     -188,  -188,   -47,  -188,  -188,  -188,   191,   200,  -188,  -188,
 856      378,  -188,  -188,  -188,  -188,   228,  -188,   148,  -188,   130,
 857     -188,  -188,   133,  -188,   197,  -187,   205,   423,  -188,    26,
 858     -188,  -188,  -188,   203,  -134,    89,   104,  -188,   207,   -29,
 859     -188,  -188,  -188,  -175,   188,   233,  -188,   -43,   -51,   -45,
 860      -33,   109,  -188
 861 };
 862
 863 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 864    positive, shift that token.  If negative, reduce the rule which
 865    number is the opposite.  If zero, do what YYDEFACT says.
 866    If YYTABLE_NINF, syntax error.  */
 867 #define YYTABLE_NINF -180
 868 static const yytype_int16 yytable[] =
 869 {
 870       94,   186,   234,   245,    -2,    21,    95,   190,   110,   111,
 871      101,   104,    18,   318,   109,   190,    76,   113,   112,   191,
 872      114,    73,    93,   103,    75,   102,   105,   119,    74,    73,
 873      115,   116,    75,   117,    97,   105,    21,   106,    15,   143,
 874      144,    58,   145,    35,   146,   147,   197,   149,    20,   198,
 875      150,   199,    67,    68,    69,    70,    73,   120,    -3,    75,
 876       40,     1,     2,     3,     4,     5,     6,     7,     8,   247,
 877      248,    72,   236,   246,   -71,   140,    73,    91,   237,    75,
 878      -71,   101,   184,   175,    95,    95,    41,   183,   247,   248,
 879      189,    96,    95,   196,    95,   207,   121,    95,   122,    98,
 880       93,    93,   306,   182,   200,   308,   241,   274,    93,   275,
 881       93,   102,   242,    93,  -112,     1,     2,     3,     4,     5,
 882        6,     7,     8,   209,   209,    23,   209,   209,    74,    95,
 883       95,    29,    30,   235,   109,   215,   216,   217,   218,   225,
 884      225,    38,   118,    39,    95,    93,    93,   222,   168,    45,
 885       46,    47,    48,    49,   225,    91,    91,    95,    91,   105,
 886       93,   123,    95,    91,   115,    91,   257,   200,    91,   251,
 887      253,   285,   225,    93,   -14,   252,   254,   254,    93,    54,
 888      126,   127,   124,   125,   326,   317,    45,    46,    47,    48,
 889       49,   254,   183,   215,   216,   217,   218,   217,   218,   128,
 890       91,    91,   214,   229,   121,   223,   122,   196,   182,   129,
 891      159,    95,   169,   170,   130,    91,   131,   172,   323,   132,
 892      176,   295,   133,   185,   324,   188,   134,    93,    91,   215,
 893      216,   217,   218,    91,   109,   135,   215,   216,   217,   218,
 894      327,   240,   136,   211,   332,   137,   328,   314,   243,   138,
 895      242,    95,   215,   216,   217,   218,   208,   210,   321,   212,
 896      213,   295,   139,    91,   300,   141,   142,    93,   221,   215,
 897      216,   217,   218,   314,   331,   206,   220,   321,   219,   238,
 898      239,   191,    91,   143,   144,    58,   145,   255,   146,   147,
 899      148,   149,  -127,    65,   150,   260,   151,   215,   216,   217,
 900      218,   229,   152,   153,   265,   266,   267,   268,   154,   269,
 901      270,   256,   271,   272,  -179,   155,   156,   102,   105,   157,
 902       73,    74,    91,    75,   273,   276,   277,   281,   298,   278,
 903      287,   283,   282,   284,    55,    56,    57,    58,    59,    60,
 904       61,    62,    63,    64,   293,    65,    66,   288,    67,    68,
 905       69,    70,    71,   215,   216,   217,   218,   290,   143,   144,
 906       58,   145,   303,   146,   147,   148,   149,    72,    65,   150,
 907      299,   151,    73,    74,   301,    75,   302,   152,   153,   215,
 908      216,   217,   218,   154,   242,   177,   262,   309,   315,   316,
 909      155,   156,   102,   105,   157,    73,    74,   322,    75,   143,
 910      144,    58,   145,   325,   146,   147,   148,   149,   329,    65,
 911      150,   333,   151,    24,    25,    26,    27,    28,   152,   153,
 912       19,    34,   292,    43,   154,    33,    44,   171,   279,    85,
 913      259,   155,   156,   102,   105,   157,    73,    74,   280,    75,
 914      143,   144,    58,   145,   311,   146,   147,   197,   149,   289,
 915      198,   150,   199,    67,    68,    69,    70,   330,   334,   291,
 916      143,   144,    58,   145,   258,   146,   147,   148,   149,   294,
 917       65,   150,    72,   151,    89,   307,   304,    73,     0,   286,
 918       75,     0,   305,     0,   310,     0,     0,     0,   143,   144,
 919       58,   145,    72,   146,   147,   148,   149,    73,    65,   150,
 920       75,   151,     0,   143,   144,    58,   145,     0,   146,   147,
 921      148,   149,     0,    65,   150,   177,   151,     0,     0,     0,
 922      178,     0,     0,     0,     0,    73,     0,   224,    75,     0,
 923        0,   143,   144,    58,   145,    72,   146,   147,   148,   149,
 924       73,    65,   150,    75,   151,     0,   143,   144,    58,   145,
 925        0,   146,   147,   148,   149,   226,    65,   150,     0,   151,
 926        0,     0,     0,    72,     0,     0,     0,     0,    73,     0,
 927      244,    75,     0,     0,   143,   144,    58,   145,    72,   146,
 928      147,   148,   149,    73,    65,   150,    75,   151,     0,     0,
 929        0,     0,     0,     0,   143,   144,    58,   145,   261,   146,
 930      147,   148,   149,   294,    65,   150,    72,   151,     0,     0,
 931        0,    73,     0,     0,    75,     0,     0,   143,   144,    58,
 932      145,     0,   146,   147,   148,   149,    72,    65,   150,     0,
 933      151,    73,     0,     0,    75,   143,   144,    58,   145,     0,
 934      146,   147,   148,   149,     0,    65,   227,     0,   151,    72,
 935        0,     0,     0,     0,    73,     0,     0,    75,   143,   144,
 936       58,   145,    53,   146,   147,   148,   149,     0,    65,   150,
 937      105,   151,   228,     0,     0,    75,     0,     1,     2,     3,
 938        4,     5,     6,     7,     8,     1,     2,     3,     4,     5,
 939        6,     7,     8,     0,     0,    73,     0,     0,    75,    23,
 940       24,    25,    26,    27,    28,    29,    30
 941 };
 942
 943 static const yytype_int16 yycheck[] =
 944 {
 945       51,   135,   177,   190,     0,    12,    51,    41,    59,    60,
 946       55,    29,     0,    41,    57,    41,    51,    62,    61,    45,
 947       63,    55,    51,    56,    58,    52,    53,    72,    56,    55,
 948       63,    64,    58,    66,    49,    53,    43,    55,     0,    18,
 949       19,    20,    21,    52,    23,    24,    25,    26,    10,    28,
 950       29,    30,    31,    32,    33,    34,    55,    90,     0,    58,
 951       41,    57,    58,    59,    60,    61,    62,    63,    64,    53,
 952       54,    50,    42,    38,    42,   118,    55,    51,    48,    58,
 953       48,   126,   133,   130,   129,   130,    41,   132,    53,    54,
 954      137,    52,   137,   138,   139,   142,    45,   142,    47,    49,
 955      129,   130,   277,   132,   139,   292,    42,    46,   137,    48,
 956      139,    52,    48,   142,    52,    57,    58,    59,    60,    61,
 957       62,    63,    64,   152,   153,     4,   155,   156,    56,   174,
 958      175,    10,    11,   178,   177,    37,    38,    39,    40,   174,
 959      175,    32,    25,    34,   189,   174,   175,    49,   122,    12,
 960       13,    14,    15,    16,   189,   129,   130,   202,   132,    53,
 961      189,    36,   207,   137,   197,   139,   199,   202,   142,    42,
 962       42,    42,   207,   202,     0,    48,    48,    48,   207,    42,
 963       48,    49,    36,    49,   318,    42,    12,    13,    14,    15,
 964       16,    48,   237,    37,    38,    39,    40,    39,    40,    36,
 965      174,   175,    43,   177,    45,    49,    47,   252,   237,    41,
 966      121,   256,   123,   124,    41,   189,    37,   128,    42,    41,
 967      131,   256,    36,   134,    48,   136,    36,   256,   202,    37,
 968       38,    39,    40,   207,   277,    41,    37,    38,    39,    40,
 969       42,    49,    36,   154,    42,    41,    48,   298,    49,    41,
 970       48,   296,    37,    38,    39,    40,   152,   153,   309,   155,
 971      156,   296,    41,   237,    49,    49,    41,   296,    45,    37,
 972       38,    39,    40,   324,   325,    36,    36,   328,    46,    36,
 973       49,    45,   256,    18,    19,    20,    21,    36,    23,    24,
 974       25,    26,    43,    28,    29,   206,    31,    37,    38,    39,
 975       40,   275,    37,    38,   215,   216,   217,   218,    43,   220,
 976      221,    41,    49,    49,    43,    50,    51,    52,    53,    54,
 977       55,    56,   296,    58,    43,    46,    48,   238,    41,    49,
 978       48,   242,    49,    49,    17,    18,    19,    20,    21,    22,
 979       23,    24,    25,    26,   255,    28,    29,    49,    31,    32,
 980       33,    34,    35,    37,    38,    39,    40,    49,    18,    19,
 981       20,    21,    46,    23,    24,    25,    26,    50,    28,    29,
 982       49,    31,    55,    56,    49,    58,    44,    37,    38,    37,
 983       38,    39,    40,    43,    48,    45,    44,    41,    44,    46,
 984       50,    51,    52,    53,    54,    55,    56,    49,    58,    18,
 985       19,    20,    21,    36,    23,    24,    25,    26,    49,    28,
 986       29,    49,    31,     5,     6,     7,     8,     9,    37,    38,
 987       10,    22,    41,    40,    43,    16,    41,   126,   237,    51,
 988      202,    50,    51,    52,    53,    54,    55,    56,   238,    58,
 989       18,    19,    20,    21,   296,    23,    24,    25,    26,   252,
 990       28,    29,    30,    31,    32,    33,    34,   324,   328,   254,
 991       18,    19,    20,    21,    42,    23,    24,    25,    26,    27,
 992       28,    29,    50,    31,    51,   287,   273,    55,    -1,   246,
 993       58,    -1,   275,    -1,    42,    -1,    -1,    -1,    18,    19,
 994       20,    21,    50,    23,    24,    25,    26,    55,    28,    29,
 995       58,    31,    -1,    18,    19,    20,    21,    -1,    23,    24,
 996       25,    26,    -1,    28,    29,    45,    31,    -1,    -1,    -1,
 997       50,    -1,    -1,    -1,    -1,    55,    -1,    42,    58,    -1,
 998       -1,    18,    19,    20,    21,    50,    23,    24,    25,    26,
 999       55,    28,    29,    58,    31,    -1,    18,    19,    20,    21,
1000       -1,    23,    24,    25,    26,    42,    28,    29,    -1,    31,
1001       -1,    -1,    -1,    50,    -1,    -1,    -1,    -1,    55,    -1,
1002       42,    58,    -1,    -1,    18,    19,    20,    21,    50,    23,
1003       24,    25,    26,    55,    28,    29,    58,    31,    -1,    -1,
1004       -1,    -1,    -1,    -1,    18,    19,    20,    21,    42,    23,
1005       24,    25,    26,    27,    28,    29,    50,    31,    -1,    -1,
1006       -1,    55,    -1,    -1,    58,    -1,    -1,    18,    19,    20,
1007       21,    -1,    23,    24,    25,    26,    50,    28,    29,    -1,
1008       31,    55,    -1,    -1,    58,    18,    19,    20,    21,    -1,
1009       23,    24,    25,    26,    -1,    28,    29,    -1,    31,    50,
1010       -1,    -1,    -1,    -1,    55,    -1,    -1,    58,    18,    19,
1011       20,    21,    42,    23,    24,    25,    26,    -1,    28,    29,
1012       53,    31,    55,    -1,    -1,    58,    -1,    57,    58,    59,
1013       60,    61,    62,    63,    64,    57,    58,    59,    60,    61,
1014       62,    63,    64,    -1,    -1,    55,    -1,    -1,    58,     4,
1015        5,     6,     7,     8,     9,    10,    11
1016 };
1017
1018 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1019    symbol of state STATE-NUM.  */
1020 static const yytype_uint8 yystos[] =
1021 {
1022        0,    57,    58,    59,    60,    61,    62,    63,    64,    66,
1023       67,    68,    70,    71,    72,    74,    75,    76,     0,    68,
1024       74,    71,    74,     4,     5,     6,     7,     8,     9,    10,
1025       11,    69,    73,    76,    73,    52,   136,   137,   136,   136,
1026       41,    41,    77,    70,    77,    12,    13,    14,    15,    16,
1027       78,   116,   117,    42,    42,    17,    18,    19,    20,    21,
1028       22,    23,    24,    25,    26,    28,    29,    31,    32,    33,
1029       34,    35,    50,    55,    56,    58,    79,    80,    81,    82,
1030       85,    88,    89,    93,    94,    95,    96,    97,    98,   112,
1031      113,   114,   115,   124,   133,   134,    52,    49,    49,    83,
1032       84,   134,    52,   135,    29,    53,    55,    86,   128,   132,
1033      133,   133,   132,   134,   132,   135,   135,   135,    25,   134,
1034      135,    45,    47,    36,    36,    49,    48,    49,    36,    41,
1035       41,    37,    41,    36,    36,    41,    36,    41,    41,    41,
1036      132,    49,    41,    18,    19,    21,    23,    24,    25,    26,
1037       29,    31,    37,    38,    43,    50,    51,    54,   114,   120,
1038      121,   124,   125,   131,   132,   133,   134,   135,   114,   120,
1039      120,    84,   120,    79,    87,    87,   120,    45,    50,    90,
1040       91,    92,   124,   134,   133,   120,   119,   120,   120,    87,
1041       41,    45,   108,   109,   110,   111,   134,    25,    28,    30,
1042       79,    95,    99,   100,   105,   112,    36,    87,   121,   124,
1043      121,   120,   121,   121,    43,    37,    38,    39,    40,    46,
1044       36,    45,    49,    49,    42,    79,    42,    29,    55,   114,
1045      122,   123,   126,   127,   128,   134,    42,    48,    36,    49,
1046       49,    42,    48,    49,    42,   110,    38,    53,    54,   129,
1047      130,    42,    48,    42,    48,    36,    41,   135,    42,   100,
1048      120,    42,    44,   118,   119,   120,   120,   120,   120,   120,
1049      120,    49,    49,    43,    46,    48,    46,    48,    49,    91,
1050       92,   120,    49,   120,    49,    42,   130,    48,    49,   109,
1051       49,   111,    41,   120,    27,    79,   101,   102,    41,    49,
1052       49,    49,    44,    46,   118,   123,   128,   129,   110,    41,
1053       42,   102,   106,   107,   133,    44,    46,    42,    41,   103,
1054      104,   133,    49,    42,    48,    36,   119,    42,    48,    49,
1055      107,   133,    42,    49,   104
1056 };
1057
1058 #define yyerrok         (yyerrstatus = 0)
1059 #define yyclearin       (yychar = YYEMPTY)
1060 #define YYEMPTY         (-2)
1061 #define YYEOF           0
1062
1063 #define YYACCEPT        goto yyacceptlab
1064 #define YYABORT         goto yyabortlab
1065 #define YYERROR         goto yyerrorlab
1066
1067
1068 /* Like YYERROR except do call yyerror.  This remains here temporarily
1069    to ease the transition to the new meaning of YYERROR, for GCC.
1070    Once GCC version 2 has supplanted version 1, this can go.  */
1071
1072 #define YYFAIL          goto yyerrlab
1073
1074 #define YYRECOVERING()  (!!yyerrstatus)
1075
1076 #define YYBACKUP(Token, Value)                                  \
1077 do                                                              \
1078   if (yychar == YYEMPTY && yylen == 1)                          \
1079     {                                                           \
1080       yychar = (Token);                                         \
1081       yylval = (Value);                                         \
1082       yytoken = YYTRANSLATE (yychar);                           \
1083       YYPOPSTACK (1);                                           \
1084       goto yybackup;                                            \
1085     }                                                           \
1086   else                                                          \
1087     {                                                           \
1088       yyerror (YY_("syntax error: cannot back up")); \
1089       YYERROR;                                                  \
1090     }                                                           \
1091 while (YYID (0))
1092
1093
1094 #define YYTERROR        1
1095 #define YYERRCODE       256
1096
1097
1098 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1099    If N is 0, then set CURRENT to the empty location which ends
1100    the previous symbol: RHS[0] (always defined).  */
1101
1102 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1103 #ifndef YYLLOC_DEFAULT
1104 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
1105     do                                                                  \
1106       if (YYID (N))                                                    \
1107         {                                                               \
1108           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
1109           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
1110           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
1111           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
1112         }                                                               \
1113       else                                                              \
1114         {                                                               \
1115           (Current).first_line   = (Current).last_line   =              \
1116             YYRHSLOC (Rhs, 0).last_line;                                \
1117           (Current).first_column = (Current).last_column =              \
1118             YYRHSLOC (Rhs, 0).last_column;                              \
1119         }                                                               \
1120     while (YYID (0))
1121 #endif
1122
1123
1124 /* YY_LOCATION_PRINT -- Print the location on the stream.
1125    This macro was not mandated originally: define only if we know
1126    we won't break user code: when these are the locations we know.  */
1127
1128 #ifndef YY_LOCATION_PRINT
1129 # if YYLTYPE_IS_TRIVIAL
1130 #  define YY_LOCATION_PRINT(File, Loc)                  \
1131      fprintf (File, "%d.%d-%d.%d",                      \
1132               (Loc).first_line, (Loc).first_column,     \
1133               (Loc).last_line,  (Loc).last_column)
1134 # else
1135 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1136 # endif
1137 #endif
1138
1139
1140 /* YYLEX -- calling `yylex' with the right arguments.  */
1141
1142 #ifdef YYLEX_PARAM
1143 # define YYLEX yylex (YYLEX_PARAM)
1144 #else
1145 # define YYLEX yylex ()
1146 #endif
1147
1148 /* Enable debugging if requested.  */
1149 #if YYDEBUG
1150
1151 # ifndef YYFPRINTF
1152 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1153 #  define YYFPRINTF fprintf
1154 # endif
1155
1156 # define YYDPRINTF(Args)                        \
1157 do {                                            \
1158   if (yydebug)                                  \
1159     YYFPRINTF Args;                             \
1160 } while (YYID (0))
1161
1162 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1163 do {                                                                      \
1164   if (yydebug)                                                            \
1165     {                                                                     \
1166       YYFPRINTF (stderr, "%s ", Title);                                   \
1167       yy_symbol_print (stderr,                                            \
1168                   Type, Value); \
1169       YYFPRINTF (stderr, "\n");                                           \
1170     }                                                                     \
1171 } while (YYID (0))
1172
1173
1174 /*--------------------------------.
1175 | Print this symbol on YYOUTPUT.  |
1176 `--------------------------------*/
1177
1178 /*ARGSUSED*/
1179 #if (defined __STDC__ || defined __C99__FUNC__ \
1180      || defined __cplusplus || defined _MSC_VER)
1181 static void
1182 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1183 #else
1184 static void
1185 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1186     FILE *yyoutput;
1187     int yytype;
1188     YYSTYPE const * const yyvaluep;
1189 #endif
1190 {
1191   if (!yyvaluep)
1192     return;
1193 # ifdef YYPRINT
1194   if (yytype < YYNTOKENS)
1195     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1196 # else
1197   YYUSE (yyoutput);
1198 # endif
1199   switch (yytype)
1200     {
1201       default:
1202         break;
1203     }
1204 }
1205
1206
1207 /*--------------------------------.
1208 | Print this symbol on YYOUTPUT.  |
1209 `--------------------------------*/
1210
1211 #if (defined __STDC__ || defined __C99__FUNC__ \
1212      || defined __cplusplus || defined _MSC_VER)
1213 static void
1214 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1215 #else
1216 static void
1217 yy_symbol_print (yyoutput, yytype, yyvaluep)
1218     FILE *yyoutput;
1219     int yytype;
1220     YYSTYPE const * const yyvaluep;
1221 #endif
1222 {
1223   if (yytype < YYNTOKENS)
1224     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1225   else
1226     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1227
1228   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1229   YYFPRINTF (yyoutput, ")");
1230 }
1231
1232 /*------------------------------------------------------------------.
1233 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1234 | TOP (included).                                                   |
1235 `------------------------------------------------------------------*/
1236
1237 #if (defined __STDC__ || defined __C99__FUNC__ \
1238      || defined __cplusplus || defined _MSC_VER)
1239 static void
1240 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1241 #else
1242 static void
1243 yy_stack_print (bottom, top)
1244     yytype_int16 *bottom;
1245     yytype_int16 *top;
1246 #endif
1247 {
1248   YYFPRINTF (stderr, "Stack now");
1249   for (; bottom <= top; ++bottom)
1250     YYFPRINTF (stderr, " %d", *bottom);
1251   YYFPRINTF (stderr, "\n");
1252 }
1253
1254 # define YY_STACK_PRINT(Bottom, Top)                            \
1255 do {                                                            \
1256   if (yydebug)                                                  \
1257     yy_stack_print ((Bottom), (Top));                           \
1258 } while (YYID (0))
1259
1260
1261 /*------------------------------------------------.
1262 | Report that the YYRULE is going to be reduced.  |
1263 `------------------------------------------------*/
1264
1265 #if (defined __STDC__ || defined __C99__FUNC__ \
1266      || defined __cplusplus || defined _MSC_VER)
1267 static void
1268 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1269 #else
1270 static void
1271 yy_reduce_print (yyvsp, yyrule)
1272     YYSTYPE *yyvsp;
1273     int yyrule;
1274 #endif
1275 {
1276   int yynrhs = yyr2[yyrule];
1277   int yyi;
1278   unsigned long int yylno = yyrline[yyrule];
1279   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1280              yyrule - 1, yylno);
1281   /* The symbols being reduced.  */
1282   for (yyi = 0; yyi < yynrhs; yyi++)
1283     {
1284       fprintf (stderr, "   $%d = ", yyi + 1);
1285       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1286                        &(yyvsp[(yyi + 1) - (yynrhs)])
1287                                        );
1288       fprintf (stderr, "\n");
1289     }
1290 }
1291
1292 # define YY_REDUCE_PRINT(Rule)          \
1293 do {                                    \
1294   if (yydebug)                          \
1295     yy_reduce_print (yyvsp, Rule); \
1296 } while (YYID (0))
1297
1298 /* Nonzero means print parse trace.  It is left uninitialized so that
1299    multiple parsers can coexist.  */
1300 int yydebug;
1301 #else /* !YYDEBUG */
1302 # define YYDPRINTF(Args)
1303 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1304 # define YY_STACK_PRINT(Bottom, Top)
1305 # define YY_REDUCE_PRINT(Rule)
1306 #endif /* !YYDEBUG */
1307
1308
1309 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1310 #ifndef YYINITDEPTH
1311 # define YYINITDEPTH 200
1312 #endif
1313
1314 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1315    if the built-in stack extension method is used).
1316
1317    Do not make this value too large; the results are undefined if
1318    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1319    evaluated with infinite-precision integer arithmetic.  */
1320
1321 #ifndef YYMAXDEPTH
1322 # define YYMAXDEPTH 10000
1323 #endif
1324
1325 \f
1326
1327 #if YYERROR_VERBOSE
1328
1329 # ifndef yystrlen
1330 #  if defined __GLIBC__ && defined _STRING_H
1331 #   define yystrlen strlen
1332 #  else
1333 /* Return the length of YYSTR.  */
1334 #if (defined __STDC__ || defined __C99__FUNC__ \
1335      || defined __cplusplus || defined _MSC_VER)
1336 static YYSIZE_T
1337 yystrlen (const char *yystr)
1338 #else
1339 static YYSIZE_T
1340 yystrlen (yystr)
1341     const char *yystr;
1342 #endif
1343 {
1344   YYSIZE_T yylen;
1345   for (yylen = 0; yystr[yylen]; yylen++)
1346     continue;
1347   return yylen;
1348 }
1349 #  endif
1350 # endif
1351
1352 # ifndef yystpcpy
1353 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1354 #   define yystpcpy stpcpy
1355 #  else
1356 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1357    YYDEST.  */
1358 #if (defined __STDC__ || defined __C99__FUNC__ \
1359      || defined __cplusplus || defined _MSC_VER)
1360 static char *
1361 yystpcpy (char *yydest, const char *yysrc)
1362 #else
1363 static char *
1364 yystpcpy (yydest, yysrc)
1365     char *yydest;
1366     const char *yysrc;
1367 #endif
1368 {
1369   char *yyd = yydest;
1370   const char *yys = yysrc;
1371
1372   while ((*yyd++ = *yys++) != '\0')
1373     continue;
1374
1375   return yyd - 1;
1376 }
1377 #  endif
1378 # endif
1379
1380 # ifndef yytnamerr
1381 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1382    quotes and backslashes, so that it's suitable for yyerror.  The
1383    heuristic is that double-quoting is unnecessary unless the string
1384    contains an apostrophe, a comma, or backslash (other than
1385    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1386    null, do not copy; instead, return the length of what the result
1387    would have been.  */
1388 static YYSIZE_T
1389 yytnamerr (char *yyres, const char *yystr)
1390 {
1391   if (*yystr == '"')
1392     {
1393       YYSIZE_T yyn = 0;
1394       char const *yyp = yystr;
1395
1396       for (;;)
1397         switch (*++yyp)
1398           {
1399           case '\'':
1400           case ',':
1401             goto do_not_strip_quotes;
1402
1403           case '\\':
1404             if (*++yyp != '\\')
1405               goto do_not_strip_quotes;
1406             /* Fall through.  */
1407           default:
1408             if (yyres)
1409               yyres[yyn] = *yyp;
1410             yyn++;
1411             break;
1412
1413           case '"':
1414             if (yyres)
1415               yyres[yyn] = '\0';
1416             return yyn;
1417           }
1418     do_not_strip_quotes: ;
1419     }
1420
1421   if (! yyres)
1422     return yystrlen (yystr);
1423
1424   return yystpcpy (yyres, yystr) - yyres;
1425 }
1426 # endif
1427
1428 /* Copy into YYRESULT an error message about the unexpected token
1429    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1430    including the terminating null byte.  If YYRESULT is null, do not
1431    copy anything; just return the number of bytes that would be
1432    copied.  As a special case, return 0 if an ordinary "syntax error"
1433    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1434    size calculation.  */
1435 static YYSIZE_T
1436 yysyntax_error (char *yyresult, int yystate, int yychar)
1437 {
1438   int yyn = yypact[yystate];
1439
1440   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1441     return 0;
1442   else
1443     {
1444       int yytype = YYTRANSLATE (yychar);
1445       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1446       YYSIZE_T yysize = yysize0;
1447       YYSIZE_T yysize1;
1448       int yysize_overflow = 0;
1449       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1450       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1451       int yyx;
1452
1453 # if 0
1454       /* This is so xgettext sees the translatable formats that are
1455          constructed on the fly.  */
1456       YY_("syntax error, unexpected %s");
1457       YY_("syntax error, unexpected %s, expecting %s");
1458       YY_("syntax error, unexpected %s, expecting %s or %s");
1459       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1460       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1461 # endif
1462       char *yyfmt;
1463       char const *yyf;
1464       static char const yyunexpected[] = "syntax error, unexpected %s";
1465       static char const yyexpecting[] = ", expecting %s";
1466       static char const yyor[] = " or %s";
1467       char yyformat[sizeof yyunexpected
1468                     + sizeof yyexpecting - 1
1469                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1470                        * (sizeof yyor - 1))];
1471       char const *yyprefix = yyexpecting;
1472
1473       /* Start YYX at -YYN if negative to avoid negative indexes in
1474          YYCHECK.  */
1475       int yyxbegin = yyn < 0 ? -yyn : 0;
1476
1477       /* Stay within bounds of both yycheck and yytname.  */
1478       int yychecklim = YYLAST - yyn + 1;
1479       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1480       int yycount = 1;
1481
1482       yyarg[0] = yytname[yytype];
1483       yyfmt = yystpcpy (yyformat, yyunexpected);
1484
1485       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1486         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1487           {
1488             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1489               {
1490                 yycount = 1;
1491                 yysize = yysize0;
1492                 yyformat[sizeof yyunexpected - 1] = '\0';
1493                 break;
1494               }
1495             yyarg[yycount++] = yytname[yyx];
1496             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1497             yysize_overflow |= (yysize1 < yysize);
1498             yysize = yysize1;
1499             yyfmt = yystpcpy (yyfmt, yyprefix);
1500             yyprefix = yyor;
1501           }
1502
1503       yyf = YY_(yyformat);
1504       yysize1 = yysize + yystrlen (yyf);
1505       yysize_overflow |= (yysize1 < yysize);
1506       yysize = yysize1;
1507
1508       if (yysize_overflow)
1509         return YYSIZE_MAXIMUM;
1510
1511       if (yyresult)
1512         {
1513           /* Avoid sprintf, as that infringes on the user's name space.
1514              Don't have undefined behavior even if the translation
1515              produced a string with the wrong number of "%s"s.  */
1516           char *yyp = yyresult;
1517           int yyi = 0;
1518           while ((*yyp = *yyf) != '\0')
1519             {
1520               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1521                 {
1522                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1523                   yyf += 2;
1524                 }
1525               else
1526                 {
1527                   yyp++;
1528                   yyf++;
1529                 }
1530             }
1531         }
1532       return yysize;
1533     }
1534 }
1535 #endif /* YYERROR_VERBOSE */
1536 \f
1537
1538 /*-----------------------------------------------.
1539 | Release the memory associated to this symbol.  |
1540 `-----------------------------------------------*/
1541
1542 /*ARGSUSED*/
1543 #if (defined __STDC__ || defined __C99__FUNC__ \
1544      || defined __cplusplus || defined _MSC_VER)
1545 static void
1546 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1547 #else
1548 static void
1549 yydestruct (yymsg, yytype, yyvaluep)
1550     const char *yymsg;
1551     int yytype;
1552     YYSTYPE *yyvaluep;
1553 #endif
1554 {
1555   YYUSE (yyvaluep);
1556
1557   if (!yymsg)
1558     yymsg = "Deleting";
1559   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1560
1561   switch (yytype)
1562     {
1563
1564       default:
1565         break;
1566     }
1567 }
1568 \f
1569
1570 /* Prevent warnings from -Wmissing-prototypes.  */
1571
1572 #ifdef YYPARSE_PARAM
1573 #if defined __STDC__ || defined __cplusplus
1574 int yyparse (void *YYPARSE_PARAM);
1575 #else
1576 int yyparse ();
1577 #endif
1578 #else /* ! YYPARSE_PARAM */
1579 #if defined __STDC__ || defined __cplusplus
1580 int yyparse (void);
1581 #else
1582 int yyparse ();
1583 #endif
1584 #endif /* ! YYPARSE_PARAM */
1585
1586
1587
1588 /* The look-ahead symbol.  */
1589 int yychar;
1590
1591 /* The semantic value of the look-ahead symbol.  */
1592 YYSTYPE yylval;
1593
1594 /* Number of syntax errors so far.  */
1595 int yynerrs;
1596
1597
1598
1599 /*----------.
1600 | yyparse.  |
1601 `----------*/
1602
1603 #ifdef YYPARSE_PARAM
1604 #if (defined __STDC__ || defined __C99__FUNC__ \
1605      || defined __cplusplus || defined _MSC_VER)
1606 int
1607 yyparse (void *YYPARSE_PARAM)
1608 #else
1609 int
1610 yyparse (YYPARSE_PARAM)
1611     void *YYPARSE_PARAM;
1612 #endif
1613 #else /* ! YYPARSE_PARAM */
1614 #if (defined __STDC__ || defined __C99__FUNC__ \
1615      || defined __cplusplus || defined _MSC_VER)
1616 int
1617 yyparse (void)
1618 #else
1619 int
1620 yyparse ()
1621
1622 #endif
1623 #endif
1624 {
1625
1626   int yystate;
1627   int yyn;
1628   int yyresult;
1629   /* Number of tokens to shift before error messages enabled.  */
1630   int yyerrstatus;
1631   /* Look-ahead token as an internal (translated) token number.  */
1632   int yytoken = 0;
1633 #if YYERROR_VERBOSE
1634   /* Buffer for error messages, and its allocated size.  */
1635   char yymsgbuf[128];
1636   char *yymsg = yymsgbuf;
1637   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1638 #endif
1639
1640   /* Three stacks and their tools:
1641      `yyss': related to states,
1642      `yyvs': related to semantic values,
1643      `yyls': related to locations.
1644
1645      Refer to the stacks thru separate pointers, to allow yyoverflow
1646      to reallocate them elsewhere.  */
1647
1648   /* The state stack.  */
1649   yytype_int16 yyssa[YYINITDEPTH];
1650   yytype_int16 *yyss = yyssa;
1651   yytype_int16 *yyssp;
1652
1653   /* The semantic value stack.  */
1654   YYSTYPE yyvsa[YYINITDEPTH];
1655   YYSTYPE *yyvs = yyvsa;
1656   YYSTYPE *yyvsp;
1657
1658
1659
1660 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1661
1662   YYSIZE_T yystacksize = YYINITDEPTH;
1663
1664   /* The variables used to return semantic value and location from the
1665      action routines.  */
1666   YYSTYPE yyval;
1667
1668
1669   /* The number of symbols on the RHS of the reduced rule.
1670      Keep to zero when no symbol should be popped.  */
1671   int yylen = 0;
1672
1673   YYDPRINTF ((stderr, "Starting parse\n"));
1674
1675   yystate = 0;
1676   yyerrstatus = 0;
1677   yynerrs = 0;
1678   yychar = YYEMPTY;             /* Cause a token to be read.  */
1679
1680   /* Initialize stack pointers.
1681      Waste one element of value and location stack
1682      so that they stay on the same level as the state stack.
1683      The wasted elements are never initialized.  */
1684
1685   yyssp = yyss;
1686   yyvsp = yyvs;
1687
1688   goto yysetstate;
1689
1690 /*------------------------------------------------------------.
1691 | yynewstate -- Push a new state, which is found in yystate.  |
1692 `------------------------------------------------------------*/
1693  yynewstate:
1694   /* In all cases, when you get here, the value and location stacks
1695      have just been pushed.  So pushing a state here evens the stacks.  */
1696   yyssp++;
1697
1698  yysetstate:
1699   *yyssp = yystate;
1700
1701   if (yyss + yystacksize - 1 <= yyssp)
1702     {
1703       /* Get the current used size of the three stacks, in elements.  */
1704       YYSIZE_T yysize = yyssp - yyss + 1;
1705
1706 #ifdef yyoverflow
1707       {
1708         /* Give user a chance to reallocate the stack.  Use copies of
1709            these so that the &'s don't force the real ones into
1710            memory.  */
1711         YYSTYPE *yyvs1 = yyvs;
1712         yytype_int16 *yyss1 = yyss;
1713
1714
1715         /* Each stack pointer address is followed by the size of the
1716            data in use in that stack, in bytes.  This used to be a
1717            conditional around just the two extra args, but that might
1718            be undefined if yyoverflow is a macro.  */
1719         yyoverflow (YY_("memory exhausted"),
1720                     &yyss1, yysize * sizeof (*yyssp),
1721                     &yyvs1, yysize * sizeof (*yyvsp),
1722
1723                     &yystacksize);
1724
1725         yyss = yyss1;
1726         yyvs = yyvs1;
1727       }
1728 #else /* no yyoverflow */
1729 # ifndef YYSTACK_RELOCATE
1730       goto yyexhaustedlab;
1731 # else
1732       /* Extend the stack our own way.  */
1733       if (YYMAXDEPTH <= yystacksize)
1734         goto yyexhaustedlab;
1735       yystacksize *= 2;
1736       if (YYMAXDEPTH < yystacksize)
1737         yystacksize = YYMAXDEPTH;
1738
1739       {
1740         yytype_int16 *yyss1 = yyss;
1741         union yyalloc *yyptr =
1742           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1743         if (! yyptr)
1744           goto yyexhaustedlab;
1745         YYSTACK_RELOCATE (yyss);
1746         YYSTACK_RELOCATE (yyvs);
1747
1748 #  undef YYSTACK_RELOCATE
1749         if (yyss1 != yyssa)
1750           YYSTACK_FREE (yyss1);
1751       }
1752 # endif
1753 #endif /* no yyoverflow */
1754
1755       yyssp = yyss + yysize - 1;
1756       yyvsp = yyvs + yysize - 1;
1757
1758
1759       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1760                   (unsigned long int) yystacksize));
1761
1762       if (yyss + yystacksize - 1 <= yyssp)
1763         YYABORT;
1764     }
1765
1766   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1767
1768   goto yybackup;
1769
1770 /*-----------.
1771 | yybackup.  |
1772 `-----------*/
1773 yybackup:
1774
1775   /* Do appropriate processing given the current state.  Read a
1776      look-ahead token if we need one and don't already have one.  */
1777
1778   /* First try to decide what to do without reference to look-ahead token.  */
1779   yyn = yypact[yystate];
1780   if (yyn == YYPACT_NINF)
1781     goto yydefault;
1782
1783   /* Not known => get a look-ahead token if don't already have one.  */
1784
1785   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1786   if (yychar == YYEMPTY)
1787     {
1788       YYDPRINTF ((stderr, "Reading a token: "));
1789       yychar = YYLEX;
1790     }
1791
1792   if (yychar <= YYEOF)
1793     {
1794       yychar = yytoken = YYEOF;
1795       YYDPRINTF ((stderr, "Now at end of input.\n"));
1796     }
1797   else
1798     {
1799       yytoken = YYTRANSLATE (yychar);
1800       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1801     }
1802
1803   /* If the proper action on seeing token YYTOKEN is to reduce or to
1804      detect an error, take that action.  */
1805   yyn += yytoken;
1806   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1807     goto yydefault;
1808   yyn = yytable[yyn];
1809   if (yyn <= 0)
1810     {
1811       if (yyn == 0 || yyn == YYTABLE_NINF)
1812         goto yyerrlab;
1813       yyn = -yyn;
1814       goto yyreduce;
1815     }
1816
1817   if (yyn == YYFINAL)
1818     YYACCEPT;
1819
1820   /* Count tokens shifted since error; after three, turn off error
1821      status.  */
1822   if (yyerrstatus)
1823     yyerrstatus--;
1824
1825   /* Shift the look-ahead token.  */
1826   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1827
1828   /* Discard the shifted token unless it is eof.  */
1829   if (yychar != YYEOF)
1830     yychar = YYEMPTY;
1831
1832   yystate = yyn;
1833   *++yyvsp = yylval;
1834
1835   goto yynewstate;
1836
1837
1838 /*-----------------------------------------------------------.
1839 | yydefault -- do the default action for the current state.  |
1840 `-----------------------------------------------------------*/
1841 yydefault:
1842   yyn = yydefact[yystate];
1843   if (yyn == 0)
1844     goto yyerrlab;
1845   goto yyreduce;
1846
1847
1848 /*-----------------------------.
1849 | yyreduce -- Do a reduction.  |
1850 `-----------------------------*/
1851 yyreduce:
1852   /* yyn is the number of a rule to reduce with.  */
1853   yylen = yyr2[yyn];
1854
1855   /* If YYLEN is nonzero, implement the default value of the action:
1856      `$$ = $1'.
1857
1858      Otherwise, the following line sets YYVAL to garbage.
1859      This behavior is undocumented and Bison
1860      users should not rely upon it.  Assigning to YYVAL
1861      unconditionally makes the parser a bit smaller, and it avoids a
1862      GCC warning that YYVAL may be used uninitialized.  */
1863   yyval = yyvsp[1-yylen];
1864
1865
1866   YY_REDUCE_PRINT (yyn);
1867   switch (yyn)
1868     {
1869         case 2:
1870 #line 169 "xkbparse.y"
1871     { (yyval.file)= rtrnValue= (yyvsp[(1) - (1)].file); }
1872     break;
1873
1874   case 3:
1875 #line 171 "xkbparse.y"
1876     { (yyval.file)= rtrnValue= (yyvsp[(1) - (1)].file);  }
1877     break;
1878
1879   case 4:
1880 #line 173 "xkbparse.y"
1881     { (yyval.file)= rtrnValue= (yyvsp[(1) - (1)].file); }
1882     break;
1883
1884   case 5:
1885 #line 177 "xkbparse.y"
1886     { (yyval.file)= (XkbFile *)AppendStmt(&(yyvsp[(1) - (2)].file)->common,&(yyvsp[(2) - (2)].file)->common); }
1887     break;
1888
1889   case 6:
1890 #line 179 "xkbparse.y"
1891     { (yyval.file)= (yyvsp[(1) - (1)].file); }
1892     break;
1893
1894   case 7:
1895 #line 185 "xkbparse.y"
1896     { (yyval.file)= CreateXKBFile((yyvsp[(2) - (7)].uval),(yyvsp[(3) - (7)].str),&(yyvsp[(5) - (7)].file)->common,(yyvsp[(1) - (7)].uval)); }
1897     break;
1898
1899   case 8:
1900 #line 188 "xkbparse.y"
1901     { (yyval.uval)= XkmKeymapFile; }
1902     break;
1903
1904   case 9:
1905 #line 189 "xkbparse.y"
1906     { (yyval.uval)= XkmSemanticsFile; }
1907     break;
1908
1909   case 10:
1910 #line 190 "xkbparse.y"
1911     { (yyval.uval)= XkmLayoutFile; }
1912     break;
1913
1914   case 11:
1915 #line 194 "xkbparse.y"
1916     { (yyval.file)= (XkbFile *)AppendStmt(&(yyvsp[(1) - (2)].file)->common,&(yyvsp[(2) - (2)].file)->common); }
1917     break;
1918
1919   case 12:
1920 #line 196 "xkbparse.y"
1921     { (yyval.file)= (yyvsp[(1) - (1)].file); }
1922     break;
1923
1924   case 13:
1925 #line 202 "xkbparse.y"
1926     { (yyval.file)= CreateXKBFile((yyvsp[(2) - (7)].uval),(yyvsp[(3) - (7)].str),(yyvsp[(5) - (7)].any),(yyvsp[(1) - (7)].uval)); }
1927     break;
1928
1929   case 14:
1930 #line 206 "xkbparse.y"
1931     { (yyval.file)= CreateXKBFile((yyvsp[(2) - (4)].uval),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].any),(yyvsp[(1) - (4)].uval)); }
1932     break;
1933
1934   case 15:
1935 #line 210 "xkbparse.y"
1936     { (yyval.uval)= XkmKeyNamesIndex; }
1937     break;
1938
1939   case 16:
1940 #line 211 "xkbparse.y"
1941     { (yyval.uval)= XkmTypesIndex; }
1942     break;
1943
1944   case 17:
1945 #line 212 "xkbparse.y"
1946     { (yyval.uval)= XkmCompatMapIndex; }
1947     break;
1948
1949   case 18:
1950 #line 213 "xkbparse.y"
1951     { (yyval.uval)= XkmSymbolsIndex; }
1952     break;
1953
1954   case 19:
1955 #line 214 "xkbparse.y"
1956     { (yyval.uval)= XkmGeometryIndex; }
1957     break;
1958
1959   case 20:
1960 #line 217 "xkbparse.y"
1961     { (yyval.uval)= (yyvsp[(1) - (1)].uval); }
1962     break;
1963
1964   case 21:
1965 #line 218 "xkbparse.y"
1966     { (yyval.uval)= 0; }
1967     break;
1968
1969   case 22:
1970 #line 221 "xkbparse.y"
1971     { (yyval.uval)= (((yyvsp[(1) - (2)].uval))|((yyvsp[(2) - (2)].uval))); }
1972     break;
1973
1974   case 23:
1975 #line 222 "xkbparse.y"
1976     { (yyval.uval)= (yyvsp[(1) - (1)].uval); }
1977     break;
1978
1979   case 24:
1980 #line 225 "xkbparse.y"
1981     { (yyval.uval)= XkbLC_Partial; }
1982     break;
1983
1984   case 25:
1985 #line 226 "xkbparse.y"
1986     { (yyval.uval)= XkbLC_Default; }
1987     break;
1988
1989   case 26:
1990 #line 227 "xkbparse.y"
1991     { (yyval.uval)= XkbLC_Hidden; }
1992     break;
1993
1994   case 27:
1995 #line 228 "xkbparse.y"
1996     { (yyval.uval)= XkbLC_AlphanumericKeys; }
1997     break;
1998
1999   case 28:
2000 #line 229 "xkbparse.y"
2001     { (yyval.uval)= XkbLC_ModifierKeys; }
2002     break;
2003
2004   case 29:
2005 #line 230 "xkbparse.y"
2006     { (yyval.uval)= XkbLC_KeypadKeys; }
2007     break;
2008
2009   case 30:
2010 #line 231 "xkbparse.y"
2011     { (yyval.uval)= XkbLC_FunctionKeys; }
2012     break;
2013
2014   case 31:
2015 #line 232 "xkbparse.y"
2016     { (yyval.uval)= XkbLC_AlternateGroup; }
2017     break;
2018
2019   case 32:
2020 #line 236 "xkbparse.y"
2021     { (yyval.any)= AppendStmt((yyvsp[(1) - (2)].any),(yyvsp[(2) - (2)].any)); }
2022     break;
2023
2024   case 33:
2025 #line 237 "xkbparse.y"
2026     { (yyval.any)= NULL; }
2027     break;
2028
2029   case 34:
2030 #line 241 "xkbparse.y"
2031     {
2032                             (yyvsp[(2) - (2)].var)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].var)->common,(yyvsp[(1) - (2)].uval));
2033                             (yyval.any)= &(yyvsp[(2) - (2)].var)->common;
2034                         }
2035     break;
2036
2037   case 35:
2038 #line 246 "xkbparse.y"
2039     {
2040                             (yyvsp[(2) - (2)].vmod)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].vmod)->common,(yyvsp[(1) - (2)].uval));
2041                             (yyval.any)= &(yyvsp[(2) - (2)].vmod)->common;
2042                         }
2043     break;
2044
2045   case 36:
2046 #line 251 "xkbparse.y"
2047     {
2048                             (yyvsp[(2) - (2)].interp)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].interp)->common,(yyvsp[(1) - (2)].uval));
2049                             (yyval.any)= &(yyvsp[(2) - (2)].interp)->common;
2050                         }
2051     break;
2052
2053   case 37:
2054 #line 256 "xkbparse.y"
2055     {
2056                             (yyvsp[(2) - (2)].keyName)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].keyName)->common,(yyvsp[(1) - (2)].uval));
2057                             (yyval.any)= &(yyvsp[(2) - (2)].keyName)->common;
2058                         }
2059     break;
2060
2061   case 38:
2062 #line 261 "xkbparse.y"
2063     {
2064                             (yyvsp[(2) - (2)].keyAlias)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].keyAlias)->common,(yyvsp[(1) - (2)].uval));
2065                             (yyval.any)= &(yyvsp[(2) - (2)].keyAlias)->common;
2066                         }
2067     break;
2068
2069   case 39:
2070 #line 266 "xkbparse.y"
2071     {
2072                             (yyvsp[(2) - (2)].keyType)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].keyType)->common,(yyvsp[(1) - (2)].uval));
2073                             (yyval.any)= &(yyvsp[(2) - (2)].keyType)->common;
2074                         }
2075     break;
2076
2077   case 40:
2078 #line 271 "xkbparse.y"
2079     {
2080                             (yyvsp[(2) - (2)].syms)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].syms)->common,(yyvsp[(1) - (2)].uval));
2081                             (yyval.any)= &(yyvsp[(2) - (2)].syms)->common;
2082                         }
2083     break;
2084
2085   case 41:
2086 #line 276 "xkbparse.y"
2087     {
2088                             (yyvsp[(2) - (2)].modMask)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].modMask)->common,(yyvsp[(1) - (2)].uval));
2089                             (yyval.any)= &(yyvsp[(2) - (2)].modMask)->common;
2090                         }
2091     break;
2092
2093   case 42:
2094 #line 281 "xkbparse.y"
2095     {
2096                             (yyvsp[(2) - (2)].groupCompat)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].groupCompat)->common,(yyvsp[(1) - (2)].uval));
2097                             (yyval.any)= &(yyvsp[(2) - (2)].groupCompat)->common;
2098                         }
2099     break;
2100
2101   case 43:
2102 #line 286 "xkbparse.y"
2103     {
2104                             (yyvsp[(2) - (2)].ledMap)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].ledMap)->common,(yyvsp[(1) - (2)].uval));
2105                             (yyval.any)= &(yyvsp[(2) - (2)].ledMap)->common;
2106                         }
2107     break;
2108
2109   case 44:
2110 #line 291 "xkbparse.y"
2111     {
2112                             (yyvsp[(2) - (2)].ledName)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].ledName)->common,(yyvsp[(1) - (2)].uval));
2113                             (yyval.any)= &(yyvsp[(2) - (2)].ledName)->common;
2114                         }
2115     break;
2116
2117   case 45:
2118 #line 296 "xkbparse.y"
2119     {
2120                             (yyvsp[(2) - (2)].shape)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].shape)->common,(yyvsp[(1) - (2)].uval));
2121                             (yyval.any)= &(yyvsp[(2) - (2)].shape)->common;
2122                         }
2123     break;
2124
2125   case 46:
2126 #line 301 "xkbparse.y"
2127     {
2128                             (yyvsp[(2) - (2)].section)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].section)->common,(yyvsp[(1) - (2)].uval));
2129                             (yyval.any)= &(yyvsp[(2) - (2)].section)->common;
2130                         }
2131     break;
2132
2133   case 47:
2134 #line 306 "xkbparse.y"
2135     {
2136                             (yyvsp[(2) - (2)].doodad)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].doodad)->common,(yyvsp[(1) - (2)].uval));
2137                             (yyval.any)= &(yyvsp[(2) - (2)].doodad)->common;
2138                         }
2139     break;
2140
2141   case 48:
2142 #line 311 "xkbparse.y"
2143     {
2144                             if ((yyvsp[(1) - (2)].uval)==MergeAltForm) {
2145                                 yyerror("cannot use 'alternate' to include other maps");
2146                                 (yyval.any)= &IncludeCreate(scanBuf,MergeDefault)->common;
2147                             }
2148                             else {
2149                                 (yyval.any)= &IncludeCreate(scanBuf,(yyvsp[(1) - (2)].uval))->common;
2150                             }
2151                         }
2152     break;
2153
2154   case 49:
2155 #line 323 "xkbparse.y"
2156     { (yyval.var)= VarCreate((yyvsp[(1) - (4)].expr),(yyvsp[(3) - (4)].expr)); }
2157     break;
2158
2159   case 50:
2160 #line 325 "xkbparse.y"
2161     { (yyval.var)= BoolVarCreate((yyvsp[(1) - (2)].sval),1); }
2162     break;
2163
2164   case 51:
2165 #line 327 "xkbparse.y"
2166     { (yyval.var)= BoolVarCreate((yyvsp[(2) - (3)].sval),0); }
2167     break;
2168
2169   case 52:
2170 #line 331 "xkbparse.y"
2171     {
2172                             KeycodeDef *def;
2173
2174                             def= KeycodeCreate((yyvsp[(1) - (4)].str),(yyvsp[(3) - (4)].expr));
2175                             if ((yyvsp[(1) - (4)].str))
2176                                 free((yyvsp[(1) - (4)].str));
2177                             (yyval.keyName)= def;
2178                         }
2179     break;
2180
2181   case 53:
2182 #line 342 "xkbparse.y"
2183     {
2184                             KeyAliasDef *def;
2185                             def= KeyAliasCreate((yyvsp[(2) - (5)].str),(yyvsp[(4) - (5)].str));
2186                             if ((yyvsp[(2) - (5)].str)) free((yyvsp[(2) - (5)].str));
2187                             if ((yyvsp[(4) - (5)].str)) free((yyvsp[(4) - (5)].str));
2188                             (yyval.keyAlias)= def;
2189                         }
2190     break;
2191
2192   case 54:
2193 #line 352 "xkbparse.y"
2194     { (yyval.vmod)= (yyvsp[(2) - (3)].vmod); }
2195     break;
2196
2197   case 55:
2198 #line 356 "xkbparse.y"
2199     { (yyval.vmod)= (VModDef *)AppendStmt(&(yyvsp[(1) - (3)].vmod)->common,&(yyvsp[(3) - (3)].vmod)->common); }
2200     break;
2201
2202   case 56:
2203 #line 358 "xkbparse.y"
2204     { (yyval.vmod)= (yyvsp[(1) - (1)].vmod); }
2205     break;
2206
2207   case 57:
2208 #line 362 "xkbparse.y"
2209     { (yyval.vmod)= VModCreate((yyvsp[(1) - (1)].sval),NULL); }
2210     break;
2211
2212   case 58:
2213 #line 364 "xkbparse.y"
2214     { (yyval.vmod)= VModCreate((yyvsp[(1) - (3)].sval),(yyvsp[(3) - (3)].expr)); }
2215     break;
2216
2217   case 59:
2218 #line 370 "xkbparse.y"
2219     {
2220                             (yyvsp[(2) - (6)].interp)->def= (yyvsp[(4) - (6)].var);
2221                             (yyval.interp)= (yyvsp[(2) - (6)].interp);
2222                         }
2223     break;
2224
2225   case 60:
2226 #line 377 "xkbparse.y"
2227     { (yyval.interp)= InterpCreate((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].expr)); }
2228     break;
2229
2230   case 61:
2231 #line 379 "xkbparse.y"
2232     { (yyval.interp)= InterpCreate((yyvsp[(1) - (1)].str), NULL); }
2233     break;
2234
2235   case 62:
2236 #line 383 "xkbparse.y"
2237     { (yyval.var)= (VarDef *)AppendStmt(&(yyvsp[(1) - (2)].var)->common,&(yyvsp[(2) - (2)].var)->common); }
2238     break;
2239
2240   case 63:
2241 #line 385 "xkbparse.y"
2242     { (yyval.var)= (yyvsp[(1) - (1)].var); }
2243     break;
2244
2245   case 64:
2246 #line 391 "xkbparse.y"
2247     { (yyval.keyType)= KeyTypeCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].var)); }
2248     break;
2249
2250   case 65:
2251 #line 397 "xkbparse.y"
2252     { (yyval.syms)= SymbolsCreate((yyvsp[(2) - (6)].str),(ExprDef *)(yyvsp[(4) - (6)].var)); }
2253     break;
2254
2255   case 66:
2256 #line 401 "xkbparse.y"
2257     { (yyval.var)= (VarDef *)AppendStmt(&(yyvsp[(1) - (3)].var)->common,&(yyvsp[(3) - (3)].var)->common); }
2258     break;
2259
2260   case 67:
2261 #line 403 "xkbparse.y"
2262     { (yyval.var)= (yyvsp[(1) - (1)].var); }
2263     break;
2264
2265   case 68:
2266 #line 404 "xkbparse.y"
2267     { (yyval.var)= NULL; }
2268     break;
2269
2270   case 69:
2271 #line 408 "xkbparse.y"
2272     { (yyval.var)= VarCreate((yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2273     break;
2274
2275   case 70:
2276 #line 410 "xkbparse.y"
2277     { (yyval.var)= VarCreate((yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2278     break;
2279
2280   case 71:
2281 #line 412 "xkbparse.y"
2282     { (yyval.var)= BoolVarCreate((yyvsp[(1) - (1)].sval),1); }
2283     break;
2284
2285   case 72:
2286 #line 414 "xkbparse.y"
2287     { (yyval.var)= BoolVarCreate((yyvsp[(2) - (2)].sval),0); }
2288     break;
2289
2290   case 73:
2291 #line 416 "xkbparse.y"
2292     { (yyval.var)= VarCreate(NULL,(yyvsp[(1) - (1)].expr)); }
2293     break;
2294
2295   case 74:
2296 #line 420 "xkbparse.y"
2297     { (yyval.expr)= (yyvsp[(2) - (3)].expr); }
2298     break;
2299
2300   case 75:
2301 #line 422 "xkbparse.y"
2302     { (yyval.expr)= ExprCreateUnary(ExprActionList,TypeAction,(yyvsp[(2) - (3)].expr)); }
2303     break;
2304
2305   case 76:
2306 #line 426 "xkbparse.y"
2307     { (yyval.groupCompat)= GroupCompatCreate((yyvsp[(2) - (5)].ival),(yyvsp[(4) - (5)].expr)); }
2308     break;
2309
2310   case 77:
2311 #line 430 "xkbparse.y"
2312     { (yyval.modMask)= ModMapCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].expr)); }
2313     break;
2314
2315   case 78:
2316 #line 434 "xkbparse.y"
2317     { (yyval.ledMap)= IndicatorMapCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].var)); }
2318     break;
2319
2320   case 79:
2321 #line 438 "xkbparse.y"
2322     { (yyval.ledName)= IndicatorNameCreate((yyvsp[(2) - (5)].ival),(yyvsp[(4) - (5)].expr),False); }
2323     break;
2324
2325   case 80:
2326 #line 440 "xkbparse.y"
2327     { (yyval.ledName)= IndicatorNameCreate((yyvsp[(3) - (6)].ival),(yyvsp[(5) - (6)].expr),True); }
2328     break;
2329
2330   case 81:
2331 #line 444 "xkbparse.y"
2332     { (yyval.shape)= ShapeDeclCreate((yyvsp[(2) - (6)].sval),(OutlineDef *)&(yyvsp[(4) - (6)].outline)->common); }
2333     break;
2334
2335   case 82:
2336 #line 446 "xkbparse.y"
2337     {
2338                             OutlineDef *outlines;
2339                             outlines= OutlineCreate(None,(yyvsp[(4) - (6)].expr));
2340                             (yyval.shape)= ShapeDeclCreate((yyvsp[(2) - (6)].sval),outlines);
2341                         }
2342     break;
2343
2344   case 83:
2345 #line 454 "xkbparse.y"
2346     { (yyval.section)= SectionDeclCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].row)); }
2347     break;
2348
2349   case 84:
2350 #line 458 "xkbparse.y"
2351     { (yyval.row)=(RowDef *)AppendStmt(&(yyvsp[(1) - (2)].row)->common,&(yyvsp[(2) - (2)].row)->common);}
2352     break;
2353
2354   case 85:
2355 #line 460 "xkbparse.y"
2356     { (yyval.row)= (yyvsp[(1) - (1)].row); }
2357     break;
2358
2359   case 86:
2360 #line 464 "xkbparse.y"
2361     { (yyval.row)= RowDeclCreate((yyvsp[(3) - (5)].key)); }
2362     break;
2363
2364   case 87:
2365 #line 466 "xkbparse.y"
2366     { (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].var); }
2367     break;
2368
2369   case 88:
2370 #line 468 "xkbparse.y"
2371     { (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].doodad); }
2372     break;
2373
2374   case 89:
2375 #line 470 "xkbparse.y"
2376     { (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].ledMap); }
2377     break;
2378
2379   case 90:
2380 #line 472 "xkbparse.y"
2381     { (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].overlay); }
2382     break;
2383
2384   case 91:
2385 #line 476 "xkbparse.y"
2386     { (yyval.key)=(KeyDef *)AppendStmt(&(yyvsp[(1) - (2)].key)->common,&(yyvsp[(2) - (2)].key)->common);}
2387     break;
2388
2389   case 92:
2390 #line 478 "xkbparse.y"
2391     { (yyval.key)= (yyvsp[(1) - (1)].key); }
2392     break;
2393
2394   case 93:
2395 #line 482 "xkbparse.y"
2396     { (yyval.key)= (yyvsp[(3) - (5)].key); }
2397     break;
2398
2399   case 94:
2400 #line 484 "xkbparse.y"
2401     { (yyval.key)= (KeyDef *)(yyvsp[(1) - (1)].var); }
2402     break;
2403
2404   case 95:
2405 #line 488 "xkbparse.y"
2406     { (yyval.key)=(KeyDef *)AppendStmt(&(yyvsp[(1) - (3)].key)->common,&(yyvsp[(3) - (3)].key)->common);}
2407     break;
2408
2409   case 96:
2410 #line 490 "xkbparse.y"
2411     { (yyval.key)= (yyvsp[(1) - (1)].key); }
2412     break;
2413
2414   case 97:
2415 #line 494 "xkbparse.y"
2416     { (yyval.key)= KeyDeclCreate((yyvsp[(1) - (1)].str),NULL); }
2417     break;
2418
2419   case 98:
2420 #line 496 "xkbparse.y"
2421     { (yyval.key)= KeyDeclCreate(NULL,(yyvsp[(2) - (3)].expr)); }
2422     break;
2423
2424   case 99:
2425 #line 500 "xkbparse.y"
2426     { (yyval.overlay)= OverlayDeclCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].olKey)); }
2427     break;
2428
2429   case 100:
2430 #line 504 "xkbparse.y"
2431     {
2432                             (yyval.olKey)= (OverlayKeyDef *)
2433                                 AppendStmt(&(yyvsp[(1) - (3)].olKey)->common,&(yyvsp[(3) - (3)].olKey)->common);
2434                         }
2435     break;
2436
2437   case 101:
2438 #line 509 "xkbparse.y"
2439     { (yyval.olKey)= (yyvsp[(1) - (1)].olKey); }
2440     break;
2441
2442   case 102:
2443 #line 513 "xkbparse.y"
2444     { (yyval.olKey)= OverlayKeyCreate((yyvsp[(1) - (3)].str),(yyvsp[(3) - (3)].str)); }
2445     break;
2446
2447   case 103:
2448 #line 517 "xkbparse.y"
2449     { (yyval.outline)=(OutlineDef *)AppendStmt(&(yyvsp[(1) - (3)].outline)->common,&(yyvsp[(3) - (3)].outline)->common);}
2450     break;
2451
2452   case 104:
2453 #line 519 "xkbparse.y"
2454     { (yyval.outline)= (yyvsp[(1) - (1)].outline); }
2455     break;
2456
2457   case 105:
2458 #line 523 "xkbparse.y"
2459     { (yyval.outline)= OutlineCreate(None,(yyvsp[(2) - (3)].expr)); }
2460     break;
2461
2462   case 106:
2463 #line 525 "xkbparse.y"
2464     { (yyval.outline)= OutlineCreate((yyvsp[(1) - (5)].sval),(yyvsp[(4) - (5)].expr)); }
2465     break;
2466
2467   case 107:
2468 #line 527 "xkbparse.y"
2469     { (yyval.outline)= OutlineCreate((yyvsp[(1) - (3)].sval),(yyvsp[(3) - (3)].expr)); }
2470     break;
2471
2472   case 108:
2473 #line 531 "xkbparse.y"
2474     { (yyval.expr)= (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common,&(yyvsp[(3) - (3)].expr)->common); }
2475     break;
2476
2477   case 109:
2478 #line 533 "xkbparse.y"
2479     { (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2480     break;
2481
2482   case 110:
2483 #line 537 "xkbparse.y"
2484     {
2485                             ExprDef *expr;
2486                             expr= ExprCreate(ExprCoord,TypeUnknown);
2487                             expr->value.coord.x= (yyvsp[(2) - (5)].ival);
2488                             expr->value.coord.y= (yyvsp[(4) - (5)].ival);
2489                             (yyval.expr)= expr;
2490                         }
2491     break;
2492
2493   case 111:
2494 #line 547 "xkbparse.y"
2495     { (yyval.doodad)= DoodadCreate((yyvsp[(1) - (6)].uval),(yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].var)); }
2496     break;
2497
2498   case 112:
2499 #line 550 "xkbparse.y"
2500     { (yyval.uval)= XkbTextDoodad; }
2501     break;
2502
2503   case 113:
2504 #line 551 "xkbparse.y"
2505     { (yyval.uval)= XkbOutlineDoodad; }
2506     break;
2507
2508   case 114:
2509 #line 552 "xkbparse.y"
2510     { (yyval.uval)= XkbSolidDoodad; }
2511     break;
2512
2513   case 115:
2514 #line 553 "xkbparse.y"
2515     { (yyval.uval)= XkbLogoDoodad; }
2516     break;
2517
2518   case 116:
2519 #line 556 "xkbparse.y"
2520     { (yyval.sval)= (yyvsp[(1) - (1)].sval); }
2521     break;
2522
2523   case 117:
2524 #line 557 "xkbparse.y"
2525     { (yyval.sval)= (yyvsp[(1) - (1)].sval); }
2526     break;
2527
2528   case 118:
2529 #line 561 "xkbparse.y"
2530     { (yyval.sval)= XkbInternAtom(NULL,"action",False); }
2531     break;
2532
2533   case 119:
2534 #line 563 "xkbparse.y"
2535     { (yyval.sval)= XkbInternAtom(NULL,"interpret",False); }
2536     break;
2537
2538   case 120:
2539 #line 565 "xkbparse.y"
2540     { (yyval.sval)= XkbInternAtom(NULL,"type",False); }
2541     break;
2542
2543   case 121:
2544 #line 567 "xkbparse.y"
2545     { (yyval.sval)= XkbInternAtom(NULL,"key",False); }
2546     break;
2547
2548   case 122:
2549 #line 569 "xkbparse.y"
2550     { (yyval.sval)= XkbInternAtom(NULL,"group",False); }
2551     break;
2552
2553   case 123:
2554 #line 571 "xkbparse.y"
2555     {(yyval.sval)=XkbInternAtom(NULL,"modifier_map",False);}
2556     break;
2557
2558   case 124:
2559 #line 573 "xkbparse.y"
2560     { (yyval.sval)= XkbInternAtom(NULL,"indicator",False); }
2561     break;
2562
2563   case 125:
2564 #line 575 "xkbparse.y"
2565     { (yyval.sval)= XkbInternAtom(NULL,"shape",False); }
2566     break;
2567
2568   case 126:
2569 #line 577 "xkbparse.y"
2570     { (yyval.sval)= XkbInternAtom(NULL,"row",False); }
2571     break;
2572
2573   case 127:
2574 #line 579 "xkbparse.y"
2575     { (yyval.sval)= XkbInternAtom(NULL,"section",False); }
2576     break;
2577
2578   case 128:
2579 #line 581 "xkbparse.y"
2580     { (yyval.sval)= XkbInternAtom(NULL,"text",False); }
2581     break;
2582
2583   case 129:
2584 #line 584 "xkbparse.y"
2585     { (yyval.uval)= (yyvsp[(1) - (1)].uval); }
2586     break;
2587
2588   case 130:
2589 #line 585 "xkbparse.y"
2590     { (yyval.uval)= MergeDefault; }
2591     break;
2592
2593   case 131:
2594 #line 588 "xkbparse.y"
2595     { (yyval.uval)= MergeDefault; }
2596     break;
2597
2598   case 132:
2599 #line 589 "xkbparse.y"
2600     { (yyval.uval)= MergeAugment; }
2601     break;
2602
2603   case 133:
2604 #line 590 "xkbparse.y"
2605     { (yyval.uval)= MergeOverride; }
2606     break;
2607
2608   case 134:
2609 #line 591 "xkbparse.y"
2610     { (yyval.uval)= MergeReplace; }
2611     break;
2612
2613   case 135:
2614 #line 592 "xkbparse.y"
2615     { (yyval.uval)= MergeAltForm; }
2616     break;
2617
2618   case 136:
2619 #line 595 "xkbparse.y"
2620     { (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2621     break;
2622
2623   case 137:
2624 #line 596 "xkbparse.y"
2625     { (yyval.expr)= NULL; }
2626     break;
2627
2628   case 138:
2629 #line 600 "xkbparse.y"
2630     { (yyval.expr)= (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common,&(yyvsp[(3) - (3)].expr)->common); }
2631     break;
2632
2633   case 139:
2634 #line 602 "xkbparse.y"
2635     { (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2636     break;
2637
2638   case 140:
2639 #line 606 "xkbparse.y"
2640     { (yyval.expr)= ExprCreateBinary(OpDivide,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2641     break;
2642
2643   case 141:
2644 #line 608 "xkbparse.y"
2645     { (yyval.expr)= ExprCreateBinary(OpAdd,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2646     break;
2647
2648   case 142:
2649 #line 610 "xkbparse.y"
2650     { (yyval.expr)= ExprCreateBinary(OpSubtract,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2651     break;
2652
2653   case 143:
2654 #line 612 "xkbparse.y"
2655     { (yyval.expr)= ExprCreateBinary(OpMultiply,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2656     break;
2657
2658   case 144:
2659 #line 614 "xkbparse.y"
2660     { (yyval.expr)= ExprCreateBinary(OpAssign,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2661     break;
2662
2663   case 145:
2664 #line 616 "xkbparse.y"
2665     { (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2666     break;
2667
2668   case 146:
2669 #line 620 "xkbparse.y"
2670     { (yyval.expr)= ExprCreateUnary(OpNegate,(yyvsp[(2) - (2)].expr)->type,(yyvsp[(2) - (2)].expr)); }
2671     break;
2672
2673   case 147:
2674 #line 622 "xkbparse.y"
2675     { (yyval.expr)= ExprCreateUnary(OpUnaryPlus,(yyvsp[(2) - (2)].expr)->type,(yyvsp[(2) - (2)].expr)); }
2676     break;
2677
2678   case 148:
2679 #line 624 "xkbparse.y"
2680     { (yyval.expr)= ExprCreateUnary(OpNot,TypeBoolean,(yyvsp[(2) - (2)].expr)); }
2681     break;
2682
2683   case 149:
2684 #line 626 "xkbparse.y"
2685     { (yyval.expr)= ExprCreateUnary(OpInvert,(yyvsp[(2) - (2)].expr)->type,(yyvsp[(2) - (2)].expr)); }
2686     break;
2687
2688   case 150:
2689 #line 628 "xkbparse.y"
2690     { (yyval.expr)= (yyvsp[(1) - (1)].expr);  }
2691     break;
2692
2693   case 151:
2694 #line 630 "xkbparse.y"
2695     { (yyval.expr)= ActionCreate((yyvsp[(1) - (4)].sval),(yyvsp[(3) - (4)].expr)); }
2696     break;
2697
2698   case 152:
2699 #line 632 "xkbparse.y"
2700     { (yyval.expr)= (yyvsp[(1) - (1)].expr);  }
2701     break;
2702
2703   case 153:
2704 #line 634 "xkbparse.y"
2705     { (yyval.expr)= (yyvsp[(2) - (3)].expr);  }
2706     break;
2707
2708   case 154:
2709 #line 638 "xkbparse.y"
2710     { (yyval.expr)= (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common,&(yyvsp[(3) - (3)].expr)->common); }
2711     break;
2712
2713   case 155:
2714 #line 640 "xkbparse.y"
2715     { (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2716     break;
2717
2718   case 156:
2719 #line 644 "xkbparse.y"
2720     { (yyval.expr)= ActionCreate((yyvsp[(1) - (4)].sval),(yyvsp[(3) - (4)].expr)); }
2721     break;
2722
2723   case 157:
2724 #line 648 "xkbparse.y"
2725     {
2726                             ExprDef *expr;
2727                             expr= ExprCreate(ExprIdent,TypeUnknown);
2728                             expr->value.str= (yyvsp[(1) - (1)].sval);
2729                             (yyval.expr)= expr;
2730                         }
2731     break;
2732
2733   case 158:
2734 #line 655 "xkbparse.y"
2735     {
2736                             ExprDef *expr;
2737                             expr= ExprCreate(ExprFieldRef,TypeUnknown);
2738                             expr->value.field.element= (yyvsp[(1) - (3)].sval);
2739                             expr->value.field.field= (yyvsp[(3) - (3)].sval);
2740                             (yyval.expr)= expr;
2741                         }
2742     break;
2743
2744   case 159:
2745 #line 663 "xkbparse.y"
2746     {
2747                             ExprDef *expr;
2748                             expr= ExprCreate(ExprArrayRef,TypeUnknown);
2749                             expr->value.array.element= None;
2750                             expr->value.array.field= (yyvsp[(1) - (4)].sval);
2751                             expr->value.array.entry= (yyvsp[(3) - (4)].expr);
2752                             (yyval.expr)= expr;
2753                         }
2754     break;
2755
2756   case 160:
2757 #line 672 "xkbparse.y"
2758     {
2759                             ExprDef *expr;
2760                             expr= ExprCreate(ExprArrayRef,TypeUnknown);
2761                             expr->value.array.element= (yyvsp[(1) - (6)].sval);
2762                             expr->value.array.field= (yyvsp[(3) - (6)].sval);
2763                             expr->value.array.entry= (yyvsp[(5) - (6)].expr);
2764                             (yyval.expr)= expr;
2765                         }
2766     break;
2767
2768   case 161:
2769 #line 683 "xkbparse.y"
2770     {
2771                             ExprDef *expr;
2772                             expr= ExprCreate(ExprValue,TypeString);
2773                             expr->value.str= (yyvsp[(1) - (1)].sval);
2774                             (yyval.expr)= expr;
2775                         }
2776     break;
2777
2778   case 162:
2779 #line 690 "xkbparse.y"
2780     {
2781                             ExprDef *expr;
2782                             expr= ExprCreate(ExprValue,TypeInt);
2783                             expr->value.ival= (yyvsp[(1) - (1)].ival);
2784                             (yyval.expr)= expr;
2785                         }
2786     break;
2787
2788   case 163:
2789 #line 697 "xkbparse.y"
2790     {
2791                             ExprDef *expr;
2792                             expr= ExprCreate(ExprValue,TypeFloat);
2793                             expr->value.ival= (yyvsp[(1) - (1)].ival);
2794                             (yyval.expr)= expr;
2795                         }
2796     break;
2797
2798   case 164:
2799 #line 704 "xkbparse.y"
2800     {
2801                             ExprDef *expr;
2802                             expr= ExprCreate(ExprValue,TypeKeyName);
2803                             memset(expr->value.keyName,0,5);
2804                             strncpy(expr->value.keyName,(yyvsp[(1) - (1)].str),4);
2805                             free((yyvsp[(1) - (1)].str));
2806                             (yyval.expr)= expr;
2807                         }
2808     break;
2809
2810   case 165:
2811 #line 714 "xkbparse.y"
2812     { (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2813     break;
2814
2815   case 166:
2816 #line 715 "xkbparse.y"
2817     { (yyval.expr)= NULL; }
2818     break;
2819
2820   case 167:
2821 #line 719 "xkbparse.y"
2822     { (yyval.expr)= AppendKeysymList((yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].str)); }
2823     break;
2824
2825   case 168:
2826 #line 721 "xkbparse.y"
2827     { (yyval.expr)= CreateKeysymList((yyvsp[(1) - (1)].str)); }
2828     break;
2829
2830   case 169:
2831 #line 724 "xkbparse.y"
2832     { (yyval.str)= strdup(scanBuf); }
2833     break;
2834
2835   case 170:
2836 #line 725 "xkbparse.y"
2837     { (yyval.str)= strdup("section"); }
2838     break;
2839
2840   case 171:
2841 #line 727 "xkbparse.y"
2842     {
2843                             if ((yyvsp[(1) - (1)].ival)<10)     { (yyval.str)= malloc(2); (yyval.str)[0]= '0' + (yyvsp[(1) - (1)].ival); (yyval.str)[1]= '\0'; }
2844                             else        { (yyval.str)= malloc(19); snprintf((yyval.str), 19, "0x%x", (yyvsp[(1) - (1)].ival)); }
2845                         }
2846     break;
2847
2848   case 172:
2849 #line 733 "xkbparse.y"
2850     { (yyval.ival)= -(yyvsp[(2) - (2)].ival); }
2851     break;
2852
2853   case 173:
2854 #line 734 "xkbparse.y"
2855     { (yyval.ival)= (yyvsp[(1) - (1)].ival); }
2856     break;
2857
2858   case 174:
2859 #line 737 "xkbparse.y"
2860     { (yyval.ival)= scanInt; }
2861     break;
2862
2863   case 175:
2864 #line 738 "xkbparse.y"
2865     { (yyval.ival)= scanInt*XkbGeomPtsPerMM; }
2866     break;
2867
2868   case 176:
2869 #line 741 "xkbparse.y"
2870     { (yyval.ival)= scanInt; }
2871     break;
2872
2873   case 177:
2874 #line 744 "xkbparse.y"
2875     { (yyval.ival)= scanInt; }
2876     break;
2877
2878   case 178:
2879 #line 747 "xkbparse.y"
2880     { (yyval.str)= strdup(scanBuf); }
2881     break;
2882
2883   case 179:
2884 #line 750 "xkbparse.y"
2885     { (yyval.sval)= XkbInternAtom(NULL,scanBuf,False); }
2886     break;
2887
2888   case 180:
2889 #line 751 "xkbparse.y"
2890     { (yyval.sval)= XkbInternAtom(NULL,"default",False); }
2891     break;
2892
2893   case 181:
2894 #line 754 "xkbparse.y"
2895     { (yyval.sval)= XkbInternAtom(NULL,scanBuf,False); }
2896     break;
2897
2898   case 182:
2899 #line 757 "xkbparse.y"
2900     { (yyval.str)= (yyvsp[(1) - (1)].str); }
2901     break;
2902
2903   case 183:
2904 #line 758 "xkbparse.y"
2905     { (yyval.str)= NULL; }
2906     break;
2907
2908   case 184:
2909 #line 761 "xkbparse.y"
2910     { (yyval.str)= strdup(scanBuf); }
2911     break;
2912
2913
2914 /* Line 1267 of yacc.c.  */
2915 #line 2916 "xkbparse.c"
2916       default: break;
2917     }
2918   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2919
2920   YYPOPSTACK (yylen);
2921   yylen = 0;
2922   YY_STACK_PRINT (yyss, yyssp);
2923
2924   *++yyvsp = yyval;
2925
2926
2927   /* Now `shift' the result of the reduction.  Determine what state
2928      that goes to, based on the state we popped back to and the rule
2929      number reduced by.  */
2930
2931   yyn = yyr1[yyn];
2932
2933   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2934   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2935     yystate = yytable[yystate];
2936   else
2937     yystate = yydefgoto[yyn - YYNTOKENS];
2938
2939   goto yynewstate;
2940
2941
2942 /*------------------------------------.
2943 | yyerrlab -- here on detecting error |
2944 `------------------------------------*/
2945 yyerrlab:
2946   /* If not already recovering from an error, report this error.  */
2947   if (!yyerrstatus)
2948     {
2949       ++yynerrs;
2950 #if ! YYERROR_VERBOSE
2951       yyerror (YY_("syntax error"));
2952 #else
2953       {
2954         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2955         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2956           {
2957             YYSIZE_T yyalloc = 2 * yysize;
2958             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2959               yyalloc = YYSTACK_ALLOC_MAXIMUM;
2960             if (yymsg != yymsgbuf)
2961               YYSTACK_FREE (yymsg);
2962             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2963             if (yymsg)
2964               yymsg_alloc = yyalloc;
2965             else
2966               {
2967                 yymsg = yymsgbuf;
2968                 yymsg_alloc = sizeof yymsgbuf;
2969               }
2970           }
2971
2972         if (0 < yysize && yysize <= yymsg_alloc)
2973           {
2974             (void) yysyntax_error (yymsg, yystate, yychar);
2975             yyerror (yymsg);
2976           }
2977         else
2978           {
2979             yyerror (YY_("syntax error"));
2980             if (yysize != 0)
2981               goto yyexhaustedlab;
2982           }
2983       }
2984 #endif
2985     }
2986
2987
2988
2989   if (yyerrstatus == 3)
2990     {
2991       /* If just tried and failed to reuse look-ahead token after an
2992          error, discard it.  */
2993
2994       if (yychar <= YYEOF)
2995         {
2996           /* Return failure if at end of input.  */
2997           if (yychar == YYEOF)
2998             YYABORT;
2999         }
3000       else
3001         {
3002           yydestruct ("Error: discarding",
3003                       yytoken, &yylval);
3004           yychar = YYEMPTY;
3005         }
3006     }
3007
3008   /* Else will try to reuse look-ahead token after shifting the error
3009      token.  */
3010   goto yyerrlab1;
3011
3012
3013 /*---------------------------------------------------.
3014 | yyerrorlab -- error raised explicitly by YYERROR.  |
3015 `---------------------------------------------------*/
3016 yyerrorlab:
3017
3018   /* Pacify compilers like GCC when the user code never invokes
3019      YYERROR and the label yyerrorlab therefore never appears in user
3020      code.  */
3021   if (/*CONSTCOND*/ 0)
3022      goto yyerrorlab;
3023
3024   /* Do not reclaim the symbols of the rule which action triggered
3025      this YYERROR.  */
3026   YYPOPSTACK (yylen);
3027   yylen = 0;
3028   YY_STACK_PRINT (yyss, yyssp);
3029   yystate = *yyssp;
3030   goto yyerrlab1;
3031
3032
3033 /*-------------------------------------------------------------.
3034 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
3035 `-------------------------------------------------------------*/
3036 yyerrlab1:
3037   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3038
3039   for (;;)
3040     {
3041       yyn = yypact[yystate];
3042       if (yyn != YYPACT_NINF)
3043         {
3044           yyn += YYTERROR;
3045           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3046             {
3047               yyn = yytable[yyn];
3048               if (0 < yyn)
3049                 break;
3050             }
3051         }
3052
3053       /* Pop the current state because it cannot handle the error token.  */
3054       if (yyssp == yyss)
3055         YYABORT;
3056
3057
3058       yydestruct ("Error: popping",
3059                   yystos[yystate], yyvsp);
3060       YYPOPSTACK (1);
3061       yystate = *yyssp;
3062       YY_STACK_PRINT (yyss, yyssp);
3063     }
3064
3065   if (yyn == YYFINAL)
3066     YYACCEPT;
3067
3068   *++yyvsp = yylval;
3069
3070
3071   /* Shift the error token.  */
3072   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3073
3074   yystate = yyn;
3075   goto yynewstate;
3076
3077
3078 /*-------------------------------------.
3079 | yyacceptlab -- YYACCEPT comes here.  |
3080 `-------------------------------------*/
3081 yyacceptlab:
3082   yyresult = 0;
3083   goto yyreturn;
3084
3085 /*-----------------------------------.
3086 | yyabortlab -- YYABORT comes here.  |
3087 `-----------------------------------*/
3088 yyabortlab:
3089   yyresult = 1;
3090   goto yyreturn;
3091
3092 #ifndef yyoverflow
3093 /*-------------------------------------------------.
3094 | yyexhaustedlab -- memory exhaustion comes here.  |
3095 `-------------------------------------------------*/
3096 yyexhaustedlab:
3097   yyerror (YY_("memory exhausted"));
3098   yyresult = 2;
3099   /* Fall through.  */
3100 #endif
3101
3102 yyreturn:
3103   if (yychar != YYEOF && yychar != YYEMPTY)
3104      yydestruct ("Cleanup: discarding lookahead",
3105                  yytoken, &yylval);
3106   /* Do not reclaim the symbols of the rule which action triggered
3107      this YYABORT or YYACCEPT.  */
3108   YYPOPSTACK (yylen);
3109   YY_STACK_PRINT (yyss, yyssp);
3110   while (yyssp != yyss)
3111     {
3112       yydestruct ("Cleanup: popping",
3113                   yystos[*yyssp], yyvsp);
3114       YYPOPSTACK (1);
3115     }
3116 #ifndef yyoverflow
3117   if (yyss != yyssa)
3118     YYSTACK_FREE (yyss);
3119 #endif
3120 #if YYERROR_VERBOSE
3121   if (yymsg != yymsgbuf)
3122     YYSTACK_FREE (yymsg);
3123 #endif
3124   /* Make sure YYID is used.  */
3125   return YYID (yyresult);
3126 }
3127
3128
3129 #line 763 "xkbparse.y"
3130
3131 void
3132 yyerror(const char *s)
3133 {
3134     if (warningLevel>0) {
3135         (void)fprintf(stderr,"%s: line %d of %s\n",s,lineNum,
3136                                         (scanFile?scanFile:"(unknown)"));
3137         if ((warningLevel>3))
3138             (void)fprintf(stderr,"last scanned symbol is: %s\n",scanBuf);
3139     }
3140     return;
3141 }
3142
3143
3144 int
3145 yywrap(void)
3146 {
3147    return 1;
3148 }
3149
3150