tools/perf/util/pmu-bison.c

   1 /* A Bison parser, made by GNU Bison 2.4.3.  */
   2
   3 /* Skeleton implementation for Bison's Yacc-like parsers in C
   4
   5       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   6    2009, 2010 Free Software Foundation, Inc.
   7
   8    This program is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 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 /* All symbols defined below should begin with yy or YY, to avoid
  38    infringing on user name space.  This should be done even for local
  39    variables, as they might otherwise be expanded by user macros.
  40    There are some unavoidable exceptions within include files to
  41    define necessary library symbols; they are noted "INFRINGES ON
  42    USER NAME SPACE" below.  */
  43
  44 /* Identify Bison output.  */
  45 #define YYBISON 1
  46
  47 /* Bison version.  */
  48 #define YYBISON_VERSION "2.4.3"
  49
  50 /* Skeleton name.  */
  51 #define YYSKELETON_NAME "yacc.c"
  52
  53 /* Pure parsers.  */
  54 #define YYPURE 0
  55
  56 /* Push parsers.  */
  57 #define YYPUSH 0
  58
  59 /* Pull parsers.  */
  60 #define YYPULL 1
  61
  62 /* Using locations.  */
  63 #define YYLSP_NEEDED 0
  64
  65 /* Substitute the variable and function names.  */
  66 #define yyparse         perf_pmu_parse
  67 #define yylex           perf_pmu_lex
  68 #define yyerror         perf_pmu_error
  69 #define yylval          perf_pmu_lval
  70 #define yychar          perf_pmu_char
  71 #define yydebug         perf_pmu_debug
  72 #define yynerrs         perf_pmu_nerrs
  73
  74
  75 /* Copy the first part of user declarations.  */
  76
  77 /* Line 189 of yacc.c  */
  78 #line 6 "util/pmu.y"
  79
  80
  81 #include <linux/compiler.h>
  82 #include <linux/list.h>
  83 #include <linux/bitmap.h>
  84 #include <string.h>
  85 #include "pmu.h"
  86
  87 extern int perf_pmu_lex (void);
  88
  89 #define ABORT_ON(val) \
  90 do { \
  91         if (val) \
  92                 YYABORT; \
  93 } while (0)
  94
  95
  96
  97 /* Line 189 of yacc.c  */
  98 #line 99 "util/pmu-bison.c"
  99
 100 /* Enabling traces.  */
 101 #ifndef YYDEBUG
 102 # define YYDEBUG 0
 103 #endif
 104
 105 /* Enabling verbose error messages.  */
 106 #ifdef YYERROR_VERBOSE
 107 # undef YYERROR_VERBOSE
 108 # define YYERROR_VERBOSE 1
 109 #else
 110 # define YYERROR_VERBOSE 0
 111 #endif
 112
 113 /* Enabling the token table.  */
 114 #ifndef YYTOKEN_TABLE
 115 # define YYTOKEN_TABLE 0
 116 #endif
 117
 118
 119 /* Tokens.  */
 120 #ifndef YYTOKENTYPE
 121 # define YYTOKENTYPE
 122    /* Put the tokens into the symbol table, so that GDB and other debuggers
 123       know about them.  */
 124    enum yytokentype {
 125      PP_CONFIG = 258,
 126      PP_CONFIG1 = 259,
 127      PP_CONFIG2 = 260,
 128      PP_VALUE = 261,
 129      PP_ERROR = 262
 130    };
 131 #endif
 132
 133
 134
 135 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 136 typedef union YYSTYPE
 137 {
 138
 139 /* Line 214 of yacc.c  */
 140 #line 31 "util/pmu.y"
 141
 142         unsigned long num;
 143         DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
 144
 145
 146
 147 /* Line 214 of yacc.c  */
 148 #line 149 "util/pmu-bison.c"
 149 } YYSTYPE;
 150 # define YYSTYPE_IS_TRIVIAL 1
 151 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 152 # define YYSTYPE_IS_DECLARED 1
 153 #endif
 154
 155
 156 /* Copy the second part of user declarations.  */
 157
 158
 159 /* Line 264 of yacc.c  */
 160 #line 161 "util/pmu-bison.c"
 161
 162 #ifdef short
 163 # undef short
 164 #endif
 165
 166 #ifdef YYTYPE_UINT8
 167 typedef YYTYPE_UINT8 yytype_uint8;
 168 #else
 169 typedef unsigned char yytype_uint8;
 170 #endif
 171
 172 #ifdef YYTYPE_INT8
 173 typedef YYTYPE_INT8 yytype_int8;
 174 #elif (defined __STDC__ || defined __C99__FUNC__ \
 175      || defined __cplusplus || defined _MSC_VER)
 176 typedef signed char yytype_int8;
 177 #else
 178 typedef short int yytype_int8;
 179 #endif
 180
 181 #ifdef YYTYPE_UINT16
 182 typedef YYTYPE_UINT16 yytype_uint16;
 183 #else
 184 typedef unsigned short int yytype_uint16;
 185 #endif
 186
 187 #ifdef YYTYPE_INT16
 188 typedef YYTYPE_INT16 yytype_int16;
 189 #else
 190 typedef short int yytype_int16;
 191 #endif
 192
 193 #ifndef YYSIZE_T
 194 # ifdef __SIZE_TYPE__
 195 #  define YYSIZE_T __SIZE_TYPE__
 196 # elif defined size_t
 197 #  define YYSIZE_T size_t
 198 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 199      || defined __cplusplus || defined _MSC_VER)
 200 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 201 #  define YYSIZE_T size_t
 202 # else
 203 #  define YYSIZE_T unsigned int
 204 # endif
 205 #endif
 206
 207 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 208
 209 #ifndef YY_
 210 # if defined YYENABLE_NLS && YYENABLE_NLS
 211 #  if ENABLE_NLS
 212 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 213 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 214 #  endif
 215 # endif
 216 # ifndef YY_
 217 #  define YY_(msgid) msgid
 218 # endif
 219 #endif
 220
 221 /* Suppress unused-variable warnings by "using" E.  */
 222 #if ! defined lint || defined __GNUC__
 223 # define YYUSE(e) ((void) (e))
 224 #else
 225 # define YYUSE(e) /* empty */
 226 #endif
 227
 228 /* Identity function, used to suppress warnings about constant conditions.  */
 229 #ifndef lint
 230 # define YYID(n) (n)
 231 #else
 232 #if (defined __STDC__ || defined __C99__FUNC__ \
 233      || defined __cplusplus || defined _MSC_VER)
 234 static int
 235 YYID (int yyi)
 236 #else
 237 static int
 238 YYID (yyi)
 239     int yyi;
 240 #endif
 241 {
 242   return yyi;
 243 }
 244 #endif
 245
 246 #if ! defined yyoverflow || YYERROR_VERBOSE
 247
 248 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 249
 250 # ifdef YYSTACK_USE_ALLOCA
 251 #  if YYSTACK_USE_ALLOCA
 252 #   ifdef __GNUC__
 253 #    define YYSTACK_ALLOC __builtin_alloca
 254 #   elif defined __BUILTIN_VA_ARG_INCR
 255 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 256 #   elif defined _AIX
 257 #    define YYSTACK_ALLOC __alloca
 258 #   elif defined _MSC_VER
 259 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 260 #    define alloca _alloca
 261 #   else
 262 #    define YYSTACK_ALLOC alloca
 263 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 264      || defined __cplusplus || defined _MSC_VER)
 265 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 266 #     ifndef _STDLIB_H
 267 #      define _STDLIB_H 1
 268 #     endif
 269 #    endif
 270 #   endif
 271 #  endif
 272 # endif
 273
 274 # ifdef YYSTACK_ALLOC
 275    /* Pacify GCC's `empty if-body' warning.  */
 276 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 277 #  ifndef YYSTACK_ALLOC_MAXIMUM
 278     /* The OS might guarantee only one guard page at the bottom of the stack,
 279        and a page size can be as small as 4096 bytes.  So we cannot safely
 280        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 281        to allow for a few compiler-allocated temporary stack slots.  */
 282 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 283 #  endif
 284 # else
 285 #  define YYSTACK_ALLOC YYMALLOC
 286 #  define YYSTACK_FREE YYFREE
 287 #  ifndef YYSTACK_ALLOC_MAXIMUM
 288 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 289 #  endif
 290 #  if (defined __cplusplus && ! defined _STDLIB_H \
 291        && ! ((defined YYMALLOC || defined malloc) \
 292              && (defined YYFREE || defined free)))
 293 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 294 #   ifndef _STDLIB_H
 295 #    define _STDLIB_H 1
 296 #   endif
 297 #  endif
 298 #  ifndef YYMALLOC
 299 #   define YYMALLOC malloc
 300 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 301      || defined __cplusplus || defined _MSC_VER)
 302 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 303 #   endif
 304 #  endif
 305 #  ifndef YYFREE
 306 #   define YYFREE free
 307 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 308      || defined __cplusplus || defined _MSC_VER)
 309 void free (void *); /* INFRINGES ON USER NAME SPACE */
 310 #   endif
 311 #  endif
 312 # endif
 313 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 314
 315
 316 #if (! defined yyoverflow \
 317      && (! defined __cplusplus \
 318          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 319
 320 /* A type that is properly aligned for any stack member.  */
 321 union yyalloc
 322 {
 323   yytype_int16 yyss_alloc;
 324   YYSTYPE yyvs_alloc;
 325 };
 326
 327 /* The size of the maximum gap between one aligned stack and the next.  */
 328 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 329
 330 /* The size of an array large to enough to hold all stacks, each with
 331    N elements.  */
 332 # define YYSTACK_BYTES(N) \
 333      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 334       + YYSTACK_GAP_MAXIMUM)
 335
 336 /* Copy COUNT objects from FROM to TO.  The source and destination do
 337    not overlap.  */
 338 # ifndef YYCOPY
 339 #  if defined __GNUC__ && 1 < __GNUC__
 340 #   define YYCOPY(To, From, Count) \
 341       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 342 #  else
 343 #   define YYCOPY(To, From, Count)              \
 344       do                                        \
 345         {                                       \
 346           YYSIZE_T yyi;                         \
 347           for (yyi = 0; yyi < (Count); yyi++)   \
 348             (To)[yyi] = (From)[yyi];            \
 349         }                                       \
 350       while (YYID (0))
 351 #  endif
 352 # endif
 353
 354 /* Relocate STACK from its old location to the new one.  The
 355    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 356    elements in the stack, and YYPTR gives the new location of the
 357    stack.  Advance YYPTR to a properly aligned location for the next
 358    stack.  */
 359 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 360     do                                                                  \
 361       {                                                                 \
 362         YYSIZE_T yynewbytes;                                            \
 363         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 364         Stack = &yyptr->Stack_alloc;                                    \
 365         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 366         yyptr += yynewbytes / sizeof (*yyptr);                          \
 367       }                                                                 \
 368     while (YYID (0))
 369
 370 #endif
 371
 372 /* YYFINAL -- State number of the termination state.  */
 373 #define YYFINAL  9
 374 /* YYLAST -- Last index in YYTABLE.  */
 375 #define YYLAST   17
 376
 377 /* YYNTOKENS -- Number of terminals.  */
 378 #define YYNTOKENS  11
 379 /* YYNNTS -- Number of nonterminals.  */
 380 #define YYNNTS  5
 381 /* YYNRULES -- Number of rules.  */
 382 #define YYNRULES  10
 383 /* YYNRULES -- Number of states.  */
 384 #define YYNSTATES  20
 385
 386 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 387 #define YYUNDEFTOK  2
 388 #define YYMAXUTOK   262
 389
 390 #define YYTRANSLATE(YYX)                                                \
 391   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 392
 393 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 394 static const yytype_uint8 yytranslate[] =
 395 {
 396        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 397        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 398        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 399        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 400        2,     2,     2,     2,     9,    10,     2,     2,     2,     2,
 401        2,     2,     2,     2,     2,     2,     2,     2,     8,     2,
 402        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 403        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 404        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 405        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 406        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 407        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 408        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 409        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 410        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 411        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 412        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 413        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 414        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 415        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 416        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 417        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 418        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 419        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 420        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 421        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 422        5,     6,     7
 423 };
 424
 425 #if YYDEBUG
 426 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 427    YYRHS.  */
 428 static const yytype_uint8 yyprhs[] =
 429 {
 430        0,     0,     3,     6,     8,    12,    16,    20,    24,    26,
 431       30
 432 };
 433
 434 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 435 static const yytype_int8 yyrhs[] =
 436 {
 437       12,     0,    -1,    12,    13,    -1,    13,    -1,     3,     8,
 438       14,    -1,     4,     8,    14,    -1,     5,     8,    14,    -1,
 439       14,     9,    15,    -1,    15,    -1,     6,    10,     6,    -1,
 440        6,    -1
 441 };
 442
 443 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 444 static const yytype_uint8 yyrline[] =
 445 {
 446        0,    39,    39,    41,    44,    51,    58,    66,    71,    77,
 447       82
 448 };
 449 #endif
 450
 451 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 452 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 453    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 454 static const char *const yytname[] =
 455 {
 456   "$end", "error", "$undefined", "PP_CONFIG", "PP_CONFIG1", "PP_CONFIG2",
 457   "PP_VALUE", "PP_ERROR", "':'", "','", "'-'", "$accept", "format",
 458   "format_term", "bits", "bit_term", 0
 459 };
 460 #endif
 461
 462 # ifdef YYPRINT
 463 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 464    token YYLEX-NUM.  */
 465 static const yytype_uint16 yytoknum[] =
 466 {
 467        0,   256,   257,   258,   259,   260,   261,   262,    58,    44,
 468       45
 469 };
 470 # endif
 471
 472 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 473 static const yytype_uint8 yyr1[] =
 474 {
 475        0,    11,    12,    12,    13,    13,    13,    14,    14,    15,
 476       15
 477 };
 478
 479 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 480 static const yytype_uint8 yyr2[] =
 481 {
 482        0,     2,     2,     1,     3,     3,     3,     3,     1,     3,
 483        1
 484 };
 485
 486 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 487    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 488    means the default is an error.  */
 489 static const yytype_uint8 yydefact[] =
 490 {
 491        0,     0,     0,     0,     0,     3,     0,     0,     0,     1,
 492        2,    10,     4,     8,     5,     6,     0,     0,     9,     7
 493 };
 494
 495 /* YYDEFGOTO[NTERM-NUM].  */
 496 static const yytype_int8 yydefgoto[] =
 497 {
 498       -1,     4,     5,    12,    13
 499 };
 500
 501 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 502    STATE-NUM.  */
 503 #define YYPACT_NINF -7
 504 static const yytype_int8 yypact[] =
 505 {
 506        3,     1,     2,     4,     0,    -7,     5,     5,     5,    -7,
 507       -7,     6,     8,    -7,     8,     8,     7,     5,    -7,    -7
 508 };
 509
 510 /* YYPGOTO[NTERM-NUM].  */
 511 static const yytype_int8 yypgoto[] =
 512 {
 513       -7,    -7,    10,    -6,    -2
 514 };
 515
 516 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 517    positive, shift that token.  If negative, reduce the rule which
 518    number is the opposite.  If zero, do what YYDEFACT says.
 519    If YYTABLE_NINF, syntax error.  */
 520 #define YYTABLE_NINF -1
 521 static const yytype_uint8 yytable[] =
 522 {
 523        9,    14,    15,     1,     2,     3,     1,     2,     3,     6,
 524        7,    11,     8,    18,    10,    19,    16,    17
 525 };
 526
 527 static const yytype_uint8 yycheck[] =
 528 {
 529        0,     7,     8,     3,     4,     5,     3,     4,     5,     8,
 530        8,     6,     8,     6,     4,    17,    10,     9
 531 };
 532
 533 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 534    symbol of state STATE-NUM.  */
 535 static const yytype_uint8 yystos[] =
 536 {
 537        0,     3,     4,     5,    12,    13,     8,     8,     8,     0,
 538       13,     6,    14,    15,    14,    14,    10,     9,     6,    15
 539 };
 540
 541 #define yyerrok         (yyerrstatus = 0)
 542 #define yyclearin       (yychar = YYEMPTY)
 543 #define YYEMPTY         (-2)
 544 #define YYEOF           0
 545
 546 #define YYACCEPT        goto yyacceptlab
 547 #define YYABORT         goto yyabortlab
 548 #define YYERROR         goto yyerrorlab
 549
 550
 551 /* Like YYERROR except do call yyerror.  This remains here temporarily
 552    to ease the transition to the new meaning of YYERROR, for GCC.
 553    Once GCC version 2 has supplanted version 1, this can go.  However,
 554    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
 555    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
 556    discussed.  */
 557
 558 #define YYFAIL          goto yyerrlab
 559 #if defined YYFAIL
 560   /* This is here to suppress warnings from the GCC cpp's
 561      -Wunused-macros.  Normally we don't worry about that warning, but
 562      some users do, and we want to make it easy for users to remove
 563      YYFAIL uses, which will produce warnings from Bison 2.5.  */
 564 #endif
 565
 566 #define YYRECOVERING()  (!!yyerrstatus)
 567
 568 #define YYBACKUP(Token, Value)                                  \
 569 do                                                              \
 570   if (yychar == YYEMPTY && yylen == 1)                          \
 571     {                                                           \
 572       yychar = (Token);                                         \
 573       yylval = (Value);                                         \
 574       yytoken = YYTRANSLATE (yychar);                           \
 575       YYPOPSTACK (1);                                           \
 576       goto yybackup;                                            \
 577     }                                                           \
 578   else                                                          \
 579     {                                                           \
 580       yyerror (format, name, YY_("syntax error: cannot back up")); \
 581       YYERROR;                                                  \
 582     }                                                           \
 583 while (YYID (0))
 584
 585
 586 #define YYTERROR        1
 587 #define YYERRCODE       256
 588
 589
 590 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 591    If N is 0, then set CURRENT to the empty location which ends
 592    the previous symbol: RHS[0] (always defined).  */
 593
 594 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
 595 #ifndef YYLLOC_DEFAULT
 596 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 597     do                                                                  \
 598       if (YYID (N))                                                    \
 599         {                                                               \
 600           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 601           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 602           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 603           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 604         }                                                               \
 605       else                                                              \
 606         {                                                               \
 607           (Current).first_line   = (Current).last_line   =              \
 608             YYRHSLOC (Rhs, 0).last_line;                                \
 609           (Current).first_column = (Current).last_column =              \
 610             YYRHSLOC (Rhs, 0).last_column;                              \
 611         }                                                               \
 612     while (YYID (0))
 613 #endif
 614
 615
 616 /* YY_LOCATION_PRINT -- Print the location on the stream.
 617    This macro was not mandated originally: define only if we know
 618    we won't break user code: when these are the locations we know.  */
 619
 620 #ifndef YY_LOCATION_PRINT
 621 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
 622 #  define YY_LOCATION_PRINT(File, Loc)                  \
 623      fprintf (File, "%d.%d-%d.%d",                      \
 624               (Loc).first_line, (Loc).first_column,     \
 625               (Loc).last_line,  (Loc).last_column)
 626 # else
 627 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 628 # endif
 629 #endif
 630
 631
 632 /* YYLEX -- calling `yylex' with the right arguments.  */
 633
 634 #ifdef YYLEX_PARAM
 635 # define YYLEX yylex (YYLEX_PARAM)
 636 #else
 637 # define YYLEX yylex ()
 638 #endif
 639
 640 /* Enable debugging if requested.  */
 641 #if YYDEBUG
 642
 643 # ifndef YYFPRINTF
 644 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 645 #  define YYFPRINTF fprintf
 646 # endif
 647
 648 # define YYDPRINTF(Args)                        \
 649 do {                                            \
 650   if (yydebug)                                  \
 651     YYFPRINTF Args;                             \
 652 } while (YYID (0))
 653
 654 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 655 do {                                                                      \
 656   if (yydebug)                                                            \
 657     {                                                                     \
 658       YYFPRINTF (stderr, "%s ", Title);                                   \
 659       yy_symbol_print (stderr,                                            \
 660                   Type, Value, format, name); \
 661       YYFPRINTF (stderr, "\n");                                           \
 662     }                                                                     \
 663 } while (YYID (0))
 664
 665
 666 /*--------------------------------.
 667 | Print this symbol on YYOUTPUT.  |
 668 `--------------------------------*/
 669
 670 /*ARGSUSED*/
 671 #if (defined __STDC__ || defined __C99__FUNC__ \
 672      || defined __cplusplus || defined _MSC_VER)
 673 static void
 674 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name)
 675 #else
 676 static void
 677 yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name)
 678     FILE *yyoutput;
 679     int yytype;
 680     YYSTYPE const * const yyvaluep;
 681     struct list_head *format;
 682     char *name;
 683 #endif
 684 {
 685   if (!yyvaluep)
 686     return;
 687   YYUSE (format);
 688   YYUSE (name);
 689 # ifdef YYPRINT
 690   if (yytype < YYNTOKENS)
 691     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 692 # else
 693   YYUSE (yyoutput);
 694 # endif
 695   switch (yytype)
 696     {
 697       default:
 698         break;
 699     }
 700 }
 701
 702
 703 /*--------------------------------.
 704 | Print this symbol on YYOUTPUT.  |
 705 `--------------------------------*/
 706
 707 #if (defined __STDC__ || defined __C99__FUNC__ \
 708      || defined __cplusplus || defined _MSC_VER)
 709 static void
 710 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, struct list_head *format, char *name)
 711 #else
 712 static void
 713 yy_symbol_print (yyoutput, yytype, yyvaluep, format, name)
 714     FILE *yyoutput;
 715     int yytype;
 716     YYSTYPE const * const yyvaluep;
 717     struct list_head *format;
 718     char *name;
 719 #endif
 720 {
 721   if (yytype < YYNTOKENS)
 722     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 723   else
 724     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 725
 726   yy_symbol_value_print (yyoutput, yytype, yyvaluep, format, name);
 727   YYFPRINTF (yyoutput, ")");
 728 }
 729
 730 /*------------------------------------------------------------------.
 731 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 732 | TOP (included).                                                   |
 733 `------------------------------------------------------------------*/
 734
 735 #if (defined __STDC__ || defined __C99__FUNC__ \
 736      || defined __cplusplus || defined _MSC_VER)
 737 static void
 738 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
 739 #else
 740 static void
 741 yy_stack_print (yybottom, yytop)
 742     yytype_int16 *yybottom;
 743     yytype_int16 *yytop;
 744 #endif
 745 {
 746   YYFPRINTF (stderr, "Stack now");
 747   for (; yybottom <= yytop; yybottom++)
 748     {
 749       int yybot = *yybottom;
 750       YYFPRINTF (stderr, " %d", yybot);
 751     }
 752   YYFPRINTF (stderr, "\n");
 753 }
 754
 755 # define YY_STACK_PRINT(Bottom, Top)                            \
 756 do {                                                            \
 757   if (yydebug)                                                  \
 758     yy_stack_print ((Bottom), (Top));                           \
 759 } while (YYID (0))
 760
 761
 762 /*------------------------------------------------.
 763 | Report that the YYRULE is going to be reduced.  |
 764 `------------------------------------------------*/
 765
 766 #if (defined __STDC__ || defined __C99__FUNC__ \
 767      || defined __cplusplus || defined _MSC_VER)
 768 static void
 769 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, struct list_head *format, char *name)
 770 #else
 771 static void
 772 yy_reduce_print (yyvsp, yyrule, format, name)
 773     YYSTYPE *yyvsp;
 774     int yyrule;
 775     struct list_head *format;
 776     char *name;
 777 #endif
 778 {
 779   int yynrhs = yyr2[yyrule];
 780   int yyi;
 781   unsigned long int yylno = yyrline[yyrule];
 782   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 783              yyrule - 1, yylno);
 784   /* The symbols being reduced.  */
 785   for (yyi = 0; yyi < yynrhs; yyi++)
 786     {
 787       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 788       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
 789                        &(yyvsp[(yyi + 1) - (yynrhs)])
 790                                        , format, name);
 791       YYFPRINTF (stderr, "\n");
 792     }
 793 }
 794
 795 # define YY_REDUCE_PRINT(Rule)          \
 796 do {                                    \
 797   if (yydebug)                          \
 798     yy_reduce_print (yyvsp, Rule, format, name); \
 799 } while (YYID (0))
 800
 801 /* Nonzero means print parse trace.  It is left uninitialized so that
 802    multiple parsers can coexist.  */
 803 int yydebug;
 804 #else /* !YYDEBUG */
 805 # define YYDPRINTF(Args)
 806 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 807 # define YY_STACK_PRINT(Bottom, Top)
 808 # define YY_REDUCE_PRINT(Rule)
 809 #endif /* !YYDEBUG */
 810
 811
 812 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 813 #ifndef YYINITDEPTH
 814 # define YYINITDEPTH 200
 815 #endif
 816
 817 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 818    if the built-in stack extension method is used).
 819
 820    Do not make this value too large; the results are undefined if
 821    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 822    evaluated with infinite-precision integer arithmetic.  */
 823
 824 #ifndef YYMAXDEPTH
 825 # define YYMAXDEPTH 10000
 826 #endif
 827
 828 \f
 829
 830 #if YYERROR_VERBOSE
 831
 832 # ifndef yystrlen
 833 #  if defined __GLIBC__ && defined _STRING_H
 834 #   define yystrlen strlen
 835 #  else
 836 /* Return the length of YYSTR.  */
 837 #if (defined __STDC__ || defined __C99__FUNC__ \
 838      || defined __cplusplus || defined _MSC_VER)
 839 static YYSIZE_T
 840 yystrlen (const char *yystr)
 841 #else
 842 static YYSIZE_T
 843 yystrlen (yystr)
 844     const char *yystr;
 845 #endif
 846 {
 847   YYSIZE_T yylen;
 848   for (yylen = 0; yystr[yylen]; yylen++)
 849     continue;
 850   return yylen;
 851 }
 852 #  endif
 853 # endif
 854
 855 # ifndef yystpcpy
 856 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 857 #   define yystpcpy stpcpy
 858 #  else
 859 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 860    YYDEST.  */
 861 #if (defined __STDC__ || defined __C99__FUNC__ \
 862      || defined __cplusplus || defined _MSC_VER)
 863 static char *
 864 yystpcpy (char *yydest, const char *yysrc)
 865 #else
 866 static char *
 867 yystpcpy (yydest, yysrc)
 868     char *yydest;
 869     const char *yysrc;
 870 #endif
 871 {
 872   char *yyd = yydest;
 873   const char *yys = yysrc;
 874
 875   while ((*yyd++ = *yys++) != '\0')
 876     continue;
 877
 878   return yyd - 1;
 879 }
 880 #  endif
 881 # endif
 882
 883 # ifndef yytnamerr
 884 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 885    quotes and backslashes, so that it's suitable for yyerror.  The
 886    heuristic is that double-quoting is unnecessary unless the string
 887    contains an apostrophe, a comma, or backslash (other than
 888    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 889    null, do not copy; instead, return the length of what the result
 890    would have been.  */
 891 static YYSIZE_T
 892 yytnamerr (char *yyres, const char *yystr)
 893 {
 894   if (*yystr == '"')
 895     {
 896       YYSIZE_T yyn = 0;
 897       char const *yyp = yystr;
 898
 899       for (;;)
 900         switch (*++yyp)
 901           {
 902           case '\'':
 903           case ',':
 904             goto do_not_strip_quotes;
 905
 906           case '\\':
 907             if (*++yyp != '\\')
 908               goto do_not_strip_quotes;
 909             /* Fall through.  */
 910           default:
 911             if (yyres)
 912               yyres[yyn] = *yyp;
 913             yyn++;
 914             break;
 915
 916           case '"':
 917             if (yyres)
 918               yyres[yyn] = '\0';
 919             return yyn;
 920           }
 921     do_not_strip_quotes: ;
 922     }
 923
 924   if (! yyres)
 925     return yystrlen (yystr);
 926
 927   return yystpcpy (yyres, yystr) - yyres;
 928 }
 929 # endif
 930
 931 /* Copy into YYRESULT an error message about the unexpected token
 932    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
 933    including the terminating null byte.  If YYRESULT is null, do not
 934    copy anything; just return the number of bytes that would be
 935    copied.  As a special case, return 0 if an ordinary "syntax error"
 936    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
 937    size calculation.  */
 938 static YYSIZE_T
 939 yysyntax_error (char *yyresult, int yystate, int yychar)
 940 {
 941   int yyn = yypact[yystate];
 942
 943   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
 944     return 0;
 945   else
 946     {
 947       int yytype = YYTRANSLATE (yychar);
 948       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
 949       YYSIZE_T yysize = yysize0;
 950       YYSIZE_T yysize1;
 951       int yysize_overflow = 0;
 952       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 953       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 954       int yyx;
 955
 956 # if 0
 957       /* This is so xgettext sees the translatable formats that are
 958          constructed on the fly.  */
 959       YY_("syntax error, unexpected %s");
 960       YY_("syntax error, unexpected %s, expecting %s");
 961       YY_("syntax error, unexpected %s, expecting %s or %s");
 962       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
 963       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
 964 # endif
 965       char *yyfmt;
 966       char const *yyf;
 967       static char const yyunexpected[] = "syntax error, unexpected %s";
 968       static char const yyexpecting[] = ", expecting %s";
 969       static char const yyor[] = " or %s";
 970       char yyformat[sizeof yyunexpected
 971                     + sizeof yyexpecting - 1
 972                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
 973                        * (sizeof yyor - 1))];
 974       char const *yyprefix = yyexpecting;
 975
 976       /* Start YYX at -YYN if negative to avoid negative indexes in
 977          YYCHECK.  */
 978       int yyxbegin = yyn < 0 ? -yyn : 0;
 979
 980       /* Stay within bounds of both yycheck and yytname.  */
 981       int yychecklim = YYLAST - yyn + 1;
 982       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 983       int yycount = 1;
 984
 985       yyarg[0] = yytname[yytype];
 986       yyfmt = yystpcpy (yyformat, yyunexpected);
 987
 988       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 989         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
 990           {
 991             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 992               {
 993                 yycount = 1;
 994                 yysize = yysize0;
 995                 yyformat[sizeof yyunexpected - 1] = '\0';
 996                 break;
 997               }
 998             yyarg[yycount++] = yytname[yyx];
 999             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1000             yysize_overflow |= (yysize1 < yysize);
1001             yysize = yysize1;
1002             yyfmt = yystpcpy (yyfmt, yyprefix);
1003             yyprefix = yyor;
1004           }
1005
1006       yyf = YY_(yyformat);
1007       yysize1 = yysize + yystrlen (yyf);
1008       yysize_overflow |= (yysize1 < yysize);
1009       yysize = yysize1;
1010
1011       if (yysize_overflow)
1012         return YYSIZE_MAXIMUM;
1013
1014       if (yyresult)
1015         {
1016           /* Avoid sprintf, as that infringes on the user's name space.
1017              Don't have undefined behavior even if the translation
1018              produced a string with the wrong number of "%s"s.  */
1019           char *yyp = yyresult;
1020           int yyi = 0;
1021           while ((*yyp = *yyf) != '\0')
1022             {
1023               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1024                 {
1025                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1026                   yyf += 2;
1027                 }
1028               else
1029                 {
1030                   yyp++;
1031                   yyf++;
1032                 }
1033             }
1034         }
1035       return yysize;
1036     }
1037 }
1038 #endif /* YYERROR_VERBOSE */
1039 \f
1040
1041 /*-----------------------------------------------.
1042 | Release the memory associated to this symbol.  |
1043 `-----------------------------------------------*/
1044
1045 /*ARGSUSED*/
1046 #if (defined __STDC__ || defined __C99__FUNC__ \
1047      || defined __cplusplus || defined _MSC_VER)
1048 static void
1049 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, struct list_head *format, char *name)
1050 #else
1051 static void
1052 yydestruct (yymsg, yytype, yyvaluep, format, name)
1053     const char *yymsg;
1054     int yytype;
1055     YYSTYPE *yyvaluep;
1056     struct list_head *format;
1057     char *name;
1058 #endif
1059 {
1060   YYUSE (yyvaluep);
1061   YYUSE (format);
1062   YYUSE (name);
1063
1064   if (!yymsg)
1065     yymsg = "Deleting";
1066   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1067
1068   switch (yytype)
1069     {
1070
1071       default:
1072         break;
1073     }
1074 }
1075
1076 /* Prevent warnings from -Wmissing-prototypes.  */
1077 #ifdef YYPARSE_PARAM
1078 #if defined __STDC__ || defined __cplusplus
1079 int yyparse (void *YYPARSE_PARAM);
1080 #else
1081 int yyparse ();
1082 #endif
1083 #else /* ! YYPARSE_PARAM */
1084 #if defined __STDC__ || defined __cplusplus
1085 int yyparse (struct list_head *format, char *name);
1086 #else
1087 int yyparse ();
1088 #endif
1089 #endif /* ! YYPARSE_PARAM */
1090
1091
1092 /* The lookahead symbol.  */
1093 int yychar;
1094
1095 /* The semantic value of the lookahead symbol.  */
1096 YYSTYPE yylval;
1097
1098 /* Number of syntax errors so far.  */
1099 int yynerrs;
1100
1101
1102
1103 /*-------------------------.
1104 | yyparse or yypush_parse.  |
1105 `-------------------------*/
1106
1107 #ifdef YYPARSE_PARAM
1108 #if (defined __STDC__ || defined __C99__FUNC__ \
1109      || defined __cplusplus || defined _MSC_VER)
1110 int
1111 yyparse (void *YYPARSE_PARAM)
1112 #else
1113 int
1114 yyparse (YYPARSE_PARAM)
1115     void *YYPARSE_PARAM;
1116 #endif
1117 #else /* ! YYPARSE_PARAM */
1118 #if (defined __STDC__ || defined __C99__FUNC__ \
1119      || defined __cplusplus || defined _MSC_VER)
1120 int
1121 yyparse (struct list_head *format, char *name)
1122 #else
1123 int
1124 yyparse (format, name)
1125     struct list_head *format;
1126     char *name;
1127 #endif
1128 #endif
1129 {
1130
1131
1132     int yystate;
1133     /* Number of tokens to shift before error messages enabled.  */
1134     int yyerrstatus;
1135
1136     /* The stacks and their tools:
1137        `yyss': related to states.
1138        `yyvs': related to semantic values.
1139
1140        Refer to the stacks thru separate pointers, to allow yyoverflow
1141        to reallocate them elsewhere.  */
1142
1143     /* The state stack.  */
1144     yytype_int16 yyssa[YYINITDEPTH];
1145     yytype_int16 *yyss;
1146     yytype_int16 *yyssp;
1147
1148     /* The semantic value stack.  */
1149     YYSTYPE yyvsa[YYINITDEPTH];
1150     YYSTYPE *yyvs;
1151     YYSTYPE *yyvsp;
1152
1153     YYSIZE_T yystacksize;
1154
1155   int yyn;
1156   int yyresult;
1157   /* Lookahead token as an internal (translated) token number.  */
1158   int yytoken;
1159   /* The variables used to return semantic value and location from the
1160      action routines.  */
1161   YYSTYPE yyval;
1162
1163 #if YYERROR_VERBOSE
1164   /* Buffer for error messages, and its allocated size.  */
1165   char yymsgbuf[128];
1166   char *yymsg = yymsgbuf;
1167   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1168 #endif
1169
1170 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1171
1172   /* The number of symbols on the RHS of the reduced rule.
1173      Keep to zero when no symbol should be popped.  */
1174   int yylen = 0;
1175
1176   yytoken = 0;
1177   yyss = yyssa;
1178   yyvs = yyvsa;
1179   yystacksize = YYINITDEPTH;
1180
1181   YYDPRINTF ((stderr, "Starting parse\n"));
1182
1183   yystate = 0;
1184   yyerrstatus = 0;
1185   yynerrs = 0;
1186   yychar = YYEMPTY; /* Cause a token to be read.  */
1187
1188   /* Initialize stack pointers.
1189      Waste one element of value and location stack
1190      so that they stay on the same level as the state stack.
1191      The wasted elements are never initialized.  */
1192   yyssp = yyss;
1193   yyvsp = yyvs;
1194
1195   goto yysetstate;
1196
1197 /*------------------------------------------------------------.
1198 | yynewstate -- Push a new state, which is found in yystate.  |
1199 `------------------------------------------------------------*/
1200  yynewstate:
1201   /* In all cases, when you get here, the value and location stacks
1202      have just been pushed.  So pushing a state here evens the stacks.  */
1203   yyssp++;
1204
1205  yysetstate:
1206   *yyssp = yystate;
1207
1208   if (yyss + yystacksize - 1 <= yyssp)
1209     {
1210       /* Get the current used size of the three stacks, in elements.  */
1211       YYSIZE_T yysize = yyssp - yyss + 1;
1212
1213 #ifdef yyoverflow
1214       {
1215         /* Give user a chance to reallocate the stack.  Use copies of
1216            these so that the &'s don't force the real ones into
1217            memory.  */
1218         YYSTYPE *yyvs1 = yyvs;
1219         yytype_int16 *yyss1 = yyss;
1220
1221         /* Each stack pointer address is followed by the size of the
1222            data in use in that stack, in bytes.  This used to be a
1223            conditional around just the two extra args, but that might
1224            be undefined if yyoverflow is a macro.  */
1225         yyoverflow (YY_("memory exhausted"),
1226                     &yyss1, yysize * sizeof (*yyssp),
1227                     &yyvs1, yysize * sizeof (*yyvsp),
1228                     &yystacksize);
1229
1230         yyss = yyss1;
1231         yyvs = yyvs1;
1232       }
1233 #else /* no yyoverflow */
1234 # ifndef YYSTACK_RELOCATE
1235       goto yyexhaustedlab;
1236 # else
1237       /* Extend the stack our own way.  */
1238       if (YYMAXDEPTH <= yystacksize)
1239         goto yyexhaustedlab;
1240       yystacksize *= 2;
1241       if (YYMAXDEPTH < yystacksize)
1242         yystacksize = YYMAXDEPTH;
1243
1244       {
1245         yytype_int16 *yyss1 = yyss;
1246         union yyalloc *yyptr =
1247           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1248         if (! yyptr)
1249           goto yyexhaustedlab;
1250         YYSTACK_RELOCATE (yyss_alloc, yyss);
1251         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1252 #  undef YYSTACK_RELOCATE
1253         if (yyss1 != yyssa)
1254           YYSTACK_FREE (yyss1);
1255       }
1256 # endif
1257 #endif /* no yyoverflow */
1258
1259       yyssp = yyss + yysize - 1;
1260       yyvsp = yyvs + yysize - 1;
1261
1262       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1263                   (unsigned long int) yystacksize));
1264
1265       if (yyss + yystacksize - 1 <= yyssp)
1266         YYABORT;
1267     }
1268
1269   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1270
1271   if (yystate == YYFINAL)
1272     YYACCEPT;
1273
1274   goto yybackup;
1275
1276 /*-----------.
1277 | yybackup.  |
1278 `-----------*/
1279 yybackup:
1280
1281   /* Do appropriate processing given the current state.  Read a
1282      lookahead token if we need one and don't already have one.  */
1283
1284   /* First try to decide what to do without reference to lookahead token.  */
1285   yyn = yypact[yystate];
1286   if (yyn == YYPACT_NINF)
1287     goto yydefault;
1288
1289   /* Not known => get a lookahead token if don't already have one.  */
1290
1291   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1292   if (yychar == YYEMPTY)
1293     {
1294       YYDPRINTF ((stderr, "Reading a token: "));
1295       yychar = YYLEX;
1296     }
1297
1298   if (yychar <= YYEOF)
1299     {
1300       yychar = yytoken = YYEOF;
1301       YYDPRINTF ((stderr, "Now at end of input.\n"));
1302     }
1303   else
1304     {
1305       yytoken = YYTRANSLATE (yychar);
1306       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1307     }
1308
1309   /* If the proper action on seeing token YYTOKEN is to reduce or to
1310      detect an error, take that action.  */
1311   yyn += yytoken;
1312   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1313     goto yydefault;
1314   yyn = yytable[yyn];
1315   if (yyn <= 0)
1316     {
1317       if (yyn == 0 || yyn == YYTABLE_NINF)
1318         goto yyerrlab;
1319       yyn = -yyn;
1320       goto yyreduce;
1321     }
1322
1323   /* Count tokens shifted since error; after three, turn off error
1324      status.  */
1325   if (yyerrstatus)
1326     yyerrstatus--;
1327
1328   /* Shift the lookahead token.  */
1329   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1330
1331   /* Discard the shifted token.  */
1332   yychar = YYEMPTY;
1333
1334   yystate = yyn;
1335   *++yyvsp = yylval;
1336
1337   goto yynewstate;
1338
1339
1340 /*-----------------------------------------------------------.
1341 | yydefault -- do the default action for the current state.  |
1342 `-----------------------------------------------------------*/
1343 yydefault:
1344   yyn = yydefact[yystate];
1345   if (yyn == 0)
1346     goto yyerrlab;
1347   goto yyreduce;
1348
1349
1350 /*-----------------------------.
1351 | yyreduce -- Do a reduction.  |
1352 `-----------------------------*/
1353 yyreduce:
1354   /* yyn is the number of a rule to reduce with.  */
1355   yylen = yyr2[yyn];
1356
1357   /* If YYLEN is nonzero, implement the default value of the action:
1358      `$$ = $1'.
1359
1360      Otherwise, the following line sets YYVAL to garbage.
1361      This behavior is undocumented and Bison
1362      users should not rely upon it.  Assigning to YYVAL
1363      unconditionally makes the parser a bit smaller, and it avoids a
1364      GCC warning that YYVAL may be used uninitialized.  */
1365   yyval = yyvsp[1-yylen];
1366
1367
1368   YY_REDUCE_PRINT (yyn);
1369   switch (yyn)
1370     {
1371         case 4:
1372
1373 /* Line 1464 of yacc.c  */
1374 #line 45 "util/pmu.y"
1375     {
1376         ABORT_ON(perf_pmu__new_format(format, name,
1377                                       PERF_PMU_FORMAT_VALUE_CONFIG,
1378                                       (yyvsp[(3) - (3)].bits)));
1379 ;}
1380     break;
1381
1382   case 5:
1383
1384 /* Line 1464 of yacc.c  */
1385 #line 52 "util/pmu.y"
1386     {
1387         ABORT_ON(perf_pmu__new_format(format, name,
1388                                       PERF_PMU_FORMAT_VALUE_CONFIG1,
1389                                       (yyvsp[(3) - (3)].bits)));
1390 ;}
1391     break;
1392
1393   case 6:
1394
1395 /* Line 1464 of yacc.c  */
1396 #line 59 "util/pmu.y"
1397     {
1398         ABORT_ON(perf_pmu__new_format(format, name,
1399                                       PERF_PMU_FORMAT_VALUE_CONFIG2,
1400                                       (yyvsp[(3) - (3)].bits)));
1401 ;}
1402     break;
1403
1404   case 7:
1405
1406 /* Line 1464 of yacc.c  */
1407 #line 67 "util/pmu.y"
1408     {
1409         bitmap_or((yyval.bits), (yyvsp[(1) - (3)].bits), (yyvsp[(3) - (3)].bits), 64);
1410 ;}
1411     break;
1412
1413   case 8:
1414
1415 /* Line 1464 of yacc.c  */
1416 #line 72 "util/pmu.y"
1417     {
1418         memcpy((yyval.bits), (yyvsp[(1) - (1)].bits), sizeof((yyvsp[(1) - (1)].bits)));
1419 ;}
1420     break;
1421
1422   case 9:
1423
1424 /* Line 1464 of yacc.c  */
1425 #line 78 "util/pmu.y"
1426     {
1427         perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (3)].num), (yyvsp[(3) - (3)].num));
1428 ;}
1429     break;
1430
1431   case 10:
1432
1433 /* Line 1464 of yacc.c  */
1434 #line 83 "util/pmu.y"
1435     {
1436         perf_pmu__set_format((yyval.bits), (yyvsp[(1) - (1)].num), 0);
1437 ;}
1438     break;
1439
1440
1441
1442 /* Line 1464 of yacc.c  */
1443 #line 1444 "util/pmu-bison.c"
1444       default: break;
1445     }
1446   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1447
1448   YYPOPSTACK (yylen);
1449   yylen = 0;
1450   YY_STACK_PRINT (yyss, yyssp);
1451
1452   *++yyvsp = yyval;
1453
1454   /* Now `shift' the result of the reduction.  Determine what state
1455      that goes to, based on the state we popped back to and the rule
1456      number reduced by.  */
1457
1458   yyn = yyr1[yyn];
1459
1460   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1461   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1462     yystate = yytable[yystate];
1463   else
1464     yystate = yydefgoto[yyn - YYNTOKENS];
1465
1466   goto yynewstate;
1467
1468
1469 /*------------------------------------.
1470 | yyerrlab -- here on detecting error |
1471 `------------------------------------*/
1472 yyerrlab:
1473   /* If not already recovering from an error, report this error.  */
1474   if (!yyerrstatus)
1475     {
1476       ++yynerrs;
1477 #if ! YYERROR_VERBOSE
1478       yyerror (format, name, YY_("syntax error"));
1479 #else
1480       {
1481         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1482         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1483           {
1484             YYSIZE_T yyalloc = 2 * yysize;
1485             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1486               yyalloc = YYSTACK_ALLOC_MAXIMUM;
1487             if (yymsg != yymsgbuf)
1488               YYSTACK_FREE (yymsg);
1489             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1490             if (yymsg)
1491               yymsg_alloc = yyalloc;
1492             else
1493               {
1494                 yymsg = yymsgbuf;
1495                 yymsg_alloc = sizeof yymsgbuf;
1496               }
1497           }
1498
1499         if (0 < yysize && yysize <= yymsg_alloc)
1500           {
1501             (void) yysyntax_error (yymsg, yystate, yychar);
1502             yyerror (format, name, yymsg);
1503           }
1504         else
1505           {
1506             yyerror (format, name, YY_("syntax error"));
1507             if (yysize != 0)
1508               goto yyexhaustedlab;
1509           }
1510       }
1511 #endif
1512     }
1513
1514
1515
1516   if (yyerrstatus == 3)
1517     {
1518       /* If just tried and failed to reuse lookahead token after an
1519          error, discard it.  */
1520
1521       if (yychar <= YYEOF)
1522         {
1523           /* Return failure if at end of input.  */
1524           if (yychar == YYEOF)
1525             YYABORT;
1526         }
1527       else
1528         {
1529           yydestruct ("Error: discarding",
1530                       yytoken, &yylval, format, name);
1531           yychar = YYEMPTY;
1532         }
1533     }
1534
1535   /* Else will try to reuse lookahead token after shifting the error
1536      token.  */
1537   goto yyerrlab1;
1538
1539
1540 /*---------------------------------------------------.
1541 | yyerrorlab -- error raised explicitly by YYERROR.  |
1542 `---------------------------------------------------*/
1543 yyerrorlab:
1544
1545   /* Pacify compilers like GCC when the user code never invokes
1546      YYERROR and the label yyerrorlab therefore never appears in user
1547      code.  */
1548   if (/*CONSTCOND*/ 0)
1549      goto yyerrorlab;
1550
1551   /* Do not reclaim the symbols of the rule which action triggered
1552      this YYERROR.  */
1553   YYPOPSTACK (yylen);
1554   yylen = 0;
1555   YY_STACK_PRINT (yyss, yyssp);
1556   yystate = *yyssp;
1557   goto yyerrlab1;
1558
1559
1560 /*-------------------------------------------------------------.
1561 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1562 `-------------------------------------------------------------*/
1563 yyerrlab1:
1564   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1565
1566   for (;;)
1567     {
1568       yyn = yypact[yystate];
1569       if (yyn != YYPACT_NINF)
1570         {
1571           yyn += YYTERROR;
1572           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1573             {
1574               yyn = yytable[yyn];
1575               if (0 < yyn)
1576                 break;
1577             }
1578         }
1579
1580       /* Pop the current state because it cannot handle the error token.  */
1581       if (yyssp == yyss)
1582         YYABORT;
1583
1584
1585       yydestruct ("Error: popping",
1586                   yystos[yystate], yyvsp, format, name);
1587       YYPOPSTACK (1);
1588       yystate = *yyssp;
1589       YY_STACK_PRINT (yyss, yyssp);
1590     }
1591
1592   *++yyvsp = yylval;
1593
1594
1595   /* Shift the error token.  */
1596   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1597
1598   yystate = yyn;
1599   goto yynewstate;
1600
1601
1602 /*-------------------------------------.
1603 | yyacceptlab -- YYACCEPT comes here.  |
1604 `-------------------------------------*/
1605 yyacceptlab:
1606   yyresult = 0;
1607   goto yyreturn;
1608
1609 /*-----------------------------------.
1610 | yyabortlab -- YYABORT comes here.  |
1611 `-----------------------------------*/
1612 yyabortlab:
1613   yyresult = 1;
1614   goto yyreturn;
1615
1616 #if !defined(yyoverflow) || YYERROR_VERBOSE
1617 /*-------------------------------------------------.
1618 | yyexhaustedlab -- memory exhaustion comes here.  |
1619 `-------------------------------------------------*/
1620 yyexhaustedlab:
1621   yyerror (format, name, YY_("memory exhausted"));
1622   yyresult = 2;
1623   /* Fall through.  */
1624 #endif
1625
1626 yyreturn:
1627   if (yychar != YYEMPTY)
1628      yydestruct ("Cleanup: discarding lookahead",
1629                  yytoken, &yylval, format, name);
1630   /* Do not reclaim the symbols of the rule which action triggered
1631      this YYABORT or YYACCEPT.  */
1632   YYPOPSTACK (yylen);
1633   YY_STACK_PRINT (yyss, yyssp);
1634   while (yyssp != yyss)
1635     {
1636       yydestruct ("Cleanup: popping",
1637                   yystos[*yyssp], yyvsp, format, name);
1638       YYPOPSTACK (1);
1639     }
1640 #ifndef yyoverflow
1641   if (yyss != yyssa)
1642     YYSTACK_FREE (yyss);
1643 #endif
1644 #if YYERROR_VERBOSE
1645   if (yymsg != yymsgbuf)
1646     YYSTACK_FREE (yymsg);
1647 #endif
1648   /* Make sure YYID is used.  */
1649   return YYID (yyresult);
1650 }
1651
1652
1653
1654 /* Line 1684 of yacc.c  */
1655 #line 87 "util/pmu.y"
1656
1657
1658 void perf_pmu_error(struct list_head *list __used,
1659                     char *name __used,
1660                     char const *msg __used)
1661 {
1662 }
1663