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