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