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