Source/cmCommandArgumentParser.cxx

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