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