xkbparse.c revision 83e5f723
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 214unsigned 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 237typedef 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 288typedef YYTYPE_UINT8 yytype_uint8; 289#else 290typedef unsigned char yytype_uint8; 291#endif 292 293#ifdef YYTYPE_INT8 294typedef YYTYPE_INT8 yytype_int8; 295#elif (defined __STDC__ || defined __C99__FUNC__ \ 296 || defined __cplusplus || defined _MSC_VER) 297typedef signed char yytype_int8; 298#else 299typedef short int yytype_int8; 300#endif 301 302#ifdef YYTYPE_UINT16 303typedef YYTYPE_UINT16 yytype_uint16; 304#else 305typedef unsigned short int yytype_uint16; 306#endif 307 308#ifdef YYTYPE_INT16 309typedef YYTYPE_INT16 yytype_int16; 310#else 311typedef 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) 355static int 356YYID (int i) 357#else 358static int 359YYID (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) 423void *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) 430void 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. */ 442union 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. */ 515static 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. */ 548static 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. */ 572static 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. */ 634static 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. */ 661static 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. */ 695static 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. */ 708static 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. */ 732static 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. */ 758static 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]. */ 797static 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 812static 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]. */ 851static 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 868static 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 943static 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. */ 1020static 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) \ 1077do \ 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 } \ 1091while (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) \ 1157do { \ 1158 if (yydebug) \ 1159 YYFPRINTF Args; \ 1160} while (YYID (0)) 1161 1162# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1163do { \ 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) 1181static void 1182yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1183#else 1184static void 1185yy_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) 1213static void 1214yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1215#else 1216static void 1217yy_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) 1239static void 1240yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 1241#else 1242static void 1243yy_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) \ 1255do { \ 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) 1267static void 1268yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1269#else 1270static void 1271yy_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) \ 1293do { \ 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. */ 1300int 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 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) 1336static YYSIZE_T 1337yystrlen (const char *yystr) 1338#else 1339static YYSIZE_T 1340yystrlen (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) 1360static char * 1361yystpcpy (char *yydest, const char *yysrc) 1362#else 1363static char * 1364yystpcpy (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. */ 1388static YYSIZE_T 1389yytnamerr (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. */ 1435static YYSIZE_T 1436yysyntax_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 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) 1545static void 1546yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1547#else 1548static void 1549yydestruct (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 1569 1570/* Prevent warnings from -Wmissing-prototypes. */ 1571 1572#ifdef YYPARSE_PARAM 1573#if defined __STDC__ || defined __cplusplus 1574int yyparse (void *YYPARSE_PARAM); 1575#else 1576int yyparse (); 1577#endif 1578#else /* ! YYPARSE_PARAM */ 1579#if defined __STDC__ || defined __cplusplus 1580int yyparse (void); 1581#else 1582int yyparse (); 1583#endif 1584#endif /* ! YYPARSE_PARAM */ 1585 1586 1587 1588/* The look-ahead symbol. */ 1589int yychar; 1590 1591/* The semantic value of the look-ahead symbol. */ 1592YYSTYPE yylval; 1593 1594/* Number of syntax errors so far. */ 1595int 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) 1606int 1607yyparse (void *YYPARSE_PARAM) 1608#else 1609int 1610yyparse (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) 1616int 1617yyparse (void) 1618#else 1619int 1620yyparse () 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`-----------*/ 1773yybackup: 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`-----------------------------------------------------------*/ 1841yydefault: 1842 yyn = yydefact[yystate]; 1843 if (yyn == 0) 1844 goto yyerrlab; 1845 goto yyreduce; 1846 1847 1848/*-----------------------------. 1849| yyreduce -- Do a reduction. | 1850`-----------------------------*/ 1851yyreduce: 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(XStringToKeysym((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].expr)); } 2228 break; 2229 2230 case 61: 2231#line 379 "xkbparse.y" 2232 { (yyval.interp)= InterpCreate(XStringToKeysym((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`------------------------------------*/ 2945yyerrlab: 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`---------------------------------------------------*/ 3016yyerrorlab: 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`-------------------------------------------------------------*/ 3036yyerrlab1: 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`-------------------------------------*/ 3081yyacceptlab: 3082 yyresult = 0; 3083 goto yyreturn; 3084 3085/*-----------------------------------. 3086| yyabortlab -- YYABORT comes here. | 3087`-----------------------------------*/ 3088yyabortlab: 3089 yyresult = 1; 3090 goto yyreturn; 3091 3092#ifndef yyoverflow 3093/*-------------------------------------------------. 3094| yyexhaustedlab -- memory exhaustion comes here. | 3095`-------------------------------------------------*/ 3096yyexhaustedlab: 3097 yyerror (YY_("memory exhausted")); 3098 yyresult = 2; 3099 /* Fall through. */ 3100#endif 3101 3102yyreturn: 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 3131void 3132yyerror(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 3144int 3145yywrap(void) 3146{ 3147 return 1; 3148} 3149 3150 3151