xref: /PHP-5.6/sapi/phpdbg/phpdbg_parser.c (revision 36311ee4)
1 /* A Bison parser, made by GNU Bison 2.7.12-4996.  */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5       Copyright (C) 1984, 1989-1990, 2000-2013 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 "2.7.12-4996"
48 
49 /* Skeleton name.  */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers.  */
53 #define YYPURE 1
54 
55 /* Push parsers.  */
56 #define YYPUSH 0
57 
58 /* Pull parsers.  */
59 #define YYPULL 1
60 
61 
62 /* Substitute the variable and function names.  */
63 #define yyparse         phpdbg_parse
64 #define yylex           phpdbg_lex
65 #define yyerror         phpdbg_error
66 #define yylval          phpdbg_lval
67 #define yychar          phpdbg_char
68 #define yydebug         phpdbg_debug
69 #define yynerrs         phpdbg_nerrs
70 
71 /* Copy the first part of user declarations.  */
72 /* Line 371 of yacc.c  */
73 #line 1 "sapi/phpdbg/phpdbg_parser.y"
74 
75 
76 /*
77  * phpdbg_parser.y
78  * (from php-src root)
79  * flex sapi/phpdbg/dev/phpdbg_lexer.l
80  * bison sapi/phpdbg/dev/phpdbg_parser.y
81  */
82 
83 #include "phpdbg.h"
84 #include "phpdbg_cmd.h"
85 #include "phpdbg_utils.h"
86 #include "phpdbg_cmd.h"
87 #include "phpdbg_prompt.h"
88 
89 #define YYSTYPE phpdbg_param_t
90 
91 #include "phpdbg_parser.h"
92 #include "phpdbg_lexer.h"
93 
94 #undef yyerror
95 static int yyerror(void ***tsrm_ls, const char *msg);
96 
97 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
98 
99 
100 /* Line 371 of yacc.c  */
101 #line 102 "sapi/phpdbg/phpdbg_parser.c"
102 
103 # ifndef YY_NULL
104 #  if defined __cplusplus && 201103L <= __cplusplus
105 #   define YY_NULL nullptr
106 #  else
107 #   define YY_NULL 0
108 #  endif
109 # endif
110 
111 /* Enabling verbose error messages.  */
112 #ifdef YYERROR_VERBOSE
113 # undef YYERROR_VERBOSE
114 # define YYERROR_VERBOSE 1
115 #else
116 # define YYERROR_VERBOSE 1
117 #endif
118 
119 /* In a future release of Bison, this section will be replaced
120    by #include "phpdbg_parser.h".  */
121 #ifndef YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED
122 # define YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED
123 /* Enabling traces.  */
124 #ifndef YYDEBUG
125 # define YYDEBUG 0
126 #endif
127 #if YYDEBUG
128 extern int phpdbg_debug;
129 #endif
130 /* "%code requires" blocks.  */
131 /* Line 387 of yacc.c  */
132 #line 31 "sapi/phpdbg/phpdbg_parser.y"
133 
134 #include "phpdbg.h"
135 #ifndef YY_TYPEDEF_YY_SCANNER_T
136 #define YY_TYPEDEF_YY_SCANNER_T
137 typedef void* yyscan_t;
138 #endif
139 
140 
141 /* Line 387 of yacc.c  */
142 #line 143 "sapi/phpdbg/phpdbg_parser.c"
143 
144 /* Tokens.  */
145 #ifndef YYTOKENTYPE
146 # define YYTOKENTYPE
147    /* Put the tokens into the symbol table, so that GDB and other debuggers
148       know about them.  */
149    enum yytokentype {
150      T_EVAL = 258,
151      T_RUN = 259,
152      T_SHELL = 260,
153      T_IF = 261,
154      T_TRUTHY = 262,
155      T_FALSY = 263,
156      T_STRING = 264,
157      T_COLON = 265,
158      T_DCOLON = 266,
159      T_POUND = 267,
160      T_PROTO = 268,
161      T_DIGITS = 269,
162      T_LITERAL = 270,
163      T_ADDR = 271,
164      T_OPCODE = 272,
165      T_ID = 273,
166      T_INPUT = 274,
167      T_UNEXPECTED = 275
168    };
169 #endif
170 /* Tokens.  */
171 #define T_EVAL 258
172 #define T_RUN 259
173 #define T_SHELL 260
174 #define T_IF 261
175 #define T_TRUTHY 262
176 #define T_FALSY 263
177 #define T_STRING 264
178 #define T_COLON 265
179 #define T_DCOLON 266
180 #define T_POUND 267
181 #define T_PROTO 268
182 #define T_DIGITS 269
183 #define T_LITERAL 270
184 #define T_ADDR 271
185 #define T_OPCODE 272
186 #define T_ID 273
187 #define T_INPUT 274
188 #define T_UNEXPECTED 275
189 
190 
191 
192 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
193 typedef int YYSTYPE;
194 # define YYSTYPE_IS_TRIVIAL 1
195 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
196 # define YYSTYPE_IS_DECLARED 1
197 #endif
198 
199 
200 #ifdef YYPARSE_PARAM
201 #if defined __STDC__ || defined __cplusplus
202 int phpdbg_parse (void *YYPARSE_PARAM);
203 #else
204 int phpdbg_parse ();
205 #endif
206 #else /* ! YYPARSE_PARAM */
207 #if defined __STDC__ || defined __cplusplus
208 int phpdbg_parse (void *tsrm_ls);
209 #else
210 int phpdbg_parse ();
211 #endif
212 #endif /* ! YYPARSE_PARAM */
213 
214 #endif /* !YY_PHPDBG_SAPI_PHPDBG_PHPDBG_PARSER_H_INCLUDED  */
215 
216 /* Copy the second part of user declarations.  */
217 
218 /* Line 390 of yacc.c  */
219 #line 220 "sapi/phpdbg/phpdbg_parser.c"
220 
221 #ifdef short
222 # undef short
223 #endif
224 
225 #ifdef YYTYPE_UINT8
226 typedef YYTYPE_UINT8 yytype_uint8;
227 #else
228 typedef unsigned char yytype_uint8;
229 #endif
230 
231 #ifdef YYTYPE_INT8
232 typedef YYTYPE_INT8 yytype_int8;
233 #elif (defined __STDC__ || defined __C99__FUNC__ \
234      || defined __cplusplus || defined _MSC_VER)
235 typedef signed char yytype_int8;
236 #else
237 typedef short int yytype_int8;
238 #endif
239 
240 #ifdef YYTYPE_UINT16
241 typedef YYTYPE_UINT16 yytype_uint16;
242 #else
243 typedef unsigned short int yytype_uint16;
244 #endif
245 
246 #ifdef YYTYPE_INT16
247 typedef YYTYPE_INT16 yytype_int16;
248 #else
249 typedef short int yytype_int16;
250 #endif
251 
252 #ifndef YYSIZE_T
253 # ifdef __SIZE_TYPE__
254 #  define YYSIZE_T __SIZE_TYPE__
255 # elif defined size_t
256 #  define YYSIZE_T size_t
257 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
258      || defined __cplusplus || defined _MSC_VER)
259 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
260 #  define YYSIZE_T size_t
261 # else
262 #  define YYSIZE_T unsigned int
263 # endif
264 #endif
265 
266 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
267 
268 #ifndef YY_
269 # if defined YYENABLE_NLS && YYENABLE_NLS
270 #  if ENABLE_NLS
271 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
272 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
273 #  endif
274 # endif
275 # ifndef YY_
276 #  define YY_(Msgid) Msgid
277 # endif
278 #endif
279 
280 #ifndef __attribute__
281 /* This feature is available in gcc versions 2.5 and later.  */
282 # if (! defined __GNUC__ || __GNUC__ < 2 \
283       || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
284 #  define __attribute__(Spec) /* empty */
285 # endif
286 #endif
287 
288 /* Suppress unused-variable warnings by "using" E.  */
289 #if ! defined lint || defined __GNUC__
290 # define YYUSE(E) ((void) (E))
291 #else
292 # define YYUSE(E) /* empty */
293 #endif
294 
295 
296 /* Identity function, used to suppress warnings about constant conditions.  */
297 #ifndef lint
298 # define YYID(N) (N)
299 #else
300 #if (defined __STDC__ || defined __C99__FUNC__ \
301      || defined __cplusplus || defined _MSC_VER)
302 static int
YYID(int yyi)303 YYID (int yyi)
304 #else
305 static int
306 YYID (yyi)
307     int yyi;
308 #endif
309 {
310   return yyi;
311 }
312 #endif
313 
314 #if ! defined yyoverflow || YYERROR_VERBOSE
315 
316 /* The parser invokes alloca or malloc; define the necessary symbols.  */
317 
318 # ifdef YYSTACK_USE_ALLOCA
319 #  if YYSTACK_USE_ALLOCA
320 #   ifdef __GNUC__
321 #    define YYSTACK_ALLOC __builtin_alloca
322 #   elif defined __BUILTIN_VA_ARG_INCR
323 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
324 #   elif defined _AIX
325 #    define YYSTACK_ALLOC __alloca
326 #   elif defined _MSC_VER
327 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
328 #    define alloca _alloca
329 #   else
330 #    define YYSTACK_ALLOC alloca
331 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
332      || defined __cplusplus || defined _MSC_VER)
333 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
334       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
335 #     ifndef EXIT_SUCCESS
336 #      define EXIT_SUCCESS 0
337 #     endif
338 #    endif
339 #   endif
340 #  endif
341 # endif
342 
343 # ifdef YYSTACK_ALLOC
344    /* Pacify GCC's `empty if-body' warning.  */
345 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
346 #  ifndef YYSTACK_ALLOC_MAXIMUM
347     /* The OS might guarantee only one guard page at the bottom of the stack,
348        and a page size can be as small as 4096 bytes.  So we cannot safely
349        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
350        to allow for a few compiler-allocated temporary stack slots.  */
351 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
352 #  endif
353 # else
354 #  define YYSTACK_ALLOC YYMALLOC
355 #  define YYSTACK_FREE YYFREE
356 #  ifndef YYSTACK_ALLOC_MAXIMUM
357 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
358 #  endif
359 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
360        && ! ((defined YYMALLOC || defined malloc) \
361 	     && (defined YYFREE || defined free)))
362 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
363 #   ifndef EXIT_SUCCESS
364 #    define EXIT_SUCCESS 0
365 #   endif
366 #  endif
367 #  ifndef YYMALLOC
368 #   define YYMALLOC malloc
369 #   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
370      || defined __cplusplus || defined _MSC_VER)
371 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
372 #   endif
373 #  endif
374 #  ifndef YYFREE
375 #   define YYFREE free
376 #   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
377      || defined __cplusplus || defined _MSC_VER)
378 void free (void *); /* INFRINGES ON USER NAME SPACE */
379 #   endif
380 #  endif
381 # endif
382 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
383 
384 
385 #if (! defined yyoverflow \
386      && (! defined __cplusplus \
387 	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
388 
389 /* A type that is properly aligned for any stack member.  */
390 union yyalloc
391 {
392   yytype_int16 yyss_alloc;
393   YYSTYPE yyvs_alloc;
394 };
395 
396 /* The size of the maximum gap between one aligned stack and the next.  */
397 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
398 
399 /* The size of an array large to enough to hold all stacks, each with
400    N elements.  */
401 # define YYSTACK_BYTES(N) \
402      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
403       + YYSTACK_GAP_MAXIMUM)
404 
405 # define YYCOPY_NEEDED 1
406 
407 /* Relocate STACK from its old location to the new one.  The
408    local variables YYSIZE and YYSTACKSIZE give the old and new number of
409    elements in the stack, and YYPTR gives the new location of the
410    stack.  Advance YYPTR to a properly aligned location for the next
411    stack.  */
412 # define YYSTACK_RELOCATE(Stack_alloc, Stack)				\
413     do									\
414       {									\
415 	YYSIZE_T yynewbytes;						\
416 	YYCOPY (&yyptr->Stack_alloc, Stack, yysize);			\
417 	Stack = &yyptr->Stack_alloc;					\
418 	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
419 	yyptr += yynewbytes / sizeof (*yyptr);				\
420       }									\
421     while (YYID (0))
422 
423 #endif
424 
425 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
426 /* Copy COUNT objects from SRC to DST.  The source and destination do
427    not overlap.  */
428 # ifndef YYCOPY
429 #  if defined __GNUC__ && 1 < __GNUC__
430 #   define YYCOPY(Dst, Src, Count) \
431       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
432 #  else
433 #   define YYCOPY(Dst, Src, Count)              \
434       do                                        \
435         {                                       \
436           YYSIZE_T yyi;                         \
437           for (yyi = 0; yyi < (Count); yyi++)   \
438             (Dst)[yyi] = (Src)[yyi];            \
439         }                                       \
440       while (YYID (0))
441 #  endif
442 # endif
443 #endif /* !YYCOPY_NEEDED */
444 
445 /* YYFINAL -- State number of the termination state.  */
446 #define YYFINAL  25
447 /* YYLAST -- Last index in YYTABLE.  */
448 #define YYLAST   42
449 
450 /* YYNTOKENS -- Number of terminals.  */
451 #define YYNTOKENS  21
452 /* YYNNTS -- Number of nonterminals.  */
453 #define YYNNTS  5
454 /* YYNRULES -- Number of rules.  */
455 #define YYNRULES  25
456 /* YYNRULES -- Number of states.  */
457 #define YYNSTATES  38
458 
459 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
460 #define YYUNDEFTOK  2
461 #define YYMAXUTOK   275
462 
463 #define YYTRANSLATE(YYX)						\
464   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
465 
466 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
467 static const yytype_uint8 yytranslate[] =
468 {
469        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
470        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
471        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
472        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
473        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
474        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
475        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
476        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
477        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
478        2,     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,     1,     2,     3,     4,
495        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
496       15,    16,    17,    18,    19,    20
497 };
498 
499 #if YYDEBUG
500 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
501    YYRHS.  */
502 static const yytype_uint8 yyprhs[] =
503 {
504        0,     0,     3,     5,     7,     8,    10,    13,    17,    22,
505       27,    33,    37,    43,    47,    50,    52,    54,    56,    58,
506       60,    62,    64,    67,    70,    72
507 };
508 
509 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
510 static const yytype_int8 yyrhs[] =
511 {
512       22,     0,    -1,    23,    -1,    25,    -1,    -1,    24,    -1,
513       23,    24,    -1,    18,    10,    14,    -1,    18,    10,    12,
514       14,    -1,    13,    18,    10,    14,    -1,    13,    18,    10,
515       12,    14,    -1,    18,    11,    18,    -1,    18,    11,    18,
516       12,    14,    -1,    18,    12,    14,    -1,     6,    19,    -1,
517       17,    -1,    16,    -1,    15,    -1,     7,    -1,     8,    -1,
518       14,    -1,    18,    -1,     3,    19,    -1,     5,    19,    -1,
519        4,    -1,     4,    19,    -1
520 };
521 
522 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
523 static const yytype_uint8 yyrline[] =
524 {
525        0,    66,    66,    67,    68,    72,    73,    77,    82,    87,
526       97,   107,   112,   118,   124,   129,   130,   131,   132,   133,
527      134,   135,   139,   144,   149,   153
528 };
529 #endif
530 
531 #if YYDEBUG || YYERROR_VERBOSE || 1
532 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
533    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
534 static const char *const yytname[] =
535 {
536   "$end", "error", "$undefined", "\"eval\"", "\"run\"", "\"shell\"",
537   "\"if (condition)\"", "\"truthy (true, on, yes or enabled)\"",
538   "\"falsy (false, off, no or disabled)\"",
539   "\"string (some input, perhaps)\"", "\": (colon)\"",
540   "\":: (double colon)\"", "\"# (pound sign)\"", "\"protocol (file://)\"",
541   "\"digits (numbers)\"", "\"literal (string)\"", "\"address\"",
542   "\"opcode\"", "\"identifier (command or function name)\"",
543   "\"input (input string or data)\"", "\"input\"", "$accept", "input",
544   "parameters", "parameter", "full_expression", YY_NULL
545 };
546 #endif
547 
548 # ifdef YYPRINT
549 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
550    token YYLEX-NUM.  */
551 static const yytype_uint16 yytoknum[] =
552 {
553        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
554      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
555      275
556 };
557 # endif
558 
559 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
560 static const yytype_uint8 yyr1[] =
561 {
562        0,    21,    22,    22,    22,    23,    23,    24,    24,    24,
563       24,    24,    24,    24,    24,    24,    24,    24,    24,    24,
564       24,    24,    25,    25,    25,    25
565 };
566 
567 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
568 static const yytype_uint8 yyr2[] =
569 {
570        0,     2,     1,     1,     0,     1,     2,     3,     4,     4,
571        5,     3,     5,     3,     2,     1,     1,     1,     1,     1,
572        1,     1,     2,     2,     1,     2
573 };
574 
575 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
576    Performed when YYTABLE doesn't specify something else to do.  Zero
577    means the default is an error.  */
578 static const yytype_uint8 yydefact[] =
579 {
580        4,     0,    24,     0,     0,    18,    19,     0,    20,    17,
581       16,    15,    21,     0,     2,     5,     3,    22,    25,    23,
582       14,     0,     0,     0,     0,     1,     6,     0,     0,     7,
583       11,    13,     0,     9,     8,     0,    10,    12
584 };
585 
586 /* YYDEFGOTO[NTERM-NUM].  */
587 static const yytype_int8 yydefgoto[] =
588 {
589       -1,    13,    14,    15,    16
590 };
591 
592 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
593    STATE-NUM.  */
594 #define YYPACT_NINF -11
595 static const yytype_int8 yypact[] =
596 {
597       -3,   -10,    11,    12,    13,   -11,   -11,    15,   -11,   -11,
598      -11,   -11,    -4,    29,    10,   -11,   -11,   -11,   -11,   -11,
599      -11,    24,     7,    17,    22,   -11,   -11,     8,    23,   -11,
600       26,   -11,    25,   -11,   -11,    27,   -11,   -11
601 };
602 
603 /* YYPGOTO[NTERM-NUM].  */
604 static const yytype_int8 yypgoto[] =
605 {
606      -11,   -11,   -11,    28,   -11
607 };
608 
609 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
610    positive, shift that token.  If negative, reduce the rule which
611    number is the opposite.  If YYTABLE_NINF, syntax error.  */
612 #define YYTABLE_NINF -1
613 static const yytype_uint8 yytable[] =
614 {
615        1,     2,     3,     4,     5,     6,    22,    23,    24,    17,
616        7,     8,     9,    10,    11,    12,     4,     5,     6,    28,
617       32,    29,    33,     7,     8,     9,    10,    11,    12,    25,
618       18,    19,    20,    21,    27,    30,    31,    34,    35,    36,
619        0,    37,    26
620 };
621 
622 #define yypact_value_is_default(Yystate) \
623   (!!((Yystate) == (-11)))
624 
625 #define yytable_value_is_error(Yytable_value) \
626   YYID (0)
627 
628 static const yytype_int8 yycheck[] =
629 {
630        3,     4,     5,     6,     7,     8,    10,    11,    12,    19,
631       13,    14,    15,    16,    17,    18,     6,     7,     8,    12,
632       12,    14,    14,    13,    14,    15,    16,    17,    18,     0,
633       19,    19,    19,    18,    10,    18,    14,    14,    12,    14,
634       -1,    14,    14
635 };
636 
637 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
638    symbol of state STATE-NUM.  */
639 static const yytype_uint8 yystos[] =
640 {
641        0,     3,     4,     5,     6,     7,     8,    13,    14,    15,
642       16,    17,    18,    22,    23,    24,    25,    19,    19,    19,
643       19,    18,    10,    11,    12,     0,    24,    10,    12,    14,
644       18,    14,    12,    14,    14,    12,    14,    14
645 };
646 
647 #define yyerrok		(yyerrstatus = 0)
648 #define yyclearin	(yychar = YYEMPTY)
649 #define YYEMPTY		(-2)
650 #define YYEOF		0
651 
652 #define YYACCEPT	goto yyacceptlab
653 #define YYABORT		goto yyabortlab
654 #define YYERROR		goto yyerrorlab
655 
656 
657 /* Like YYERROR except do call yyerror.  This remains here temporarily
658    to ease the transition to the new meaning of YYERROR, for GCC.
659    Once GCC version 2 has supplanted version 1, this can go.  However,
660    YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
661    in Bison 2.4.2's NEWS entry, where a plan to phase it out is
662    discussed.  */
663 
664 #define YYFAIL		goto yyerrlab
665 #if defined YYFAIL
666   /* This is here to suppress warnings from the GCC cpp's
667      -Wunused-macros.  Normally we don't worry about that warning, but
668      some users do, and we want to make it easy for users to remove
669      YYFAIL uses, which will produce warnings from Bison 2.5.  */
670 #endif
671 
672 #define YYRECOVERING()  (!!yyerrstatus)
673 
674 #define YYBACKUP(Token, Value)                                  \
675 do                                                              \
676   if (yychar == YYEMPTY)                                        \
677     {                                                           \
678       yychar = (Token);                                         \
679       yylval = (Value);                                         \
680       YYPOPSTACK (yylen);                                       \
681       yystate = *yyssp;                                         \
682       goto yybackup;                                            \
683     }                                                           \
684   else                                                          \
685     {                                                           \
686       yyerror (tsrm_ls, YY_("syntax error: cannot back up")); \
687       YYERROR;							\
688     }								\
689 while (YYID (0))
690 
691 /* Error token number */
692 #define YYTERROR	1
693 #define YYERRCODE	256
694 
695 
696 /* This macro is provided for backward compatibility. */
697 #ifndef YY_LOCATION_PRINT
698 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
699 #endif
700 
701 
702 /* YYLEX -- calling `yylex' with the right arguments.  */
703 #ifdef YYLEX_PARAM
704 # define YYLEX yylex (&yylval, YYLEX_PARAM)
705 #else
706 # define YYLEX yylex (&yylval)
707 #endif
708 
709 /* Enable debugging if requested.  */
710 #if YYDEBUG
711 
712 # ifndef YYFPRINTF
713 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
714 #  define YYFPRINTF fprintf
715 # endif
716 
717 # define YYDPRINTF(Args)			\
718 do {						\
719   if (yydebug)					\
720     YYFPRINTF Args;				\
721 } while (YYID (0))
722 
723 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
724 do {									  \
725   if (yydebug)								  \
726     {									  \
727       YYFPRINTF (stderr, "%s ", Title);					  \
728       yy_symbol_print (stderr,						  \
729 		  Type, Value, tsrm_ls); \
730       YYFPRINTF (stderr, "\n");						  \
731     }									  \
732 } while (YYID (0))
733 
734 
735 /*--------------------------------.
736 | Print this symbol on YYOUTPUT.  |
737 `--------------------------------*/
738 
739 /*ARGSUSED*/
740 #if (defined __STDC__ || defined __C99__FUNC__ \
741      || defined __cplusplus || defined _MSC_VER)
742 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,void * tsrm_ls)743 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void *tsrm_ls)
744 #else
745 static void
746 yy_symbol_value_print (yyoutput, yytype, yyvaluep, tsrm_ls)
747     FILE *yyoutput;
748     int yytype;
749     YYSTYPE const * const yyvaluep;
750     void *tsrm_ls;
751 #endif
752 {
753   FILE *yyo = yyoutput;
754   YYUSE (yyo);
755   if (!yyvaluep)
756     return;
757   YYUSE (tsrm_ls);
758 # ifdef YYPRINT
759   if (yytype < YYNTOKENS)
760     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
761 # else
762   YYUSE (yyoutput);
763 # endif
764   YYUSE (yytype);
765 }
766 
767 
768 /*--------------------------------.
769 | Print this symbol on YYOUTPUT.  |
770 `--------------------------------*/
771 
772 #if (defined __STDC__ || defined __C99__FUNC__ \
773      || defined __cplusplus || defined _MSC_VER)
774 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,void * tsrm_ls)775 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void *tsrm_ls)
776 #else
777 static void
778 yy_symbol_print (yyoutput, yytype, yyvaluep, tsrm_ls)
779     FILE *yyoutput;
780     int yytype;
781     YYSTYPE const * const yyvaluep;
782     void *tsrm_ls;
783 #endif
784 {
785   if (yytype < YYNTOKENS)
786     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
787   else
788     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
789 
790   yy_symbol_value_print (yyoutput, yytype, yyvaluep, tsrm_ls);
791   YYFPRINTF (yyoutput, ")");
792 }
793 
794 /*------------------------------------------------------------------.
795 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
796 | TOP (included).                                                   |
797 `------------------------------------------------------------------*/
798 
799 #if (defined __STDC__ || defined __C99__FUNC__ \
800      || defined __cplusplus || defined _MSC_VER)
801 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)802 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
803 #else
804 static void
805 yy_stack_print (yybottom, yytop)
806     yytype_int16 *yybottom;
807     yytype_int16 *yytop;
808 #endif
809 {
810   YYFPRINTF (stderr, "Stack now");
811   for (; yybottom <= yytop; yybottom++)
812     {
813       int yybot = *yybottom;
814       YYFPRINTF (stderr, " %d", yybot);
815     }
816   YYFPRINTF (stderr, "\n");
817 }
818 
819 # define YY_STACK_PRINT(Bottom, Top)				\
820 do {								\
821   if (yydebug)							\
822     yy_stack_print ((Bottom), (Top));				\
823 } while (YYID (0))
824 
825 
826 /*------------------------------------------------.
827 | Report that the YYRULE is going to be reduced.  |
828 `------------------------------------------------*/
829 
830 #if (defined __STDC__ || defined __C99__FUNC__ \
831      || defined __cplusplus || defined _MSC_VER)
832 static void
yy_reduce_print(YYSTYPE * yyvsp,int yyrule,void * tsrm_ls)833 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, void *tsrm_ls)
834 #else
835 static void
836 yy_reduce_print (yyvsp, yyrule, tsrm_ls)
837     YYSTYPE *yyvsp;
838     int yyrule;
839     void *tsrm_ls;
840 #endif
841 {
842   int yynrhs = yyr2[yyrule];
843   int yyi;
844   unsigned long int yylno = yyrline[yyrule];
845   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
846 	     yyrule - 1, yylno);
847   /* The symbols being reduced.  */
848   for (yyi = 0; yyi < yynrhs; yyi++)
849     {
850       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
851       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
852 		       &(yyvsp[(yyi + 1) - (yynrhs)])
853 		       		       , tsrm_ls);
854       YYFPRINTF (stderr, "\n");
855     }
856 }
857 
858 # define YY_REDUCE_PRINT(Rule)		\
859 do {					\
860   if (yydebug)				\
861     yy_reduce_print (yyvsp, Rule, tsrm_ls); \
862 } while (YYID (0))
863 
864 /* Nonzero means print parse trace.  It is left uninitialized so that
865    multiple parsers can coexist.  */
866 int yydebug;
867 #else /* !YYDEBUG */
868 # define YYDPRINTF(Args)
869 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
870 # define YY_STACK_PRINT(Bottom, Top)
871 # define YY_REDUCE_PRINT(Rule)
872 #endif /* !YYDEBUG */
873 
874 
875 /* YYINITDEPTH -- initial size of the parser's stacks.  */
876 #ifndef	YYINITDEPTH
877 # define YYINITDEPTH 200
878 #endif
879 
880 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
881    if the built-in stack extension method is used).
882 
883    Do not make this value too large; the results are undefined if
884    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
885    evaluated with infinite-precision integer arithmetic.  */
886 
887 #ifndef YYMAXDEPTH
888 # define YYMAXDEPTH 10000
889 #endif
890 
891 
892 #if YYERROR_VERBOSE
893 
894 # ifndef yystrlen
895 #  if defined __GLIBC__ && defined _STRING_H
896 #   define yystrlen strlen
897 #  else
898 /* Return the length of YYSTR.  */
899 #if (defined __STDC__ || defined __C99__FUNC__ \
900      || defined __cplusplus || defined _MSC_VER)
901 static YYSIZE_T
yystrlen(const char * yystr)902 yystrlen (const char *yystr)
903 #else
904 static YYSIZE_T
905 yystrlen (yystr)
906     const char *yystr;
907 #endif
908 {
909   YYSIZE_T yylen;
910   for (yylen = 0; yystr[yylen]; yylen++)
911     continue;
912   return yylen;
913 }
914 #  endif
915 # endif
916 
917 # ifndef yystpcpy
918 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
919 #   define yystpcpy stpcpy
920 #  else
921 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
922    YYDEST.  */
923 #if (defined __STDC__ || defined __C99__FUNC__ \
924      || defined __cplusplus || defined _MSC_VER)
925 static char *
yystpcpy(char * yydest,const char * yysrc)926 yystpcpy (char *yydest, const char *yysrc)
927 #else
928 static char *
929 yystpcpy (yydest, yysrc)
930     char *yydest;
931     const char *yysrc;
932 #endif
933 {
934   char *yyd = yydest;
935   const char *yys = yysrc;
936 
937   while ((*yyd++ = *yys++) != '\0')
938     continue;
939 
940   return yyd - 1;
941 }
942 #  endif
943 # endif
944 
945 # ifndef yytnamerr
946 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
947    quotes and backslashes, so that it's suitable for yyerror.  The
948    heuristic is that double-quoting is unnecessary unless the string
949    contains an apostrophe, a comma, or backslash (other than
950    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
951    null, do not copy; instead, return the length of what the result
952    would have been.  */
953 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)954 yytnamerr (char *yyres, const char *yystr)
955 {
956   if (*yystr == '"')
957     {
958       YYSIZE_T yyn = 0;
959       char const *yyp = yystr;
960 
961       for (;;)
962 	switch (*++yyp)
963 	  {
964 	  case '\'':
965 	  case ',':
966 	    goto do_not_strip_quotes;
967 
968 	  case '\\':
969 	    if (*++yyp != '\\')
970 	      goto do_not_strip_quotes;
971 	    /* Fall through.  */
972 	  default:
973 	    if (yyres)
974 	      yyres[yyn] = *yyp;
975 	    yyn++;
976 	    break;
977 
978 	  case '"':
979 	    if (yyres)
980 	      yyres[yyn] = '\0';
981 	    return yyn;
982 	  }
983     do_not_strip_quotes: ;
984     }
985 
986   if (! yyres)
987     return yystrlen (yystr);
988 
989   return yystpcpy (yyres, yystr) - yyres;
990 }
991 # endif
992 
993 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
994    about the unexpected token YYTOKEN for the state stack whose top is
995    YYSSP.
996 
997    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
998    not large enough to hold the message.  In that case, also set
999    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1000    required number of bytes is too large to store.  */
1001 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyssp,int yytoken)1002 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1003                 yytype_int16 *yyssp, int yytoken)
1004 {
1005   YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1006   YYSIZE_T yysize = yysize0;
1007   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1008   /* Internationalized format string. */
1009   const char *yyformat = YY_NULL;
1010   /* Arguments of yyformat. */
1011   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1012   /* Number of reported tokens (one for the "unexpected", one per
1013      "expected"). */
1014   int yycount = 0;
1015 
1016   /* There are many possibilities here to consider:
1017      - Assume YYFAIL is not used.  It's too flawed to consider.  See
1018        <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1019        for details.  YYERROR is fine as it does not invoke this
1020        function.
1021      - If this state is a consistent state with a default action, then
1022        the only way this function was invoked is if the default action
1023        is an error action.  In that case, don't check for expected
1024        tokens because there are none.
1025      - The only way there can be no lookahead present (in yychar) is if
1026        this state is a consistent state with a default action.  Thus,
1027        detecting the absence of a lookahead is sufficient to determine
1028        that there is no unexpected or expected token to report.  In that
1029        case, just report a simple "syntax error".
1030      - Don't assume there isn't a lookahead just because this state is a
1031        consistent state with a default action.  There might have been a
1032        previous inconsistent state, consistent state with a non-default
1033        action, or user semantic action that manipulated yychar.
1034      - Of course, the expected token list depends on states to have
1035        correct lookahead information, and it depends on the parser not
1036        to perform extra reductions after fetching a lookahead from the
1037        scanner and before detecting a syntax error.  Thus, state merging
1038        (from LALR or IELR) and default reductions corrupt the expected
1039        token list.  However, the list is correct for canonical LR with
1040        one exception: it will still contain any token that will not be
1041        accepted due to an error action in a later state.
1042   */
1043   if (yytoken != YYEMPTY)
1044     {
1045       int yyn = yypact[*yyssp];
1046       yyarg[yycount++] = yytname[yytoken];
1047       if (!yypact_value_is_default (yyn))
1048         {
1049           /* Start YYX at -YYN if negative to avoid negative indexes in
1050              YYCHECK.  In other words, skip the first -YYN actions for
1051              this state because they are default actions.  */
1052           int yyxbegin = yyn < 0 ? -yyn : 0;
1053           /* Stay within bounds of both yycheck and yytname.  */
1054           int yychecklim = YYLAST - yyn + 1;
1055           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1056           int yyx;
1057 
1058           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1059             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1060                 && !yytable_value_is_error (yytable[yyx + yyn]))
1061               {
1062                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1063                   {
1064                     yycount = 1;
1065                     yysize = yysize0;
1066                     break;
1067                   }
1068                 yyarg[yycount++] = yytname[yyx];
1069                 {
1070                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1071                   if (! (yysize <= yysize1
1072                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1073                     return 2;
1074                   yysize = yysize1;
1075                 }
1076               }
1077         }
1078     }
1079 
1080   switch (yycount)
1081     {
1082 # define YYCASE_(N, S)                      \
1083       case N:                               \
1084         yyformat = S;                       \
1085       break
1086       YYCASE_(0, YY_("syntax error"));
1087       YYCASE_(1, YY_("syntax error, unexpected %s"));
1088       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1089       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1090       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1091       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1092 # undef YYCASE_
1093     }
1094 
1095   {
1096     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1097     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1098       return 2;
1099     yysize = yysize1;
1100   }
1101 
1102   if (*yymsg_alloc < yysize)
1103     {
1104       *yymsg_alloc = 2 * yysize;
1105       if (! (yysize <= *yymsg_alloc
1106              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1107         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1108       return 1;
1109     }
1110 
1111   /* Avoid sprintf, as that infringes on the user's name space.
1112      Don't have undefined behavior even if the translation
1113      produced a string with the wrong number of "%s"s.  */
1114   {
1115     char *yyp = *yymsg;
1116     int yyi = 0;
1117     while ((*yyp = *yyformat) != '\0')
1118       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1119         {
1120           yyp += yytnamerr (yyp, yyarg[yyi++]);
1121           yyformat += 2;
1122         }
1123       else
1124         {
1125           yyp++;
1126           yyformat++;
1127         }
1128   }
1129   return 0;
1130 }
1131 #endif /* YYERROR_VERBOSE */
1132 
1133 /*-----------------------------------------------.
1134 | Release the memory associated to this symbol.  |
1135 `-----------------------------------------------*/
1136 
1137 /*ARGSUSED*/
1138 #if (defined __STDC__ || defined __C99__FUNC__ \
1139      || defined __cplusplus || defined _MSC_VER)
1140 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,void * tsrm_ls)1141 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, void *tsrm_ls)
1142 #else
1143 static void
1144 yydestruct (yymsg, yytype, yyvaluep, tsrm_ls)
1145     const char *yymsg;
1146     int yytype;
1147     YYSTYPE *yyvaluep;
1148     void *tsrm_ls;
1149 #endif
1150 {
1151   YYUSE (yyvaluep);
1152   YYUSE (tsrm_ls);
1153 
1154   if (!yymsg)
1155     yymsg = "Deleting";
1156   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1157 
1158   YYUSE (yytype);
1159 }
1160 
1161 
1162 
1163 
1164 /*----------.
1165 | yyparse.  |
1166 `----------*/
1167 
1168 #ifdef YYPARSE_PARAM
1169 #if (defined __STDC__ || defined __C99__FUNC__ \
1170      || defined __cplusplus || defined _MSC_VER)
1171 int
yyparse(void * YYPARSE_PARAM)1172 yyparse (void *YYPARSE_PARAM)
1173 #else
1174 int
1175 yyparse (YYPARSE_PARAM)
1176     void *YYPARSE_PARAM;
1177 #endif
1178 #else /* ! YYPARSE_PARAM */
1179 #if (defined __STDC__ || defined __C99__FUNC__ \
1180      || defined __cplusplus || defined _MSC_VER)
1181 int
1182 yyparse (void *tsrm_ls)
1183 #else
1184 int
1185 yyparse (tsrm_ls)
1186     void *tsrm_ls;
1187 #endif
1188 #endif
1189 {
1190 /* The lookahead symbol.  */
1191 int yychar;
1192 
1193 
1194 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
1195 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
1196 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
1197     _Pragma ("GCC diagnostic push") \
1198     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
1199     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
1200 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
1201     _Pragma ("GCC diagnostic pop")
1202 #else
1203 /* Default value used for initialization, for pacifying older GCCs
1204    or non-GCC compilers.  */
1205 static YYSTYPE yyval_default;
1206 # define YY_INITIAL_VALUE(Value) = Value
1207 #endif
1208 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1209 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1210 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1211 #endif
1212 #ifndef YY_INITIAL_VALUE
1213 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1214 #endif
1215 
1216 /* The semantic value of the lookahead symbol.  */
1217 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1218 
1219     /* Number of syntax errors so far.  */
1220     int yynerrs;
1221 
1222     int yystate;
1223     /* Number of tokens to shift before error messages enabled.  */
1224     int yyerrstatus;
1225 
1226     /* The stacks and their tools:
1227        `yyss': related to states.
1228        `yyvs': related to semantic values.
1229 
1230        Refer to the stacks through separate pointers, to allow yyoverflow
1231        to reallocate them elsewhere.  */
1232 
1233     /* The state stack.  */
1234     yytype_int16 yyssa[YYINITDEPTH];
1235     yytype_int16 *yyss;
1236     yytype_int16 *yyssp;
1237 
1238     /* The semantic value stack.  */
1239     YYSTYPE yyvsa[YYINITDEPTH];
1240     YYSTYPE *yyvs;
1241     YYSTYPE *yyvsp;
1242 
1243     YYSIZE_T yystacksize;
1244 
1245   int yyn;
1246   int yyresult;
1247   /* Lookahead token as an internal (translated) token number.  */
1248   int yytoken = 0;
1249   /* The variables used to return semantic value and location from the
1250      action routines.  */
1251   YYSTYPE yyval;
1252 
1253 #if YYERROR_VERBOSE
1254   /* Buffer for error messages, and its allocated size.  */
1255   char yymsgbuf[128];
1256   char *yymsg = yymsgbuf;
1257   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1258 #endif
1259 
1260 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1261 
1262   /* The number of symbols on the RHS of the reduced rule.
1263      Keep to zero when no symbol should be popped.  */
1264   int yylen = 0;
1265 
1266   yyssp = yyss = yyssa;
1267   yyvsp = yyvs = yyvsa;
1268   yystacksize = YYINITDEPTH;
1269 
1270   YYDPRINTF ((stderr, "Starting parse\n"));
1271 
1272   yystate = 0;
1273   yyerrstatus = 0;
1274   yynerrs = 0;
1275   yychar = YYEMPTY; /* Cause a token to be read.  */
1276   goto yysetstate;
1277 
1278 /*------------------------------------------------------------.
1279 | yynewstate -- Push a new state, which is found in yystate.  |
1280 `------------------------------------------------------------*/
1281  yynewstate:
1282   /* In all cases, when you get here, the value and location stacks
1283      have just been pushed.  So pushing a state here evens the stacks.  */
1284   yyssp++;
1285 
1286  yysetstate:
1287   *yyssp = yystate;
1288 
1289   if (yyss + yystacksize - 1 <= yyssp)
1290     {
1291       /* Get the current used size of the three stacks, in elements.  */
1292       YYSIZE_T yysize = yyssp - yyss + 1;
1293 
1294 #ifdef yyoverflow
1295       {
1296 	/* Give user a chance to reallocate the stack.  Use copies of
1297 	   these so that the &'s don't force the real ones into
1298 	   memory.  */
1299 	YYSTYPE *yyvs1 = yyvs;
1300 	yytype_int16 *yyss1 = yyss;
1301 
1302 	/* Each stack pointer address is followed by the size of the
1303 	   data in use in that stack, in bytes.  This used to be a
1304 	   conditional around just the two extra args, but that might
1305 	   be undefined if yyoverflow is a macro.  */
1306 	yyoverflow (YY_("memory exhausted"),
1307 		    &yyss1, yysize * sizeof (*yyssp),
1308 		    &yyvs1, yysize * sizeof (*yyvsp),
1309 		    &yystacksize);
1310 
1311 	yyss = yyss1;
1312 	yyvs = yyvs1;
1313       }
1314 #else /* no yyoverflow */
1315 # ifndef YYSTACK_RELOCATE
1316       goto yyexhaustedlab;
1317 # else
1318       /* Extend the stack our own way.  */
1319       if (YYMAXDEPTH <= yystacksize)
1320 	goto yyexhaustedlab;
1321       yystacksize *= 2;
1322       if (YYMAXDEPTH < yystacksize)
1323 	yystacksize = YYMAXDEPTH;
1324 
1325       {
1326 	yytype_int16 *yyss1 = yyss;
1327 	union yyalloc *yyptr =
1328 	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1329 	if (! yyptr)
1330 	  goto yyexhaustedlab;
1331 	YYSTACK_RELOCATE (yyss_alloc, yyss);
1332 	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
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       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1344 		  (unsigned long int) yystacksize));
1345 
1346       if (yyss + yystacksize - 1 <= yyssp)
1347 	YYABORT;
1348     }
1349 
1350   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1351 
1352   if (yystate == YYFINAL)
1353     YYACCEPT;
1354 
1355   goto yybackup;
1356 
1357 /*-----------.
1358 | yybackup.  |
1359 `-----------*/
1360 yybackup:
1361 
1362   /* Do appropriate processing given the current state.  Read a
1363      lookahead token if we need one and don't already have one.  */
1364 
1365   /* First try to decide what to do without reference to lookahead token.  */
1366   yyn = yypact[yystate];
1367   if (yypact_value_is_default (yyn))
1368     goto yydefault;
1369 
1370   /* Not known => get a lookahead token if don't already have one.  */
1371 
1372   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1373   if (yychar == YYEMPTY)
1374     {
1375       YYDPRINTF ((stderr, "Reading a token: "));
1376       yychar = YYLEX;
1377     }
1378 
1379   if (yychar <= YYEOF)
1380     {
1381       yychar = yytoken = YYEOF;
1382       YYDPRINTF ((stderr, "Now at end of input.\n"));
1383     }
1384   else
1385     {
1386       yytoken = YYTRANSLATE (yychar);
1387       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1388     }
1389 
1390   /* If the proper action on seeing token YYTOKEN is to reduce or to
1391      detect an error, take that action.  */
1392   yyn += yytoken;
1393   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1394     goto yydefault;
1395   yyn = yytable[yyn];
1396   if (yyn <= 0)
1397     {
1398       if (yytable_value_is_error (yyn))
1399         goto yyerrlab;
1400       yyn = -yyn;
1401       goto yyreduce;
1402     }
1403 
1404   /* Count tokens shifted since error; after three, turn off error
1405      status.  */
1406   if (yyerrstatus)
1407     yyerrstatus--;
1408 
1409   /* Shift the lookahead token.  */
1410   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1411 
1412   /* Discard the shifted token.  */
1413   yychar = YYEMPTY;
1414 
1415   yystate = yyn;
1416   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1417   *++yyvsp = yylval;
1418   YY_IGNORE_MAYBE_UNINITIALIZED_END
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 3:
1455 /* Line 1802 of yacc.c  */
1456 #line 67 "sapi/phpdbg/phpdbg_parser.y"
1457     { phpdbg_stack_push(PHPDBG_G(parser_stack), &(yyvsp[(1) - (1)])); }
1458     break;
1459 
1460   case 5:
1461 /* Line 1802 of yacc.c  */
1462 #line 72 "sapi/phpdbg/phpdbg_parser.y"
1463     { phpdbg_stack_push(PHPDBG_G(parser_stack), &(yyvsp[(1) - (1)])); }
1464     break;
1465 
1466   case 6:
1467 /* Line 1802 of yacc.c  */
1468 #line 73 "sapi/phpdbg/phpdbg_parser.y"
1469     { phpdbg_stack_push(PHPDBG_G(parser_stack), &(yyvsp[(2) - (2)])); }
1470     break;
1471 
1472   case 7:
1473 /* Line 1802 of yacc.c  */
1474 #line 77 "sapi/phpdbg/phpdbg_parser.y"
1475     {
1476 		(yyval).type = FILE_PARAM;
1477 		(yyval).file.name = (yyvsp[(2) - (3)]).str;
1478 		(yyval).file.line = (yyvsp[(3) - (3)]).num;
1479 	}
1480     break;
1481 
1482   case 8:
1483 /* Line 1802 of yacc.c  */
1484 #line 82 "sapi/phpdbg/phpdbg_parser.y"
1485     {
1486 		(yyval).type = NUMERIC_FILE_PARAM;
1487 		(yyval).file.name = (yyvsp[(1) - (4)]).str;
1488 		(yyval).file.line = (yyvsp[(4) - (4)]).num;
1489 	}
1490     break;
1491 
1492   case 9:
1493 /* Line 1802 of yacc.c  */
1494 #line 87 "sapi/phpdbg/phpdbg_parser.y"
1495     {
1496 		(yyval).type = FILE_PARAM;
1497 		(yyval).file.name = malloc((yyvsp[(1) - (4)]).len + (yyvsp[(2) - (4)]).len + 1);
1498 		if ((yyval).file.name) {
1499 			memcpy(&(yyval).file.name[0], (yyvsp[(1) - (4)]).str, (yyvsp[(1) - (4)]).len);
1500 			memcpy(&(yyval).file.name[(yyvsp[(1) - (4)]).len], (yyvsp[(2) - (4)]).str, (yyvsp[(2) - (4)]).len);
1501 			(yyval).file.name[(yyvsp[(1) - (4)]).len + (yyvsp[(2) - (4)]).len] = '\0';
1502 		}
1503 		(yyval).file.line = (yyvsp[(4) - (4)]).num;
1504 	}
1505     break;
1506 
1507   case 10:
1508 /* Line 1802 of yacc.c  */
1509 #line 97 "sapi/phpdbg/phpdbg_parser.y"
1510     {
1511 		(yyval).type = NUMERIC_FILE_PARAM;
1512 		(yyval).file.name = malloc((yyvsp[(1) - (5)]).len + (yyvsp[(2) - (5)]).len + 1);
1513 		if ((yyval).file.name) {
1514 			memcpy(&(yyval).file.name[0], (yyvsp[(1) - (5)]).str, (yyvsp[(1) - (5)]).len);
1515 			memcpy(&(yyval).file.name[(yyvsp[(1) - (5)]).len], (yyvsp[(2) - (5)]).str, (yyvsp[(2) - (5)]).len);
1516 			(yyval).file.name[(yyvsp[(1) - (5)]).len + (yyvsp[(2) - (5)]).len] = '\0';
1517 		}
1518 		(yyval).file.line = (yyvsp[(5) - (5)]).num;
1519 	}
1520     break;
1521 
1522   case 11:
1523 /* Line 1802 of yacc.c  */
1524 #line 107 "sapi/phpdbg/phpdbg_parser.y"
1525     {
1526 		(yyval).type = METHOD_PARAM;
1527 		(yyval).method.class = (yyvsp[(1) - (3)]).str;
1528 		(yyval).method.name = (yyvsp[(3) - (3)]).str;
1529 	}
1530     break;
1531 
1532   case 12:
1533 /* Line 1802 of yacc.c  */
1534 #line 112 "sapi/phpdbg/phpdbg_parser.y"
1535     {
1536 		(yyval).type = NUMERIC_METHOD_PARAM;
1537 		(yyval).method.class = (yyvsp[(1) - (5)]).str;
1538 		(yyval).method.name = (yyvsp[(3) - (5)]).str;
1539 		(yyval).num = (yyvsp[(5) - (5)]).num;
1540 	}
1541     break;
1542 
1543   case 13:
1544 /* Line 1802 of yacc.c  */
1545 #line 118 "sapi/phpdbg/phpdbg_parser.y"
1546     {
1547 		(yyval).type = NUMERIC_FUNCTION_PARAM;
1548 		(yyval).str = (yyvsp[(1) - (3)]).str;
1549 		(yyval).len = (yyvsp[(1) - (3)]).len;
1550 		(yyval).num = (yyvsp[(3) - (3)]).num;
1551 	}
1552     break;
1553 
1554   case 14:
1555 /* Line 1802 of yacc.c  */
1556 #line 124 "sapi/phpdbg/phpdbg_parser.y"
1557     {
1558 		(yyval).type = COND_PARAM;
1559 		(yyval).str = (yyvsp[(2) - (2)]).str;
1560 		(yyval).len = (yyvsp[(2) - (2)]).len;
1561 	}
1562     break;
1563 
1564   case 15:
1565 /* Line 1802 of yacc.c  */
1566 #line 129 "sapi/phpdbg/phpdbg_parser.y"
1567     { (yyval) = (yyvsp[(1) - (1)]); }
1568     break;
1569 
1570   case 16:
1571 /* Line 1802 of yacc.c  */
1572 #line 130 "sapi/phpdbg/phpdbg_parser.y"
1573     { (yyval) = (yyvsp[(1) - (1)]); }
1574     break;
1575 
1576   case 17:
1577 /* Line 1802 of yacc.c  */
1578 #line 131 "sapi/phpdbg/phpdbg_parser.y"
1579     { (yyval) = (yyvsp[(1) - (1)]); }
1580     break;
1581 
1582   case 18:
1583 /* Line 1802 of yacc.c  */
1584 #line 132 "sapi/phpdbg/phpdbg_parser.y"
1585     { (yyval) = (yyvsp[(1) - (1)]); }
1586     break;
1587 
1588   case 19:
1589 /* Line 1802 of yacc.c  */
1590 #line 133 "sapi/phpdbg/phpdbg_parser.y"
1591     { (yyval) = (yyvsp[(1) - (1)]); }
1592     break;
1593 
1594   case 20:
1595 /* Line 1802 of yacc.c  */
1596 #line 134 "sapi/phpdbg/phpdbg_parser.y"
1597     { (yyval) = (yyvsp[(1) - (1)]); }
1598     break;
1599 
1600   case 21:
1601 /* Line 1802 of yacc.c  */
1602 #line 135 "sapi/phpdbg/phpdbg_parser.y"
1603     { (yyval) = (yyvsp[(1) - (1)]); }
1604     break;
1605 
1606   case 22:
1607 /* Line 1802 of yacc.c  */
1608 #line 139 "sapi/phpdbg/phpdbg_parser.y"
1609     {
1610 		(yyval).type = EVAL_PARAM;
1611 		(yyval).str = (yyvsp[(2) - (2)]).str;
1612 		(yyval).len = (yyvsp[(2) - (2)]).len;
1613 	}
1614     break;
1615 
1616   case 23:
1617 /* Line 1802 of yacc.c  */
1618 #line 144 "sapi/phpdbg/phpdbg_parser.y"
1619     {
1620 		(yyval).type = SHELL_PARAM;
1621 		(yyval).str = (yyvsp[(2) - (2)]).str;
1622 		(yyval).len = (yyvsp[(2) - (2)]).len;
1623 	}
1624     break;
1625 
1626   case 24:
1627 /* Line 1802 of yacc.c  */
1628 #line 149 "sapi/phpdbg/phpdbg_parser.y"
1629     {
1630 		(yyval).type = RUN_PARAM;
1631 		(yyval).len = 0;
1632 	}
1633     break;
1634 
1635   case 25:
1636 /* Line 1802 of yacc.c  */
1637 #line 153 "sapi/phpdbg/phpdbg_parser.y"
1638     {
1639 		(yyval).type = RUN_PARAM;
1640 		(yyval).str = (yyvsp[(2) - (2)]).str;
1641 		(yyval).len = (yyvsp[(2) - (2)]).len;
1642 	}
1643     break;
1644 
1645 
1646 /* Line 1802 of yacc.c  */
1647 #line 1648 "sapi/phpdbg/phpdbg_parser.c"
1648       default: break;
1649     }
1650   /* User semantic actions sometimes alter yychar, and that requires
1651      that yytoken be updated with the new translation.  We take the
1652      approach of translating immediately before every use of yytoken.
1653      One alternative is translating here after every semantic action,
1654      but that translation would be missed if the semantic action invokes
1655      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1656      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
1657      incorrect destructor might then be invoked immediately.  In the
1658      case of YYERROR or YYBACKUP, subsequent parser actions might lead
1659      to an incorrect destructor call or verbose syntax error message
1660      before the lookahead is translated.  */
1661   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1662 
1663   YYPOPSTACK (yylen);
1664   yylen = 0;
1665   YY_STACK_PRINT (yyss, yyssp);
1666 
1667   *++yyvsp = yyval;
1668 
1669   /* Now `shift' the result of the reduction.  Determine what state
1670      that goes to, based on the state we popped back to and the rule
1671      number reduced by.  */
1672 
1673   yyn = yyr1[yyn];
1674 
1675   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1676   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1677     yystate = yytable[yystate];
1678   else
1679     yystate = yydefgoto[yyn - YYNTOKENS];
1680 
1681   goto yynewstate;
1682 
1683 
1684 /*------------------------------------.
1685 | yyerrlab -- here on detecting error |
1686 `------------------------------------*/
1687 yyerrlab:
1688   /* Make sure we have latest lookahead translation.  See comments at
1689      user semantic actions for why this is necessary.  */
1690   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1691 
1692   /* If not already recovering from an error, report this error.  */
1693   if (!yyerrstatus)
1694     {
1695       ++yynerrs;
1696 #if ! YYERROR_VERBOSE
1697       yyerror (tsrm_ls, YY_("syntax error"));
1698 #else
1699 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1700                                         yyssp, yytoken)
1701       {
1702         char const *yymsgp = YY_("syntax error");
1703         int yysyntax_error_status;
1704         yysyntax_error_status = YYSYNTAX_ERROR;
1705         if (yysyntax_error_status == 0)
1706           yymsgp = yymsg;
1707         else if (yysyntax_error_status == 1)
1708           {
1709             if (yymsg != yymsgbuf)
1710               YYSTACK_FREE (yymsg);
1711             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1712             if (!yymsg)
1713               {
1714                 yymsg = yymsgbuf;
1715                 yymsg_alloc = sizeof yymsgbuf;
1716                 yysyntax_error_status = 2;
1717               }
1718             else
1719               {
1720                 yysyntax_error_status = YYSYNTAX_ERROR;
1721                 yymsgp = yymsg;
1722               }
1723           }
1724         yyerror (tsrm_ls, yymsgp);
1725         if (yysyntax_error_status == 2)
1726           goto yyexhaustedlab;
1727       }
1728 # undef YYSYNTAX_ERROR
1729 #endif
1730     }
1731 
1732 
1733 
1734   if (yyerrstatus == 3)
1735     {
1736       /* If just tried and failed to reuse lookahead token after an
1737 	 error, discard it.  */
1738 
1739       if (yychar <= YYEOF)
1740 	{
1741 	  /* Return failure if at end of input.  */
1742 	  if (yychar == YYEOF)
1743 	    YYABORT;
1744 	}
1745       else
1746 	{
1747 	  yydestruct ("Error: discarding",
1748 		      yytoken, &yylval, tsrm_ls);
1749 	  yychar = YYEMPTY;
1750 	}
1751     }
1752 
1753   /* Else will try to reuse lookahead token after shifting the error
1754      token.  */
1755   goto yyerrlab1;
1756 
1757 
1758 /*---------------------------------------------------.
1759 | yyerrorlab -- error raised explicitly by YYERROR.  |
1760 `---------------------------------------------------*/
1761 yyerrorlab:
1762 
1763   /* Pacify compilers like GCC when the user code never invokes
1764      YYERROR and the label yyerrorlab therefore never appears in user
1765      code.  */
1766   if (/*CONSTCOND*/ 0)
1767      goto yyerrorlab;
1768 
1769   /* Do not reclaim the symbols of the rule which action triggered
1770      this YYERROR.  */
1771   YYPOPSTACK (yylen);
1772   yylen = 0;
1773   YY_STACK_PRINT (yyss, yyssp);
1774   yystate = *yyssp;
1775   goto yyerrlab1;
1776 
1777 
1778 /*-------------------------------------------------------------.
1779 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1780 `-------------------------------------------------------------*/
1781 yyerrlab1:
1782   yyerrstatus = 3;	/* Each real token shifted decrements this.  */
1783 
1784   for (;;)
1785     {
1786       yyn = yypact[yystate];
1787       if (!yypact_value_is_default (yyn))
1788 	{
1789 	  yyn += YYTERROR;
1790 	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1791 	    {
1792 	      yyn = yytable[yyn];
1793 	      if (0 < yyn)
1794 		break;
1795 	    }
1796 	}
1797 
1798       /* Pop the current state because it cannot handle the error token.  */
1799       if (yyssp == yyss)
1800 	YYABORT;
1801 
1802 
1803       yydestruct ("Error: popping",
1804 		  yystos[yystate], yyvsp, tsrm_ls);
1805       YYPOPSTACK (1);
1806       yystate = *yyssp;
1807       YY_STACK_PRINT (yyss, yyssp);
1808     }
1809 
1810   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1811   *++yyvsp = yylval;
1812   YY_IGNORE_MAYBE_UNINITIALIZED_END
1813 
1814 
1815   /* Shift the error token.  */
1816   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1817 
1818   yystate = yyn;
1819   goto yynewstate;
1820 
1821 
1822 /*-------------------------------------.
1823 | yyacceptlab -- YYACCEPT comes here.  |
1824 `-------------------------------------*/
1825 yyacceptlab:
1826   yyresult = 0;
1827   goto yyreturn;
1828 
1829 /*-----------------------------------.
1830 | yyabortlab -- YYABORT comes here.  |
1831 `-----------------------------------*/
1832 yyabortlab:
1833   yyresult = 1;
1834   goto yyreturn;
1835 
1836 #if !defined yyoverflow || YYERROR_VERBOSE
1837 /*-------------------------------------------------.
1838 | yyexhaustedlab -- memory exhaustion comes here.  |
1839 `-------------------------------------------------*/
1840 yyexhaustedlab:
1841   yyerror (tsrm_ls, YY_("memory exhausted"));
1842   yyresult = 2;
1843   /* Fall through.  */
1844 #endif
1845 
1846 yyreturn:
1847   if (yychar != YYEMPTY)
1848     {
1849       /* Make sure we have latest lookahead translation.  See comments at
1850          user semantic actions for why this is necessary.  */
1851       yytoken = YYTRANSLATE (yychar);
1852       yydestruct ("Cleanup: discarding lookahead",
1853                   yytoken, &yylval, tsrm_ls);
1854     }
1855   /* Do not reclaim the symbols of the rule which action triggered
1856      this YYABORT or YYACCEPT.  */
1857   YYPOPSTACK (yylen);
1858   YY_STACK_PRINT (yyss, yyssp);
1859   while (yyssp != yyss)
1860     {
1861       yydestruct ("Cleanup: popping",
1862 		  yystos[*yyssp], yyvsp, tsrm_ls);
1863       YYPOPSTACK (1);
1864     }
1865 #ifndef yyoverflow
1866   if (yyss != yyssa)
1867     YYSTACK_FREE (yyss);
1868 #endif
1869 #if YYERROR_VERBOSE
1870   if (yymsg != yymsgbuf)
1871     YYSTACK_FREE (yymsg);
1872 #endif
1873   /* Make sure YYID is used.  */
1874   return YYID (yyresult);
1875 }
1876 
1877 
1878 /* Line 2050 of yacc.c  */
1879 #line 160 "sapi/phpdbg/phpdbg_parser.y"
1880 
1881 
yyerror(void *** tsrm_ls,const char * msg)1882 static int yyerror(void ***tsrm_ls, const char *msg) {
1883 	phpdbg_error("Parse Error: %s", msg);
1884 
1885 	{
1886 		const phpdbg_param_t *top = PHPDBG_G(parser_stack);
1887 
1888 		while (top) {
1889 			phpdbg_param_debug(top, "--> ");
1890 			top = top->next;
1891 		}
1892 	}
1893 	return 0;
1894 }
1895 
phpdbg_do_parse(phpdbg_param_t * stack,char * input TSRMLS_DC)1896 int phpdbg_do_parse(phpdbg_param_t *stack, char *input TSRMLS_DC) {
1897 	phpdbg_init_lexer(stack, input TSRMLS_CC);
1898 
1899 #ifdef ZTS
1900 	return yyparse(TSRMLS_C);
1901 #else
1902 	return yyparse(NULL);
1903 #endif
1904 }
1905