src/Parser.cpp

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