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
