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-2025, 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 560 : yydestruct (const char *yymsg,
869 : yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
870 : {
871 : YY_USE (yyvaluep);
872 560 : 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 560 : }
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 280 : yyparse (void)
899 : {
900 280 : yy_state_fast_t yystate = 0;
901 : /* Number of tokens to shift before error messages enabled. */
902 280 : 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 280 : YYPTRDIFF_T yystacksize = YYINITDEPTH;
909 :
910 : /* The state stack: array, bottom, top. */
911 : yy_state_t yyssa[YYINITDEPTH];
912 280 : yy_state_t *yyss = yyssa;
913 280 : yy_state_t *yyssp = yyss;
914 :
915 : /* The semantic value stack: array, bottom, top. */
916 : YYSTYPE yyvsa[YYINITDEPTH];
917 280 : YYSTYPE *yyvs = yyvsa;
918 280 : YYSTYPE *yyvsp = yyvs;
919 :
920 : int yyn;
921 : /* The return value of yyparse. */
922 : int yyresult;
923 : /* Lookahead symbol kind. */
924 280 : 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 280 : int yylen = 0;
936 :
937 : YYDPRINTF ((stderr, "Starting parse\n"));
938 :
939 280 : yychar = YYEMPTY; /* Cause a token to be read. */
940 :
941 280 : goto yysetstate;
942 :
943 :
944 : /*------------------------------------------------------------.
945 : | yynewstate -- push a new state, which is found in yystate. |
946 : `------------------------------------------------------------*/
947 84310 : 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 84310 : yyssp++;
951 :
952 :
953 : /*--------------------------------------------------------------------.
954 : | yysetstate -- set current state (the top of the stack) to yystate. |
955 : `--------------------------------------------------------------------*/
956 84590 : yysetstate:
957 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
958 : YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
959 : YY_IGNORE_USELESS_CAST_BEGIN
960 84590 : *yyssp = YY_CAST (yy_state_t, yystate);
961 : YY_IGNORE_USELESS_CAST_END
962 : YY_STACK_PRINT (yyss, yyssp);
963 :
964 84590 : 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 84590 : if (yystate == YYFINAL)
1029 280 : YYACCEPT;
1030 :
1031 84310 : goto yybackup;
1032 :
1033 :
1034 : /*-----------.
1035 : | yybackup. |
1036 : `-----------*/
1037 84310 : 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 84310 : yyn = yypact[yystate];
1043 84310 : if (yypact_value_is_default (yyn))
1044 29938 : 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 54372 : if (yychar == YYEMPTY)
1050 : {
1051 : YYDPRINTF ((stderr, "Reading a token\n"));
1052 32928 : yychar = yylex ();
1053 : }
1054 :
1055 54372 : if (yychar <= YYEOF)
1056 : {
1057 1088 : yychar = YYEOF;
1058 1088 : yytoken = YYSYMBOL_YYEOF;
1059 : YYDPRINTF ((stderr, "Now at end of input.\n"));
1060 : }
1061 53284 : 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 53284 : 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 54372 : yyn += yytoken;
1080 54372 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1081 21444 : goto yydefault;
1082 32928 : yyn = yytable[yyn];
1083 32928 : 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 32928 : if (yyerrstatus)
1094 0 : yyerrstatus--;
1095 :
1096 : /* Shift the lookahead token. */
1097 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1098 32928 : yystate = yyn;
1099 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1100 32928 : *++yyvsp = yylval;
1101 : YY_IGNORE_MAYBE_UNINITIALIZED_END
1102 :
1103 : /* Discard the shifted token. */
1104 32928 : yychar = YYEMPTY;
1105 32928 : goto yynewstate;
1106 :
1107 :
1108 : /*-----------------------------------------------------------.
1109 : | yydefault -- do the default action for the current state. |
1110 : `-----------------------------------------------------------*/
1111 51382 : yydefault:
1112 51382 : yyn = yydefact[yystate];
1113 51382 : if (yyn == 0)
1114 0 : goto yyerrlab;
1115 51382 : goto yyreduce;
1116 :
1117 :
1118 : /*-----------------------------.
1119 : | yyreduce -- do a reduction. |
1120 : `-----------------------------*/
1121 51382 : yyreduce:
1122 : /* yyn is the number of a rule to reduce with. */
1123 51382 : 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 51382 : yyval = yyvsp[1-yylen];
1134 :
1135 :
1136 : YY_REDUCE_PRINT (yyn);
1137 51382 : switch (yyn)
1138 : {
1139 280 : 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 280 : break;
1152 :
1153 280 : 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 280 : break;
1161 :
1162 296 : case 4: /* setup_list: setup_list setup */
1163 : #line 85 "specparse.y"
1164 : {
1165 : (yyval.ptr_list).elements = pg_realloc((yyvsp[-1].ptr_list).elements,
1166 : ((yyvsp[-1].ptr_list).nelements + 1) * sizeof(void *));
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 296 : break;
1172 :
1173 272 : case 5: /* opt_setup: %empty */
1174 : #line 94 "specparse.y"
1175 : { (yyval.str) = NULL; }
1176 : #line 1177 "specparse.c"
1177 272 : break;
1178 :
1179 422 : case 6: /* opt_setup: setup */
1180 : #line 95 "specparse.y"
1181 : { (yyval.str) = (yyvsp[0].str); }
1182 : #line 1183 "specparse.c"
1183 422 : break;
1184 :
1185 718 : case 7: /* setup: SETUP sqlblock */
1186 : #line 99 "specparse.y"
1187 : { (yyval.str) = (yyvsp[0].str); }
1188 : #line 1189 "specparse.c"
1189 718 : break;
1190 :
1191 670 : case 8: /* opt_teardown: %empty */
1192 : #line 103 "specparse.y"
1193 : { (yyval.str) = NULL; }
1194 : #line 1195 "specparse.c"
1195 670 : break;
1196 :
1197 304 : case 9: /* opt_teardown: TEARDOWN sqlblock */
1198 : #line 104 "specparse.y"
1199 : { (yyval.str) = (yyvsp[0].str); }
1200 : #line 1201 "specparse.c"
1201 304 : break;
1202 :
1203 414 : case 10: /* session_list: session_list session */
1204 : #line 109 "specparse.y"
1205 : {
1206 : (yyval.ptr_list).elements = pg_realloc((yyvsp[-1].ptr_list).elements,
1207 : ((yyvsp[-1].ptr_list).nelements + 1) * sizeof(void *));
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 414 : break;
1213 :
1214 280 : case 11: /* session_list: session */
1215 : #line 116 "specparse.y"
1216 : {
1217 : (yyval.ptr_list).nelements = 1;
1218 : (yyval.ptr_list).elements = pg_malloc(sizeof(void *));
1219 : (yyval.ptr_list).elements[0] = (yyvsp[0].session);
1220 : }
1221 : #line 1222 "specparse.c"
1222 280 : break;
1223 :
1224 694 : case 12: /* session: SESSION identifier opt_setup step_list opt_teardown */
1225 : #line 125 "specparse.y"
1226 : {
1227 : (yyval.session) = pg_malloc(sizeof(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 694 : break;
1236 :
1237 2148 : case 13: /* step_list: step_list step */
1238 : #line 137 "specparse.y"
1239 : {
1240 : (yyval.ptr_list).elements = pg_realloc((yyvsp[-1].ptr_list).elements,
1241 : ((yyvsp[-1].ptr_list).nelements + 1) * sizeof(void *));
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 2148 : break;
1247 :
1248 694 : case 14: /* step_list: step */
1249 : #line 144 "specparse.y"
1250 : {
1251 : (yyval.ptr_list).nelements = 1;
1252 : (yyval.ptr_list).elements = pg_malloc(sizeof(void *));
1253 : (yyval.ptr_list).elements[0] = (yyvsp[0].step);
1254 : }
1255 : #line 1256 "specparse.c"
1256 694 : break;
1257 :
1258 2842 : case 15: /* step: STEP identifier sqlblock */
1259 : #line 154 "specparse.y"
1260 : {
1261 : (yyval.step) = pg_malloc(sizeof(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 2842 : break;
1269 :
1270 252 : 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 252 : break;
1277 :
1278 28 : 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 28 : break;
1286 :
1287 2152 : case 18: /* permutation_list: permutation_list permutation */
1288 : #line 177 "specparse.y"
1289 : {
1290 : (yyval.ptr_list).elements = pg_realloc((yyvsp[-1].ptr_list).elements,
1291 : ((yyvsp[-1].ptr_list).nelements + 1) * sizeof(void *));
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 2152 : break;
1297 :
1298 252 : case 19: /* permutation_list: permutation */
1299 : #line 184 "specparse.y"
1300 : {
1301 : (yyval.ptr_list).nelements = 1;
1302 : (yyval.ptr_list).elements = pg_malloc(sizeof(void *));
1303 : (yyval.ptr_list).elements[0] = (yyvsp[0].permutation);
1304 : }
1305 : #line 1306 "specparse.c"
1306 252 : break;
1307 :
1308 2404 : case 20: /* permutation: PERMUTATION permutation_step_list */
1309 : #line 194 "specparse.y"
1310 : {
1311 : (yyval.permutation) = pg_malloc(sizeof(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 2404 : break;
1317 :
1318 15440 : case 21: /* permutation_step_list: permutation_step_list permutation_step */
1319 : #line 203 "specparse.y"
1320 : {
1321 : (yyval.ptr_list).elements = pg_realloc((yyvsp[-1].ptr_list).elements,
1322 : ((yyvsp[-1].ptr_list).nelements + 1) * sizeof(void *));
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 15440 : break;
1328 :
1329 2404 : 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(sizeof(void *));
1334 : (yyval.ptr_list).elements[0] = (yyvsp[0].permutationstep);
1335 : }
1336 : #line 1337 "specparse.c"
1337 2404 : break;
1338 :
1339 17698 : case 23: /* permutation_step: identifier */
1340 : #line 219 "specparse.y"
1341 : {
1342 : (yyval.permutationstep) = pg_malloc(sizeof(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 17698 : break;
1350 :
1351 146 : case 24: /* permutation_step: identifier '(' blocker_list ')' */
1352 : #line 227 "specparse.y"
1353 : {
1354 : (yyval.permutationstep) = pg_malloc(sizeof(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 146 : break;
1362 :
1363 0 : case 25: /* blocker_list: blocker_list ',' blocker */
1364 : #line 238 "specparse.y"
1365 : {
1366 : (yyval.ptr_list).elements = pg_realloc((yyvsp[-2].ptr_list).elements,
1367 : ((yyvsp[-2].ptr_list).nelements + 1) * sizeof(void *));
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 146 : case 26: /* blocker_list: blocker */
1375 : #line 245 "specparse.y"
1376 : {
1377 : (yyval.ptr_list).nelements = 1;
1378 : (yyval.ptr_list).elements = pg_malloc(sizeof(void *));
1379 : (yyval.ptr_list).elements[0] = (yyvsp[0].blocker);
1380 : }
1381 : #line 1382 "specparse.c"
1382 146 : break;
1383 :
1384 120 : case 27: /* blocker: identifier */
1385 : #line 254 "specparse.y"
1386 : {
1387 : (yyval.blocker) = pg_malloc(sizeof(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 120 : break;
1396 :
1397 2 : case 28: /* blocker: identifier NOTICES INTEGER */
1398 : #line 263 "specparse.y"
1399 : {
1400 : (yyval.blocker) = pg_malloc(sizeof(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 2 : break;
1409 :
1410 24 : case 29: /* blocker: '*' */
1411 : #line 272 "specparse.y"
1412 : {
1413 : (yyval.blocker) = pg_malloc(sizeof(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 24 : 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 51382 : YYPOPSTACK (yylen);
1442 51382 : yylen = 0;
1443 :
1444 51382 : *++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 51382 : const int yylhs = yyr1[yyn] - YYNTOKENS;
1451 51382 : const int yyi = yypgoto[yylhs] + *yyssp;
1452 46454 : yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1453 21270 : ? yytable[yyi]
1454 97836 : : yydefgoto[yylhs]);
1455 : }
1456 :
1457 51382 : 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 280 : yyacceptlab:
1566 280 : yyresult = 0;
1567 280 : 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 280 : yyreturnlab:
1591 280 : 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 280 : YYPOPSTACK (yylen);
1602 : YY_STACK_PRINT (yyss, yyssp);
1603 840 : while (yyssp != yyss)
1604 : {
1605 560 : yydestruct ("Cleanup: popping",
1606 560 : YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
1607 560 : YYPOPSTACK (1);
1608 : }
1609 : #ifndef yyoverflow
1610 280 : if (yyss != yyssa)
1611 0 : YYSTACK_FREE (yyss);
1612 : #endif
1613 :
1614 280 : return yyresult;
1615 : }
1616 :
1617 : #line 282 "specparse.y"
1618 :
|
