Line data Source code
1 : /* A Bison parser, made by GNU Bison 3.7.5. */
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 <http://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 30705
50 :
51 : /* Bison version string. */
52 : #define YYBISON_VERSION "3.7.5"
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 replication_yyparse
69 : #define yylex replication_yylex
70 : #define yyerror replication_yyerror
71 : #define yydebug replication_yydebug
72 : #define yynerrs replication_yynerrs
73 : #define yylval replication_yylval
74 : #define yychar replication_yychar
75 :
76 : /* First part of user prologue. */
77 : #line 1 "repl_gram.y"
78 :
79 : /*-------------------------------------------------------------------------
80 : *
81 : * repl_gram.y - Parser for the replication commands
82 : *
83 : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
84 : * Portions Copyright (c) 1994, Regents of the University of California
85 : *
86 : *
87 : * IDENTIFICATION
88 : * src/backend/replication/repl_gram.y
89 : *
90 : *-------------------------------------------------------------------------
91 : */
92 :
93 : #include "postgres.h"
94 :
95 : #include "access/xlogdefs.h"
96 : #include "nodes/makefuncs.h"
97 : #include "nodes/parsenodes.h"
98 : #include "nodes/replnodes.h"
99 : #include "replication/walsender.h"
100 : #include "replication/walsender_private.h"
101 :
102 : #include "repl_gram.h"
103 :
104 : /* silence -Wmissing-variable-declarations */
105 : extern int replication_yychar;
106 : extern int replication_yynerrs;
107 :
108 :
109 : /* Result of the parsing is returned here */
110 : Node *replication_parse_result;
111 :
112 :
113 : /*
114 : * Bison doesn't allocate anything that needs to live across parser calls,
115 : * so we can easily have it use palloc instead of malloc. This prevents
116 : * memory leaks if we error out during parsing.
117 : */
118 : #define YYMALLOC palloc
119 : #define YYFREE pfree
120 :
121 :
122 : #line 123 "repl_gram.c"
123 :
124 : # ifndef YY_CAST
125 : # ifdef __cplusplus
126 : # define YY_CAST(Type, Val) static_cast<Type> (Val)
127 : # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
128 : # else
129 : # define YY_CAST(Type, Val) ((Type) (Val))
130 : # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
131 : # endif
132 : # endif
133 : # ifndef YY_NULLPTR
134 : # if defined __cplusplus
135 : # if 201103L <= __cplusplus
136 : # define YY_NULLPTR nullptr
137 : # else
138 : # define YY_NULLPTR 0
139 : # endif
140 : # else
141 : # define YY_NULLPTR ((void*)0)
142 : # endif
143 : # endif
144 :
145 : #include "repl_gram.h"
146 : /* Symbol kind. */
147 : enum yysymbol_kind_t
148 : {
149 : YYSYMBOL_YYEMPTY = -2,
150 : YYSYMBOL_YYEOF = 0, /* "end of file" */
151 : YYSYMBOL_YYerror = 1, /* error */
152 : YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
153 : YYSYMBOL_SCONST = 3, /* SCONST */
154 : YYSYMBOL_IDENT = 4, /* IDENT */
155 : YYSYMBOL_UCONST = 5, /* UCONST */
156 : YYSYMBOL_RECPTR = 6, /* RECPTR */
157 : YYSYMBOL_K_BASE_BACKUP = 7, /* K_BASE_BACKUP */
158 : YYSYMBOL_K_IDENTIFY_SYSTEM = 8, /* K_IDENTIFY_SYSTEM */
159 : YYSYMBOL_K_READ_REPLICATION_SLOT = 9, /* K_READ_REPLICATION_SLOT */
160 : YYSYMBOL_K_SHOW = 10, /* K_SHOW */
161 : YYSYMBOL_K_START_REPLICATION = 11, /* K_START_REPLICATION */
162 : YYSYMBOL_K_CREATE_REPLICATION_SLOT = 12, /* K_CREATE_REPLICATION_SLOT */
163 : YYSYMBOL_K_DROP_REPLICATION_SLOT = 13, /* K_DROP_REPLICATION_SLOT */
164 : YYSYMBOL_K_ALTER_REPLICATION_SLOT = 14, /* K_ALTER_REPLICATION_SLOT */
165 : YYSYMBOL_K_TIMELINE_HISTORY = 15, /* K_TIMELINE_HISTORY */
166 : YYSYMBOL_K_WAIT = 16, /* K_WAIT */
167 : YYSYMBOL_K_TIMELINE = 17, /* K_TIMELINE */
168 : YYSYMBOL_K_PHYSICAL = 18, /* K_PHYSICAL */
169 : YYSYMBOL_K_LOGICAL = 19, /* K_LOGICAL */
170 : YYSYMBOL_K_SLOT = 20, /* K_SLOT */
171 : YYSYMBOL_K_RESERVE_WAL = 21, /* K_RESERVE_WAL */
172 : YYSYMBOL_K_TEMPORARY = 22, /* K_TEMPORARY */
173 : YYSYMBOL_K_TWO_PHASE = 23, /* K_TWO_PHASE */
174 : YYSYMBOL_K_EXPORT_SNAPSHOT = 24, /* K_EXPORT_SNAPSHOT */
175 : YYSYMBOL_K_NOEXPORT_SNAPSHOT = 25, /* K_NOEXPORT_SNAPSHOT */
176 : YYSYMBOL_K_USE_SNAPSHOT = 26, /* K_USE_SNAPSHOT */
177 : YYSYMBOL_K_UPLOAD_MANIFEST = 27, /* K_UPLOAD_MANIFEST */
178 : YYSYMBOL_28_ = 28, /* ';' */
179 : YYSYMBOL_29_ = 29, /* '.' */
180 : YYSYMBOL_30_ = 30, /* '(' */
181 : YYSYMBOL_31_ = 31, /* ')' */
182 : YYSYMBOL_32_ = 32, /* ',' */
183 : YYSYMBOL_YYACCEPT = 33, /* $accept */
184 : YYSYMBOL_firstcmd = 34, /* firstcmd */
185 : YYSYMBOL_opt_semicolon = 35, /* opt_semicolon */
186 : YYSYMBOL_command = 36, /* command */
187 : YYSYMBOL_identify_system = 37, /* identify_system */
188 : YYSYMBOL_read_replication_slot = 38, /* read_replication_slot */
189 : YYSYMBOL_show = 39, /* show */
190 : YYSYMBOL_var_name = 40, /* var_name */
191 : YYSYMBOL_base_backup = 41, /* base_backup */
192 : YYSYMBOL_create_replication_slot = 42, /* create_replication_slot */
193 : YYSYMBOL_create_slot_options = 43, /* create_slot_options */
194 : YYSYMBOL_create_slot_legacy_opt_list = 44, /* create_slot_legacy_opt_list */
195 : YYSYMBOL_create_slot_legacy_opt = 45, /* create_slot_legacy_opt */
196 : YYSYMBOL_drop_replication_slot = 46, /* drop_replication_slot */
197 : YYSYMBOL_alter_replication_slot = 47, /* alter_replication_slot */
198 : YYSYMBOL_start_replication = 48, /* start_replication */
199 : YYSYMBOL_start_logical_replication = 49, /* start_logical_replication */
200 : YYSYMBOL_timeline_history = 50, /* timeline_history */
201 : YYSYMBOL_upload_manifest = 51, /* upload_manifest */
202 : YYSYMBOL_opt_physical = 52, /* opt_physical */
203 : YYSYMBOL_opt_temporary = 53, /* opt_temporary */
204 : YYSYMBOL_opt_slot = 54, /* opt_slot */
205 : YYSYMBOL_opt_timeline = 55, /* opt_timeline */
206 : YYSYMBOL_plugin_options = 56, /* plugin_options */
207 : YYSYMBOL_plugin_opt_list = 57, /* plugin_opt_list */
208 : YYSYMBOL_plugin_opt_elem = 58, /* plugin_opt_elem */
209 : YYSYMBOL_plugin_opt_arg = 59, /* plugin_opt_arg */
210 : YYSYMBOL_generic_option_list = 60, /* generic_option_list */
211 : YYSYMBOL_generic_option = 61, /* generic_option */
212 : YYSYMBOL_ident_or_keyword = 62 /* ident_or_keyword */
213 : };
214 : typedef enum yysymbol_kind_t yysymbol_kind_t;
215 :
216 :
217 :
218 :
219 : #ifdef short
220 : # undef short
221 : #endif
222 :
223 : /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
224 : <limits.h> and (if available) <stdint.h> are included
225 : so that the code can choose integer types of a good width. */
226 :
227 : #ifndef __PTRDIFF_MAX__
228 : # include <limits.h> /* INFRINGES ON USER NAME SPACE */
229 : # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
230 : # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
231 : # define YY_STDINT_H
232 : # endif
233 : #endif
234 :
235 : /* Narrow types that promote to a signed type and that can represent a
236 : signed or unsigned integer of at least N bits. In tables they can
237 : save space and decrease cache pressure. Promoting to a signed type
238 : helps avoid bugs in integer arithmetic. */
239 :
240 : #ifdef __INT_LEAST8_MAX__
241 : typedef __INT_LEAST8_TYPE__ yytype_int8;
242 : #elif defined YY_STDINT_H
243 : typedef int_least8_t yytype_int8;
244 : #else
245 : typedef signed char yytype_int8;
246 : #endif
247 :
248 : #ifdef __INT_LEAST16_MAX__
249 : typedef __INT_LEAST16_TYPE__ yytype_int16;
250 : #elif defined YY_STDINT_H
251 : typedef int_least16_t yytype_int16;
252 : #else
253 : typedef short yytype_int16;
254 : #endif
255 :
256 : /* Work around bug in HP-UX 11.23, which defines these macros
257 : incorrectly for preprocessor constants. This workaround can likely
258 : be removed in 2023, as HPE has promised support for HP-UX 11.23
259 : (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
260 : <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
261 : #ifdef __hpux
262 : # undef UINT_LEAST8_MAX
263 : # undef UINT_LEAST16_MAX
264 : # define UINT_LEAST8_MAX 255
265 : # define UINT_LEAST16_MAX 65535
266 : #endif
267 :
268 : #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
269 : typedef __UINT_LEAST8_TYPE__ yytype_uint8;
270 : #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
271 : && UINT_LEAST8_MAX <= INT_MAX)
272 : typedef uint_least8_t yytype_uint8;
273 : #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
274 : typedef unsigned char yytype_uint8;
275 : #else
276 : typedef short yytype_uint8;
277 : #endif
278 :
279 : #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
280 : typedef __UINT_LEAST16_TYPE__ yytype_uint16;
281 : #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
282 : && UINT_LEAST16_MAX <= INT_MAX)
283 : typedef uint_least16_t yytype_uint16;
284 : #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
285 : typedef unsigned short yytype_uint16;
286 : #else
287 : typedef int yytype_uint16;
288 : #endif
289 :
290 : #ifndef YYPTRDIFF_T
291 : # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
292 : # define YYPTRDIFF_T __PTRDIFF_TYPE__
293 : # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
294 : # elif defined PTRDIFF_MAX
295 : # ifndef ptrdiff_t
296 : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
297 : # endif
298 : # define YYPTRDIFF_T ptrdiff_t
299 : # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
300 : # else
301 : # define YYPTRDIFF_T long
302 : # define YYPTRDIFF_MAXIMUM LONG_MAX
303 : # endif
304 : #endif
305 :
306 : #ifndef YYSIZE_T
307 : # ifdef __SIZE_TYPE__
308 : # define YYSIZE_T __SIZE_TYPE__
309 : # elif defined size_t
310 : # define YYSIZE_T size_t
311 : # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
312 : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
313 : # define YYSIZE_T size_t
314 : # else
315 : # define YYSIZE_T unsigned
316 : # endif
317 : #endif
318 :
319 : #define YYSIZE_MAXIMUM \
320 : YY_CAST (YYPTRDIFF_T, \
321 : (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
322 : ? YYPTRDIFF_MAXIMUM \
323 : : YY_CAST (YYSIZE_T, -1)))
324 :
325 : #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
326 :
327 :
328 : /* Stored state numbers (used for stacks). */
329 : typedef yytype_int8 yy_state_t;
330 :
331 : /* State numbers in computations. */
332 : typedef int yy_state_fast_t;
333 :
334 : #ifndef YY_
335 : # if defined YYENABLE_NLS && YYENABLE_NLS
336 : # if ENABLE_NLS
337 : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
338 : # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
339 : # endif
340 : # endif
341 : # ifndef YY_
342 : # define YY_(Msgid) Msgid
343 : # endif
344 : #endif
345 :
346 :
347 : #ifndef YY_ATTRIBUTE_PURE
348 : # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
349 : # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
350 : # else
351 : # define YY_ATTRIBUTE_PURE
352 : # endif
353 : #endif
354 :
355 : #ifndef YY_ATTRIBUTE_UNUSED
356 : # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
357 : # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
358 : # else
359 : # define YY_ATTRIBUTE_UNUSED
360 : # endif
361 : #endif
362 :
363 : /* Suppress unused-variable warnings by "using" E. */
364 : #if ! defined lint || defined __GNUC__
365 : # define YY_USE(E) ((void) (E))
366 : #else
367 : # define YY_USE(E) /* empty */
368 : #endif
369 :
370 : #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
371 : /* Suppress an incorrect diagnostic about yylval being uninitialized. */
372 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
373 : _Pragma ("GCC diagnostic push") \
374 : _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
375 : _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
376 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
377 : _Pragma ("GCC diagnostic pop")
378 : #else
379 : # define YY_INITIAL_VALUE(Value) Value
380 : #endif
381 : #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
382 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
383 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END
384 : #endif
385 : #ifndef YY_INITIAL_VALUE
386 : # define YY_INITIAL_VALUE(Value) /* Nothing. */
387 : #endif
388 :
389 : #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
390 : # define YY_IGNORE_USELESS_CAST_BEGIN \
391 : _Pragma ("GCC diagnostic push") \
392 : _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
393 : # define YY_IGNORE_USELESS_CAST_END \
394 : _Pragma ("GCC diagnostic pop")
395 : #endif
396 : #ifndef YY_IGNORE_USELESS_CAST_BEGIN
397 : # define YY_IGNORE_USELESS_CAST_BEGIN
398 : # define YY_IGNORE_USELESS_CAST_END
399 : #endif
400 :
401 :
402 : #define YY_ASSERT(E) ((void) (0 && (E)))
403 :
404 : #if !defined yyoverflow
405 :
406 : /* The parser invokes alloca or malloc; define the necessary symbols. */
407 :
408 : # ifdef YYSTACK_USE_ALLOCA
409 : # if YYSTACK_USE_ALLOCA
410 : # ifdef __GNUC__
411 : # define YYSTACK_ALLOC __builtin_alloca
412 : # elif defined __BUILTIN_VA_ARG_INCR
413 : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
414 : # elif defined _AIX
415 : # define YYSTACK_ALLOC __alloca
416 : # elif defined _MSC_VER
417 : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
418 : # define alloca _alloca
419 : # else
420 : # define YYSTACK_ALLOC alloca
421 : # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
422 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
423 : /* Use EXIT_SUCCESS as a witness for stdlib.h. */
424 : # ifndef EXIT_SUCCESS
425 : # define EXIT_SUCCESS 0
426 : # endif
427 : # endif
428 : # endif
429 : # endif
430 : # endif
431 :
432 : # ifdef YYSTACK_ALLOC
433 : /* Pacify GCC's 'empty if-body' warning. */
434 : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
435 : # ifndef YYSTACK_ALLOC_MAXIMUM
436 : /* The OS might guarantee only one guard page at the bottom of the stack,
437 : and a page size can be as small as 4096 bytes. So we cannot safely
438 : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
439 : to allow for a few compiler-allocated temporary stack slots. */
440 : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
441 : # endif
442 : # else
443 : # define YYSTACK_ALLOC YYMALLOC
444 : # define YYSTACK_FREE YYFREE
445 : # ifndef YYSTACK_ALLOC_MAXIMUM
446 : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
447 : # endif
448 : # if (defined __cplusplus && ! defined EXIT_SUCCESS \
449 : && ! ((defined YYMALLOC || defined malloc) \
450 : && (defined YYFREE || defined free)))
451 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
452 : # ifndef EXIT_SUCCESS
453 : # define EXIT_SUCCESS 0
454 : # endif
455 : # endif
456 : # ifndef YYMALLOC
457 : # define YYMALLOC malloc
458 : # if ! defined malloc && ! defined EXIT_SUCCESS
459 : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
460 : # endif
461 : # endif
462 : # ifndef YYFREE
463 : # define YYFREE free
464 : # if ! defined free && ! defined EXIT_SUCCESS
465 : void free (void *); /* INFRINGES ON USER NAME SPACE */
466 : # endif
467 : # endif
468 : # endif
469 : #endif /* !defined yyoverflow */
470 :
471 : #if (! defined yyoverflow \
472 : && (! defined __cplusplus \
473 : || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
474 :
475 : /* A type that is properly aligned for any stack member. */
476 : union yyalloc
477 : {
478 : yy_state_t yyss_alloc;
479 : YYSTYPE yyvs_alloc;
480 : };
481 :
482 : /* The size of the maximum gap between one aligned stack and the next. */
483 : # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
484 :
485 : /* The size of an array large to enough to hold all stacks, each with
486 : N elements. */
487 : # define YYSTACK_BYTES(N) \
488 : ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
489 : + YYSTACK_GAP_MAXIMUM)
490 :
491 : # define YYCOPY_NEEDED 1
492 :
493 : /* Relocate STACK from its old location to the new one. The
494 : local variables YYSIZE and YYSTACKSIZE give the old and new number of
495 : elements in the stack, and YYPTR gives the new location of the
496 : stack. Advance YYPTR to a properly aligned location for the next
497 : stack. */
498 : # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
499 : do \
500 : { \
501 : YYPTRDIFF_T yynewbytes; \
502 : YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
503 : Stack = &yyptr->Stack_alloc; \
504 : yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
505 : yyptr += yynewbytes / YYSIZEOF (*yyptr); \
506 : } \
507 : while (0)
508 :
509 : #endif
510 :
511 : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
512 : /* Copy COUNT objects from SRC to DST. The source and destination do
513 : not overlap. */
514 : # ifndef YYCOPY
515 : # if defined __GNUC__ && 1 < __GNUC__
516 : # define YYCOPY(Dst, Src, Count) \
517 : __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
518 : # else
519 : # define YYCOPY(Dst, Src, Count) \
520 : do \
521 : { \
522 : YYPTRDIFF_T yyi; \
523 : for (yyi = 0; yyi < (Count); yyi++) \
524 : (Dst)[yyi] = (Src)[yyi]; \
525 : } \
526 : while (0)
527 : # endif
528 : # endif
529 : #endif /* !YYCOPY_NEEDED */
530 :
531 : /* YYFINAL -- State number of the termination state. */
532 : #define YYFINAL 34
533 : /* YYLAST -- Last index in YYTABLE. */
534 : #define YYLAST 80
535 :
536 : /* YYNTOKENS -- Number of terminals. */
537 : #define YYNTOKENS 33
538 : /* YYNNTS -- Number of nonterminals. */
539 : #define YYNNTS 30
540 : /* YYNRULES -- Number of rules. */
541 : #define YYNRULES 82
542 : /* YYNSTATES -- Number of states. */
543 : #define YYNSTATES 109
544 :
545 : /* YYMAXUTOK -- Last valid token kind. */
546 : #define YYMAXUTOK 282
547 :
548 :
549 : /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
550 : as returned by yylex, with out-of-bounds checking. */
551 : #define YYTRANSLATE(YYX) \
552 : (0 <= (YYX) && (YYX) <= YYMAXUTOK \
553 : ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
554 : : YYSYMBOL_YYUNDEF)
555 :
556 : /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
557 : as returned by yylex. */
558 : static const yytype_int8 yytranslate[] =
559 : {
560 : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
561 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
562 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
563 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
564 : 30, 31, 2, 2, 32, 2, 29, 2, 2, 2,
565 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 28,
566 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
567 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
568 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
569 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
570 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
571 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
572 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
573 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
575 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
576 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585 : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
586 : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
587 : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
588 : 25, 26, 27
589 : };
590 :
591 : #if YYDEBUG
592 : /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
593 : static const yytype_int16 yyrline[] =
594 : {
595 : 0, 106, 106, 112, 113, 117, 118, 119, 120, 121,
596 : 122, 123, 124, 125, 126, 127, 134, 144, 156, 163,
597 : 164, 172, 178, 187, 198, 212, 213, 217, 220, 224,
598 : 229, 234, 239, 244, 253, 261, 273, 287, 302, 317,
599 : 335, 343, 344, 348, 349, 353, 356, 360, 368, 373,
600 : 374, 378, 382, 389, 396, 397, 401, 403, 408, 412,
601 : 416, 420, 427, 428, 429, 430, 431, 432, 433, 434,
602 : 435, 436, 437, 438, 439, 440, 441, 442, 443, 444,
603 : 445, 446, 447
604 : };
605 : #endif
606 :
607 : /** Accessing symbol of state STATE. */
608 : #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
609 :
610 : #if YYDEBUG || 0
611 : /* The user-facing name of the symbol whose (internal) number is
612 : YYSYMBOL. No bounds checking. */
613 : static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
614 :
615 : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
616 : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
617 : static const char *const yytname[] =
618 : {
619 : "\"end of file\"", "error", "\"invalid token\"", "SCONST", "IDENT",
620 : "UCONST", "RECPTR", "K_BASE_BACKUP", "K_IDENTIFY_SYSTEM",
621 : "K_READ_REPLICATION_SLOT", "K_SHOW", "K_START_REPLICATION",
622 : "K_CREATE_REPLICATION_SLOT", "K_DROP_REPLICATION_SLOT",
623 : "K_ALTER_REPLICATION_SLOT", "K_TIMELINE_HISTORY", "K_WAIT", "K_TIMELINE",
624 : "K_PHYSICAL", "K_LOGICAL", "K_SLOT", "K_RESERVE_WAL", "K_TEMPORARY",
625 : "K_TWO_PHASE", "K_EXPORT_SNAPSHOT", "K_NOEXPORT_SNAPSHOT",
626 : "K_USE_SNAPSHOT", "K_UPLOAD_MANIFEST", "';'", "'.'", "'('", "')'", "','",
627 : "$accept", "firstcmd", "opt_semicolon", "command", "identify_system",
628 : "read_replication_slot", "show", "var_name", "base_backup",
629 : "create_replication_slot", "create_slot_options",
630 : "create_slot_legacy_opt_list", "create_slot_legacy_opt",
631 : "drop_replication_slot", "alter_replication_slot", "start_replication",
632 : "start_logical_replication", "timeline_history", "upload_manifest",
633 : "opt_physical", "opt_temporary", "opt_slot", "opt_timeline",
634 : "plugin_options", "plugin_opt_list", "plugin_opt_elem", "plugin_opt_arg",
635 : "generic_option_list", "generic_option", "ident_or_keyword", YY_NULLPTR
636 : };
637 :
638 : static const char *
639 : yysymbol_name (yysymbol_kind_t yysymbol)
640 : {
641 : return yytname[yysymbol];
642 : }
643 : #endif
644 :
645 : #ifdef YYPRINT
646 : /* YYTOKNUM[NUM] -- (External) token number corresponding to the
647 : (internal) symbol number NUM (which must be that of a token). */
648 : static const yytype_int16 yytoknum[] =
649 : {
650 : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
651 : 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
652 : 275, 276, 277, 278, 279, 280, 281, 282, 59, 46,
653 : 40, 41, 44
654 : };
655 : #endif
656 :
657 : #define YYPACT_NINF (-36)
658 :
659 : #define yypact_value_is_default(Yyn) \
660 : ((Yyn) == YYPACT_NINF)
661 :
662 : #define YYTABLE_NINF (-1)
663 :
664 : #define yytable_value_is_error(Yyn) \
665 : 0
666 :
667 : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
668 : STATE-NUM. */
669 : static const yytype_int8 yypact[] =
670 : {
671 : 17, -25, -36, 31, 31, 23, 50, 51, 52, 53,
672 : -36, 57, 32, -36, -36, -36, -36, -36, -36, -36,
673 : -36, -36, -36, -36, -4, -36, 30, 30, 58, 43,
674 : 41, 48, 35, -36, -36, -36, -36, -36, -36, -36,
675 : -36, -36, -36, -36, -36, -36, -36, -36, -36, -36,
676 : -36, -36, -36, -36, -36, -36, -36, -36, -30, -36,
677 : 37, 62, 49, -36, 61, -36, 27, -36, -4, -36,
678 : -4, -36, -36, -36, -36, 63, 54, 40, 68, 16,
679 : -36, 44, 70, -36, -4, -36, 13, 40, -36, 69,
680 : -36, -36, 19, -36, -36, -36, -36, -36, -36, -36,
681 : 73, 21, -36, -36, -36, -36, -36, 69, -36
682 : };
683 :
684 : /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
685 : Performed when YYTABLE does not specify something else to do. Zero
686 : means the default is an error. */
687 : static const yytype_int8 yydefact[] =
688 : {
689 : 0, 22, 16, 0, 0, 46, 0, 0, 0, 0,
690 : 40, 0, 4, 5, 12, 14, 6, 9, 10, 11,
691 : 7, 8, 13, 15, 0, 19, 17, 18, 0, 42,
692 : 44, 34, 0, 39, 1, 3, 2, 62, 63, 64,
693 : 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
694 : 75, 76, 77, 78, 79, 80, 81, 82, 0, 57,
695 : 58, 0, 45, 41, 0, 43, 0, 35, 0, 21,
696 : 0, 60, 59, 61, 20, 0, 48, 28, 0, 0,
697 : 56, 50, 0, 37, 0, 23, 26, 28, 36, 0,
698 : 38, 47, 0, 32, 33, 29, 30, 31, 27, 24,
699 : 55, 0, 51, 25, 54, 53, 49, 0, 52
700 : };
701 :
702 : /* YYPGOTO[NTERM-NUM]. */
703 : static const yytype_int8 yypgoto[] =
704 : {
705 : -36, -36, -36, -36, -36, -36, -36, 74, -36, -36,
706 : -10, -36, -36, -36, -36, -36, -36, -36, -36, -36,
707 : -36, -36, -36, -36, -36, -28, -36, -35, 10, -36
708 : };
709 :
710 : /* YYDEFGOTO[NTERM-NUM]. */
711 : static const yytype_int8 yydefgoto[] =
712 : {
713 : 0, 11, 36, 12, 13, 14, 15, 26, 16, 17,
714 : 85, 86, 98, 18, 19, 20, 21, 22, 23, 64,
715 : 66, 29, 83, 90, 101, 102, 105, 58, 59, 60
716 : };
717 :
718 : /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
719 : positive, shift that token. If negative, reduce the rule whose
720 : number is the opposite. If YYTABLE_NINF, syntax error. */
721 : static const yytype_int8 yytable[] =
722 : {
723 : 37, 69, 70, 38, 39, 24, 40, 41, 42, 43,
724 : 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
725 : 54, 55, 56, 57, 1, 2, 3, 4, 5, 6,
726 : 7, 8, 9, 79, 93, 25, 94, 95, 96, 97,
727 : 71, 72, 73, 28, 10, 77, 78, 88, 70, 92,
728 : 103, 70, 106, 107, 30, 31, 32, 34, 33, 61,
729 : 35, 63, 62, 65, 67, 68, 74, 76, 75, 81,
730 : 84, 82, 87, 100, 89, 91, 104, 99, 27, 108,
731 : 80
732 : };
733 :
734 : static const yytype_int8 yycheck[] =
735 : {
736 : 4, 31, 32, 7, 8, 30, 10, 11, 12, 13,
737 : 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
738 : 24, 25, 26, 27, 7, 8, 9, 10, 11, 12,
739 : 13, 14, 15, 68, 21, 4, 23, 24, 25, 26,
740 : 3, 4, 5, 20, 27, 18, 19, 31, 32, 84,
741 : 31, 32, 31, 32, 4, 4, 4, 0, 5, 29,
742 : 28, 18, 4, 22, 16, 30, 4, 6, 19, 6,
743 : 30, 17, 4, 4, 30, 5, 3, 87, 4, 107,
744 : 70
745 : };
746 :
747 : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
748 : symbol of state STATE-NUM. */
749 : static const yytype_int8 yystos[] =
750 : {
751 : 0, 7, 8, 9, 10, 11, 12, 13, 14, 15,
752 : 27, 34, 36, 37, 38, 39, 41, 42, 46, 47,
753 : 48, 49, 50, 51, 30, 4, 40, 40, 20, 54,
754 : 4, 4, 4, 5, 0, 28, 35, 4, 7, 8,
755 : 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
756 : 20, 21, 22, 23, 24, 25, 26, 27, 60, 61,
757 : 62, 29, 4, 18, 52, 22, 53, 16, 30, 31,
758 : 32, 3, 4, 5, 4, 19, 6, 18, 19, 60,
759 : 61, 6, 17, 55, 30, 43, 44, 4, 31, 30,
760 : 56, 5, 60, 21, 23, 24, 25, 26, 45, 43,
761 : 4, 57, 58, 31, 3, 59, 31, 32, 58
762 : };
763 :
764 : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
765 : static const yytype_int8 yyr1[] =
766 : {
767 : 0, 33, 34, 35, 35, 36, 36, 36, 36, 36,
768 : 36, 36, 36, 36, 36, 36, 37, 38, 39, 40,
769 : 40, 41, 41, 42, 42, 43, 43, 44, 44, 45,
770 : 45, 45, 45, 45, 46, 46, 47, 48, 49, 50,
771 : 51, 52, 52, 53, 53, 54, 54, 55, 55, 56,
772 : 56, 57, 57, 58, 59, 59, 60, 60, 61, 61,
773 : 61, 61, 62, 62, 62, 62, 62, 62, 62, 62,
774 : 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
775 : 62, 62, 62
776 : };
777 :
778 : /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
779 : static const yytype_int8 yyr2[] =
780 : {
781 : 0, 2, 2, 1, 0, 1, 1, 1, 1, 1,
782 : 1, 1, 1, 1, 1, 1, 1, 2, 2, 1,
783 : 3, 4, 1, 5, 6, 3, 1, 2, 0, 1,
784 : 1, 1, 1, 1, 2, 3, 5, 5, 6, 2,
785 : 1, 1, 0, 1, 0, 2, 0, 2, 0, 3,
786 : 0, 1, 3, 2, 1, 0, 3, 1, 1, 2,
787 : 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
788 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
789 : 1, 1, 1
790 : };
791 :
792 :
793 : enum { YYENOMEM = -2 };
794 :
795 : #define yyerrok (yyerrstatus = 0)
796 : #define yyclearin (yychar = YYEMPTY)
797 :
798 : #define YYACCEPT goto yyacceptlab
799 : #define YYABORT goto yyabortlab
800 : #define YYERROR goto yyerrorlab
801 :
802 :
803 : #define YYRECOVERING() (!!yyerrstatus)
804 :
805 : #define YYBACKUP(Token, Value) \
806 : do \
807 : if (yychar == YYEMPTY) \
808 : { \
809 : yychar = (Token); \
810 : yylval = (Value); \
811 : YYPOPSTACK (yylen); \
812 : yystate = *yyssp; \
813 : goto yybackup; \
814 : } \
815 : else \
816 : { \
817 : yyerror (YY_("syntax error: cannot back up")); \
818 : YYERROR; \
819 : } \
820 : while (0)
821 :
822 : /* Backward compatibility with an undocumented macro.
823 : Use YYerror or YYUNDEF. */
824 : #define YYERRCODE YYUNDEF
825 :
826 :
827 : /* Enable debugging if requested. */
828 : #if YYDEBUG
829 :
830 : # ifndef YYFPRINTF
831 : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
832 : # define YYFPRINTF fprintf
833 : # endif
834 :
835 : # define YYDPRINTF(Args) \
836 : do { \
837 : if (yydebug) \
838 : YYFPRINTF Args; \
839 : } while (0)
840 :
841 : /* This macro is provided for backward compatibility. */
842 : # ifndef YY_LOCATION_PRINT
843 : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
844 : # endif
845 :
846 :
847 : # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
848 : do { \
849 : if (yydebug) \
850 : { \
851 : YYFPRINTF (stderr, "%s ", Title); \
852 : yy_symbol_print (stderr, \
853 : Kind, Value); \
854 : YYFPRINTF (stderr, "\n"); \
855 : } \
856 : } while (0)
857 :
858 :
859 : /*-----------------------------------.
860 : | Print this symbol's value on YYO. |
861 : `-----------------------------------*/
862 :
863 : static void
864 : yy_symbol_value_print (FILE *yyo,
865 : yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
866 : {
867 : FILE *yyoutput = yyo;
868 : YY_USE (yyoutput);
869 : if (!yyvaluep)
870 : return;
871 : # ifdef YYPRINT
872 : if (yykind < YYNTOKENS)
873 : YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
874 : # endif
875 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
876 : YY_USE (yykind);
877 : YY_IGNORE_MAYBE_UNINITIALIZED_END
878 : }
879 :
880 :
881 : /*---------------------------.
882 : | Print this symbol on YYO. |
883 : `---------------------------*/
884 :
885 : static void
886 : yy_symbol_print (FILE *yyo,
887 : yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
888 : {
889 : YYFPRINTF (yyo, "%s %s (",
890 : yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
891 :
892 : yy_symbol_value_print (yyo, yykind, yyvaluep);
893 : YYFPRINTF (yyo, ")");
894 : }
895 :
896 : /*------------------------------------------------------------------.
897 : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
898 : | TOP (included). |
899 : `------------------------------------------------------------------*/
900 :
901 : static void
902 : yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
903 : {
904 : YYFPRINTF (stderr, "Stack now");
905 : for (; yybottom <= yytop; yybottom++)
906 : {
907 : int yybot = *yybottom;
908 : YYFPRINTF (stderr, " %d", yybot);
909 : }
910 : YYFPRINTF (stderr, "\n");
911 : }
912 :
913 : # define YY_STACK_PRINT(Bottom, Top) \
914 : do { \
915 : if (yydebug) \
916 : yy_stack_print ((Bottom), (Top)); \
917 : } while (0)
918 :
919 :
920 : /*------------------------------------------------.
921 : | Report that the YYRULE is going to be reduced. |
922 : `------------------------------------------------*/
923 :
924 : static void
925 : yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
926 : int yyrule)
927 : {
928 : int yylno = yyrline[yyrule];
929 : int yynrhs = yyr2[yyrule];
930 : int yyi;
931 : YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
932 : yyrule - 1, yylno);
933 : /* The symbols being reduced. */
934 : for (yyi = 0; yyi < yynrhs; yyi++)
935 : {
936 : YYFPRINTF (stderr, " $%d = ", yyi + 1);
937 : yy_symbol_print (stderr,
938 : YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
939 : &yyvsp[(yyi + 1) - (yynrhs)]);
940 : YYFPRINTF (stderr, "\n");
941 : }
942 : }
943 :
944 : # define YY_REDUCE_PRINT(Rule) \
945 : do { \
946 : if (yydebug) \
947 : yy_reduce_print (yyssp, yyvsp, Rule); \
948 : } while (0)
949 :
950 : /* Nonzero means print parse trace. It is left uninitialized so that
951 : multiple parsers can coexist. */
952 : int yydebug;
953 : #else /* !YYDEBUG */
954 : # define YYDPRINTF(Args) ((void) 0)
955 : # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
956 : # define YY_STACK_PRINT(Bottom, Top)
957 : # define YY_REDUCE_PRINT(Rule)
958 : #endif /* !YYDEBUG */
959 :
960 :
961 : /* YYINITDEPTH -- initial size of the parser's stacks. */
962 : #ifndef YYINITDEPTH
963 : # define YYINITDEPTH 200
964 : #endif
965 :
966 : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
967 : if the built-in stack extension method is used).
968 :
969 : Do not make this value too large; the results are undefined if
970 : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
971 : evaluated with infinite-precision integer arithmetic. */
972 :
973 : #ifndef YYMAXDEPTH
974 : # define YYMAXDEPTH 10000
975 : #endif
976 :
977 :
978 :
979 :
980 :
981 :
982 : /*-----------------------------------------------.
983 : | Release the memory associated to this symbol. |
984 : `-----------------------------------------------*/
985 :
986 : static void
987 10648 : yydestruct (const char *yymsg,
988 : yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
989 : {
990 : YY_USE (yyvaluep);
991 10648 : if (!yymsg)
992 0 : yymsg = "Deleting";
993 : YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
994 :
995 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
996 : YY_USE (yykind);
997 : YY_IGNORE_MAYBE_UNINITIALIZED_END
998 10648 : }
999 :
1000 :
1001 : /* Lookahead token kind. */
1002 : int yychar;
1003 :
1004 : /* The semantic value of the lookahead symbol. */
1005 : YYSTYPE yylval;
1006 : /* Number of syntax errors so far. */
1007 : int yynerrs;
1008 :
1009 :
1010 :
1011 :
1012 : /*----------.
1013 : | yyparse. |
1014 : `----------*/
1015 :
1016 : int
1017 5324 : yyparse (void)
1018 : {
1019 5324 : yy_state_fast_t yystate = 0;
1020 : /* Number of tokens to shift before error messages enabled. */
1021 5324 : int yyerrstatus = 0;
1022 :
1023 : /* Refer to the stacks through separate pointers, to allow yyoverflow
1024 : to reallocate them elsewhere. */
1025 :
1026 : /* Their size. */
1027 5324 : YYPTRDIFF_T yystacksize = YYINITDEPTH;
1028 :
1029 : /* The state stack: array, bottom, top. */
1030 : yy_state_t yyssa[YYINITDEPTH];
1031 5324 : yy_state_t *yyss = yyssa;
1032 5324 : yy_state_t *yyssp = yyss;
1033 :
1034 : /* The semantic value stack: array, bottom, top. */
1035 : YYSTYPE yyvsa[YYINITDEPTH];
1036 5324 : YYSTYPE *yyvs = yyvsa;
1037 5324 : YYSTYPE *yyvsp = yyvs;
1038 :
1039 : int yyn;
1040 : /* The return value of yyparse. */
1041 : int yyresult;
1042 : /* Lookahead symbol kind. */
1043 5324 : yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1044 : /* The variables used to return semantic value and location from the
1045 : action routines. */
1046 : YYSTYPE yyval;
1047 :
1048 :
1049 :
1050 : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1051 :
1052 : /* The number of symbols on the RHS of the reduced rule.
1053 : Keep to zero when no symbol should be popped. */
1054 5324 : int yylen = 0;
1055 :
1056 : YYDPRINTF ((stderr, "Starting parse\n"));
1057 :
1058 5324 : yychar = YYEMPTY; /* Cause a token to be read. */
1059 5324 : goto yysetstate;
1060 :
1061 :
1062 : /*------------------------------------------------------------.
1063 : | yynewstate -- push a new state, which is found in yystate. |
1064 : `------------------------------------------------------------*/
1065 82748 : yynewstate:
1066 : /* In all cases, when you get here, the value and location stacks
1067 : have just been pushed. So pushing a state here evens the stacks. */
1068 82748 : yyssp++;
1069 :
1070 :
1071 : /*--------------------------------------------------------------------.
1072 : | yysetstate -- set current state (the top of the stack) to yystate. |
1073 : `--------------------------------------------------------------------*/
1074 88072 : yysetstate:
1075 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1076 : YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1077 : YY_IGNORE_USELESS_CAST_BEGIN
1078 88072 : *yyssp = YY_CAST (yy_state_t, yystate);
1079 : YY_IGNORE_USELESS_CAST_END
1080 : YY_STACK_PRINT (yyss, yyssp);
1081 :
1082 88072 : if (yyss + yystacksize - 1 <= yyssp)
1083 : #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1084 : goto yyexhaustedlab;
1085 : #else
1086 : {
1087 : /* Get the current used size of the three stacks, in elements. */
1088 0 : YYPTRDIFF_T yysize = yyssp - yyss + 1;
1089 :
1090 : # if defined yyoverflow
1091 : {
1092 : /* Give user a chance to reallocate the stack. Use copies of
1093 : these so that the &'s don't force the real ones into
1094 : memory. */
1095 : yy_state_t *yyss1 = yyss;
1096 : YYSTYPE *yyvs1 = yyvs;
1097 :
1098 : /* Each stack pointer address is followed by the size of the
1099 : data in use in that stack, in bytes. This used to be a
1100 : conditional around just the two extra args, but that might
1101 : be undefined if yyoverflow is a macro. */
1102 : yyoverflow (YY_("memory exhausted"),
1103 : &yyss1, yysize * YYSIZEOF (*yyssp),
1104 : &yyvs1, yysize * YYSIZEOF (*yyvsp),
1105 : &yystacksize);
1106 : yyss = yyss1;
1107 : yyvs = yyvs1;
1108 : }
1109 : # else /* defined YYSTACK_RELOCATE */
1110 : /* Extend the stack our own way. */
1111 0 : if (YYMAXDEPTH <= yystacksize)
1112 0 : goto yyexhaustedlab;
1113 0 : yystacksize *= 2;
1114 0 : if (YYMAXDEPTH < yystacksize)
1115 0 : yystacksize = YYMAXDEPTH;
1116 :
1117 : {
1118 0 : yy_state_t *yyss1 = yyss;
1119 : union yyalloc *yyptr =
1120 0 : YY_CAST (union yyalloc *,
1121 : YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1122 0 : if (! yyptr)
1123 0 : goto yyexhaustedlab;
1124 0 : YYSTACK_RELOCATE (yyss_alloc, yyss);
1125 0 : YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1126 : # undef YYSTACK_RELOCATE
1127 0 : if (yyss1 != yyssa)
1128 0 : YYSTACK_FREE (yyss1);
1129 : }
1130 : # endif
1131 :
1132 0 : yyssp = yyss + yysize - 1;
1133 0 : yyvsp = yyvs + yysize - 1;
1134 :
1135 : YY_IGNORE_USELESS_CAST_BEGIN
1136 : YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1137 : YY_CAST (long, yystacksize)));
1138 : YY_IGNORE_USELESS_CAST_END
1139 :
1140 0 : if (yyss + yystacksize - 1 <= yyssp)
1141 0 : YYABORT;
1142 : }
1143 : #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1144 :
1145 88072 : if (yystate == YYFINAL)
1146 5324 : YYACCEPT;
1147 :
1148 82748 : goto yybackup;
1149 :
1150 :
1151 : /*-----------.
1152 : | yybackup. |
1153 : `-----------*/
1154 82748 : yybackup:
1155 : /* Do appropriate processing given the current state. Read a
1156 : lookahead token if we need one and don't already have one. */
1157 :
1158 : /* First try to decide what to do without reference to lookahead token. */
1159 82748 : yyn = yypact[yystate];
1160 82748 : if (yypact_value_is_default (yyn))
1161 35040 : goto yydefault;
1162 :
1163 : /* Not known => get a lookahead token if don't already have one. */
1164 :
1165 : /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1166 47708 : if (yychar == YYEMPTY)
1167 : {
1168 : YYDPRINTF ((stderr, "Reading a token\n"));
1169 38930 : yychar = yylex ();
1170 : }
1171 :
1172 47708 : if (yychar <= YYEOF)
1173 : {
1174 11718 : yychar = YYEOF;
1175 11718 : yytoken = YYSYMBOL_YYEOF;
1176 : YYDPRINTF ((stderr, "Now at end of input.\n"));
1177 : }
1178 35990 : else if (yychar == YYerror)
1179 : {
1180 : /* The scanner already issued an error message, process directly
1181 : to error recovery. But do not keep the error token as
1182 : lookahead, it is too special and may lead us to an endless
1183 : loop in error recovery. */
1184 0 : yychar = YYUNDEF;
1185 0 : yytoken = YYSYMBOL_YYerror;
1186 0 : goto yyerrlab1;
1187 : }
1188 : else
1189 : {
1190 35990 : yytoken = YYTRANSLATE (yychar);
1191 : YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1192 : }
1193 :
1194 : /* If the proper action on seeing token YYTOKEN is to reduce or to
1195 : detect an error, take that action. */
1196 47708 : yyn += yytoken;
1197 47708 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1198 8778 : goto yydefault;
1199 38930 : yyn = yytable[yyn];
1200 38930 : if (yyn <= 0)
1201 : {
1202 : if (yytable_value_is_error (yyn))
1203 : goto yyerrlab;
1204 0 : yyn = -yyn;
1205 0 : goto yyreduce;
1206 : }
1207 :
1208 : /* Count tokens shifted since error; after three, turn off error
1209 : status. */
1210 38930 : if (yyerrstatus)
1211 0 : yyerrstatus--;
1212 :
1213 : /* Shift the lookahead token. */
1214 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1215 38930 : yystate = yyn;
1216 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1217 38930 : *++yyvsp = yylval;
1218 : YY_IGNORE_MAYBE_UNINITIALIZED_END
1219 :
1220 : /* Discard the shifted token. */
1221 38930 : yychar = YYEMPTY;
1222 38930 : goto yynewstate;
1223 :
1224 :
1225 : /*-----------------------------------------------------------.
1226 : | yydefault -- do the default action for the current state. |
1227 : `-----------------------------------------------------------*/
1228 43818 : yydefault:
1229 43818 : yyn = yydefact[yystate];
1230 43818 : if (yyn == 0)
1231 0 : goto yyerrlab;
1232 43818 : goto yyreduce;
1233 :
1234 :
1235 : /*-----------------------------.
1236 : | yyreduce -- do a reduction. |
1237 : `-----------------------------*/
1238 43818 : yyreduce:
1239 : /* yyn is the number of a rule to reduce with. */
1240 43818 : yylen = yyr2[yyn];
1241 :
1242 : /* If YYLEN is nonzero, implement the default value of the action:
1243 : '$$ = $1'.
1244 :
1245 : Otherwise, the following line sets YYVAL to garbage.
1246 : This behavior is undocumented and Bison
1247 : users should not rely upon it. Assigning to YYVAL
1248 : unconditionally makes the parser a bit smaller, and it avoids a
1249 : GCC warning that YYVAL may be used uninitialized. */
1250 43818 : yyval = yyvsp[1-yylen];
1251 :
1252 :
1253 : YY_REDUCE_PRINT (yyn);
1254 43818 : switch (yyn)
1255 : {
1256 5324 : case 2: /* firstcmd: command opt_semicolon */
1257 : #line 107 "repl_gram.y"
1258 : {
1259 : replication_parse_result = (yyvsp[-1].node);
1260 : }
1261 : #line 1262 "repl_gram.c"
1262 5324 : break;
1263 :
1264 1294 : case 16: /* identify_system: K_IDENTIFY_SYSTEM */
1265 : #line 135 "repl_gram.y"
1266 : {
1267 : (yyval.node) = (Node *) makeNode(IdentifySystemCmd);
1268 : }
1269 : #line 1270 "repl_gram.c"
1270 1294 : break;
1271 :
1272 12 : case 17: /* read_replication_slot: K_READ_REPLICATION_SLOT var_name */
1273 : #line 145 "repl_gram.y"
1274 : {
1275 : ReadReplicationSlotCmd *n = makeNode(ReadReplicationSlotCmd);
1276 : n->slotname = (yyvsp[0].str);
1277 : (yyval.node) = (Node *) n;
1278 : }
1279 : #line 1280 "repl_gram.c"
1280 12 : break;
1281 :
1282 1092 : case 18: /* show: K_SHOW var_name */
1283 : #line 157 "repl_gram.y"
1284 : {
1285 : VariableShowStmt *n = makeNode(VariableShowStmt);
1286 : n->name = (yyvsp[0].str);
1287 : (yyval.node) = (Node *) n;
1288 : }
1289 : #line 1290 "repl_gram.c"
1290 1092 : break;
1291 :
1292 1104 : case 19: /* var_name: IDENT */
1293 : #line 163 "repl_gram.y"
1294 : { (yyval.str) = (yyvsp[0].str); }
1295 : #line 1296 "repl_gram.c"
1296 1104 : break;
1297 :
1298 0 : case 20: /* var_name: var_name '.' IDENT */
1299 : #line 165 "repl_gram.y"
1300 : { (yyval.str) = psprintf("%s.%s", (yyvsp[-2].str), (yyvsp[0].str)); }
1301 : #line 1302 "repl_gram.c"
1302 0 : break;
1303 :
1304 346 : case 21: /* base_backup: K_BASE_BACKUP '(' generic_option_list ')' */
1305 : #line 173 "repl_gram.y"
1306 : {
1307 : BaseBackupCmd *cmd = makeNode(BaseBackupCmd);
1308 : cmd->options = (yyvsp[-1].list);
1309 : (yyval.node) = (Node *) cmd;
1310 : }
1311 : #line 1312 "repl_gram.c"
1312 346 : break;
1313 :
1314 2 : case 22: /* base_backup: K_BASE_BACKUP */
1315 : #line 179 "repl_gram.y"
1316 : {
1317 : BaseBackupCmd *cmd = makeNode(BaseBackupCmd);
1318 : (yyval.node) = (Node *) cmd;
1319 : }
1320 : #line 1321 "repl_gram.c"
1321 2 : break;
1322 :
1323 266 : case 23: /* create_replication_slot: K_CREATE_REPLICATION_SLOT IDENT opt_temporary K_PHYSICAL create_slot_options */
1324 : #line 188 "repl_gram.y"
1325 : {
1326 : CreateReplicationSlotCmd *cmd;
1327 : cmd = makeNode(CreateReplicationSlotCmd);
1328 : cmd->kind = REPLICATION_KIND_PHYSICAL;
1329 : cmd->slotname = (yyvsp[-3].str);
1330 : cmd->temporary = (yyvsp[-2].boolval);
1331 : cmd->options = (yyvsp[0].list);
1332 : (yyval.node) = (Node *) cmd;
1333 : }
1334 : #line 1335 "repl_gram.c"
1335 266 : break;
1336 :
1337 586 : case 24: /* create_replication_slot: K_CREATE_REPLICATION_SLOT IDENT opt_temporary K_LOGICAL IDENT create_slot_options */
1338 : #line 199 "repl_gram.y"
1339 : {
1340 : CreateReplicationSlotCmd *cmd;
1341 : cmd = makeNode(CreateReplicationSlotCmd);
1342 : cmd->kind = REPLICATION_KIND_LOGICAL;
1343 : cmd->slotname = (yyvsp[-4].str);
1344 : cmd->temporary = (yyvsp[-3].boolval);
1345 : cmd->plugin = (yyvsp[-1].str);
1346 : cmd->options = (yyvsp[0].list);
1347 : (yyval.node) = (Node *) cmd;
1348 : }
1349 : #line 1350 "repl_gram.c"
1350 586 : break;
1351 :
1352 848 : case 25: /* create_slot_options: '(' generic_option_list ')' */
1353 : #line 212 "repl_gram.y"
1354 : { (yyval.list) = (yyvsp[-1].list); }
1355 : #line 1356 "repl_gram.c"
1356 848 : break;
1357 :
1358 4 : case 26: /* create_slot_options: create_slot_legacy_opt_list */
1359 : #line 213 "repl_gram.y"
1360 : { (yyval.list) = (yyvsp[0].list); }
1361 : #line 1362 "repl_gram.c"
1362 4 : break;
1363 :
1364 2 : case 27: /* create_slot_legacy_opt_list: create_slot_legacy_opt_list create_slot_legacy_opt */
1365 : #line 218 "repl_gram.y"
1366 : { (yyval.list) = lappend((yyvsp[-1].list), (yyvsp[0].defelt)); }
1367 : #line 1368 "repl_gram.c"
1368 2 : break;
1369 :
1370 4 : case 28: /* create_slot_legacy_opt_list: %empty */
1371 : #line 220 "repl_gram.y"
1372 : { (yyval.list) = NIL; }
1373 : #line 1374 "repl_gram.c"
1374 4 : break;
1375 :
1376 0 : case 29: /* create_slot_legacy_opt: K_EXPORT_SNAPSHOT */
1377 : #line 225 "repl_gram.y"
1378 : {
1379 : (yyval.defelt) = makeDefElem("snapshot",
1380 : (Node *) makeString("export"), -1);
1381 : }
1382 : #line 1383 "repl_gram.c"
1383 0 : break;
1384 :
1385 0 : case 30: /* create_slot_legacy_opt: K_NOEXPORT_SNAPSHOT */
1386 : #line 230 "repl_gram.y"
1387 : {
1388 : (yyval.defelt) = makeDefElem("snapshot",
1389 : (Node *) makeString("nothing"), -1);
1390 : }
1391 : #line 1392 "repl_gram.c"
1392 0 : break;
1393 :
1394 0 : case 31: /* create_slot_legacy_opt: K_USE_SNAPSHOT */
1395 : #line 235 "repl_gram.y"
1396 : {
1397 : (yyval.defelt) = makeDefElem("snapshot",
1398 : (Node *) makeString("use"), -1);
1399 : }
1400 : #line 1401 "repl_gram.c"
1401 0 : break;
1402 :
1403 2 : case 32: /* create_slot_legacy_opt: K_RESERVE_WAL */
1404 : #line 240 "repl_gram.y"
1405 : {
1406 : (yyval.defelt) = makeDefElem("reserve_wal",
1407 : (Node *) makeBoolean(true), -1);
1408 : }
1409 : #line 1410 "repl_gram.c"
1410 2 : break;
1411 :
1412 0 : case 33: /* create_slot_legacy_opt: K_TWO_PHASE */
1413 : #line 245 "repl_gram.y"
1414 : {
1415 : (yyval.defelt) = makeDefElem("two_phase",
1416 : (Node *) makeBoolean(true), -1);
1417 : }
1418 : #line 1419 "repl_gram.c"
1419 0 : break;
1420 :
1421 6 : case 34: /* drop_replication_slot: K_DROP_REPLICATION_SLOT IDENT */
1422 : #line 254 "repl_gram.y"
1423 : {
1424 : DropReplicationSlotCmd *cmd;
1425 : cmd = makeNode(DropReplicationSlotCmd);
1426 : cmd->slotname = (yyvsp[0].str);
1427 : cmd->wait = false;
1428 : (yyval.node) = (Node *) cmd;
1429 : }
1430 : #line 1431 "repl_gram.c"
1431 6 : break;
1432 :
1433 456 : case 35: /* drop_replication_slot: K_DROP_REPLICATION_SLOT IDENT K_WAIT */
1434 : #line 262 "repl_gram.y"
1435 : {
1436 : DropReplicationSlotCmd *cmd;
1437 : cmd = makeNode(DropReplicationSlotCmd);
1438 : cmd->slotname = (yyvsp[-1].str);
1439 : cmd->wait = true;
1440 : (yyval.node) = (Node *) cmd;
1441 : }
1442 : #line 1443 "repl_gram.c"
1443 456 : break;
1444 :
1445 12 : case 36: /* alter_replication_slot: K_ALTER_REPLICATION_SLOT IDENT '(' generic_option_list ')' */
1446 : #line 274 "repl_gram.y"
1447 : {
1448 : AlterReplicationSlotCmd *cmd;
1449 : cmd = makeNode(AlterReplicationSlotCmd);
1450 : cmd->slotname = (yyvsp[-3].str);
1451 : cmd->options = (yyvsp[-1].list);
1452 : (yyval.node) = (Node *) cmd;
1453 : }
1454 : #line 1455 "repl_gram.c"
1455 12 : break;
1456 :
1457 512 : case 37: /* start_replication: K_START_REPLICATION opt_slot opt_physical RECPTR opt_timeline */
1458 : #line 288 "repl_gram.y"
1459 : {
1460 : StartReplicationCmd *cmd;
1461 :
1462 : cmd = makeNode(StartReplicationCmd);
1463 : cmd->kind = REPLICATION_KIND_PHYSICAL;
1464 : cmd->slotname = (yyvsp[-3].str);
1465 : cmd->startpoint = (yyvsp[-1].recptr);
1466 : cmd->timeline = (yyvsp[0].uintval);
1467 : (yyval.node) = (Node *) cmd;
1468 : }
1469 : #line 1470 "repl_gram.c"
1470 512 : break;
1471 :
1472 692 : case 38: /* start_logical_replication: K_START_REPLICATION K_SLOT IDENT K_LOGICAL RECPTR plugin_options */
1473 : #line 303 "repl_gram.y"
1474 : {
1475 : StartReplicationCmd *cmd;
1476 : cmd = makeNode(StartReplicationCmd);
1477 : cmd->kind = REPLICATION_KIND_LOGICAL;
1478 : cmd->slotname = (yyvsp[-3].str);
1479 : cmd->startpoint = (yyvsp[-1].recptr);
1480 : cmd->options = (yyvsp[0].list);
1481 : (yyval.node) = (Node *) cmd;
1482 : }
1483 : #line 1484 "repl_gram.c"
1484 692 : break;
1485 :
1486 28 : case 39: /* timeline_history: K_TIMELINE_HISTORY UCONST */
1487 : #line 318 "repl_gram.y"
1488 : {
1489 : TimeLineHistoryCmd *cmd;
1490 :
1491 : if ((yyvsp[0].uintval) <= 0)
1492 : ereport(ERROR,
1493 : (errcode(ERRCODE_SYNTAX_ERROR),
1494 : errmsg("invalid timeline %u", (yyvsp[0].uintval))));
1495 :
1496 : cmd = makeNode(TimeLineHistoryCmd);
1497 : cmd->timeline = (yyvsp[0].uintval);
1498 :
1499 : (yyval.node) = (Node *) cmd;
1500 : }
1501 : #line 1502 "repl_gram.c"
1502 28 : break;
1503 :
1504 20 : case 40: /* upload_manifest: K_UPLOAD_MANIFEST */
1505 : #line 336 "repl_gram.y"
1506 : {
1507 : UploadManifestCmd *cmd = makeNode(UploadManifestCmd);
1508 :
1509 : (yyval.node) = (Node *) cmd;
1510 : }
1511 : #line 1512 "repl_gram.c"
1512 20 : break;
1513 :
1514 256 : case 43: /* opt_temporary: K_TEMPORARY */
1515 : #line 348 "repl_gram.y"
1516 : { (yyval.boolval) = true; }
1517 : #line 1518 "repl_gram.c"
1518 256 : break;
1519 :
1520 596 : case 44: /* opt_temporary: %empty */
1521 : #line 349 "repl_gram.y"
1522 : { (yyval.boolval) = false; }
1523 : #line 1524 "repl_gram.c"
1524 596 : break;
1525 :
1526 354 : case 45: /* opt_slot: K_SLOT IDENT */
1527 : #line 354 "repl_gram.y"
1528 : { (yyval.str) = (yyvsp[0].str); }
1529 : #line 1530 "repl_gram.c"
1530 354 : break;
1531 :
1532 158 : case 46: /* opt_slot: %empty */
1533 : #line 356 "repl_gram.y"
1534 : { (yyval.str) = NULL; }
1535 : #line 1536 "repl_gram.c"
1536 158 : break;
1537 :
1538 510 : case 47: /* opt_timeline: K_TIMELINE UCONST */
1539 : #line 361 "repl_gram.y"
1540 : {
1541 : if ((yyvsp[0].uintval) <= 0)
1542 : ereport(ERROR,
1543 : (errcode(ERRCODE_SYNTAX_ERROR),
1544 : errmsg("invalid timeline %u", (yyvsp[0].uintval))));
1545 : (yyval.uintval) = (yyvsp[0].uintval);
1546 : }
1547 : #line 1548 "repl_gram.c"
1548 510 : break;
1549 :
1550 2 : case 48: /* opt_timeline: %empty */
1551 : #line 368 "repl_gram.y"
1552 : { (yyval.uintval) = 0; }
1553 : #line 1554 "repl_gram.c"
1554 2 : break;
1555 :
1556 684 : case 49: /* plugin_options: '(' plugin_opt_list ')' */
1557 : #line 373 "repl_gram.y"
1558 : { (yyval.list) = (yyvsp[-1].list); }
1559 : #line 1560 "repl_gram.c"
1560 684 : break;
1561 :
1562 8 : case 50: /* plugin_options: %empty */
1563 : #line 374 "repl_gram.y"
1564 : { (yyval.list) = NIL; }
1565 : #line 1566 "repl_gram.c"
1566 8 : break;
1567 :
1568 684 : case 51: /* plugin_opt_list: plugin_opt_elem */
1569 : #line 379 "repl_gram.y"
1570 : {
1571 : (yyval.list) = list_make1((yyvsp[0].defelt));
1572 : }
1573 : #line 1574 "repl_gram.c"
1574 684 : break;
1575 :
1576 2002 : case 52: /* plugin_opt_list: plugin_opt_list ',' plugin_opt_elem */
1577 : #line 383 "repl_gram.y"
1578 : {
1579 : (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt));
1580 : }
1581 : #line 1582 "repl_gram.c"
1582 2002 : break;
1583 :
1584 2686 : case 53: /* plugin_opt_elem: IDENT plugin_opt_arg */
1585 : #line 390 "repl_gram.y"
1586 : {
1587 : (yyval.defelt) = makeDefElem((yyvsp[-1].str), (yyvsp[0].node), -1);
1588 : }
1589 : #line 1590 "repl_gram.c"
1590 2686 : break;
1591 :
1592 2686 : case 54: /* plugin_opt_arg: SCONST */
1593 : #line 396 "repl_gram.y"
1594 : { (yyval.node) = (Node *) makeString((yyvsp[0].str)); }
1595 : #line 1596 "repl_gram.c"
1596 2686 : break;
1597 :
1598 0 : case 55: /* plugin_opt_arg: %empty */
1599 : #line 397 "repl_gram.y"
1600 : { (yyval.node) = NULL; }
1601 : #line 1602 "repl_gram.c"
1602 0 : break;
1603 :
1604 1934 : case 56: /* generic_option_list: generic_option_list ',' generic_option */
1605 : #line 402 "repl_gram.y"
1606 : { (yyval.list) = lappend((yyvsp[-2].list), (yyvsp[0].defelt)); }
1607 : #line 1608 "repl_gram.c"
1608 1934 : break;
1609 :
1610 1206 : case 57: /* generic_option_list: generic_option */
1611 : #line 404 "repl_gram.y"
1612 : { (yyval.list) = list_make1((yyvsp[0].defelt)); }
1613 : #line 1614 "repl_gram.c"
1614 1206 : break;
1615 :
1616 740 : case 58: /* generic_option: ident_or_keyword */
1617 : #line 409 "repl_gram.y"
1618 : {
1619 : (yyval.defelt) = makeDefElem((yyvsp[0].str), NULL, -1);
1620 : }
1621 : #line 1622 "repl_gram.c"
1622 740 : break;
1623 :
1624 8 : case 59: /* generic_option: ident_or_keyword IDENT */
1625 : #line 413 "repl_gram.y"
1626 : {
1627 : (yyval.defelt) = makeDefElem((yyvsp[-1].str), (Node *) makeString((yyvsp[0].str)), -1);
1628 : }
1629 : #line 1630 "repl_gram.c"
1630 8 : break;
1631 :
1632 2056 : case 60: /* generic_option: ident_or_keyword SCONST */
1633 : #line 417 "repl_gram.y"
1634 : {
1635 : (yyval.defelt) = makeDefElem((yyvsp[-1].str), (Node *) makeString((yyvsp[0].str)), -1);
1636 : }
1637 : #line 1638 "repl_gram.c"
1638 2056 : break;
1639 :
1640 336 : case 61: /* generic_option: ident_or_keyword UCONST */
1641 : #line 421 "repl_gram.y"
1642 : {
1643 : (yyval.defelt) = makeDefElem((yyvsp[-1].str), (Node *) makeInteger((yyvsp[0].uintval)), -1);
1644 : }
1645 : #line 1646 "repl_gram.c"
1646 336 : break;
1647 :
1648 2542 : case 62: /* ident_or_keyword: IDENT */
1649 : #line 427 "repl_gram.y"
1650 : { (yyval.str) = (yyvsp[0].str); }
1651 : #line 1652 "repl_gram.c"
1652 2542 : break;
1653 :
1654 0 : case 63: /* ident_or_keyword: K_BASE_BACKUP */
1655 : #line 428 "repl_gram.y"
1656 : { (yyval.str) = "base_backup"; }
1657 : #line 1658 "repl_gram.c"
1658 0 : break;
1659 :
1660 0 : case 64: /* ident_or_keyword: K_IDENTIFY_SYSTEM */
1661 : #line 429 "repl_gram.y"
1662 : { (yyval.str) = "identify_system"; }
1663 : #line 1664 "repl_gram.c"
1664 0 : break;
1665 :
1666 0 : case 65: /* ident_or_keyword: K_SHOW */
1667 : #line 430 "repl_gram.y"
1668 : { (yyval.str) = "show"; }
1669 : #line 1670 "repl_gram.c"
1670 0 : break;
1671 :
1672 0 : case 66: /* ident_or_keyword: K_START_REPLICATION */
1673 : #line 431 "repl_gram.y"
1674 : { (yyval.str) = "start_replication"; }
1675 : #line 1676 "repl_gram.c"
1676 0 : break;
1677 :
1678 0 : case 67: /* ident_or_keyword: K_CREATE_REPLICATION_SLOT */
1679 : #line 432 "repl_gram.y"
1680 : { (yyval.str) = "create_replication_slot"; }
1681 : #line 1682 "repl_gram.c"
1682 0 : break;
1683 :
1684 0 : case 68: /* ident_or_keyword: K_DROP_REPLICATION_SLOT */
1685 : #line 433 "repl_gram.y"
1686 : { (yyval.str) = "drop_replication_slot"; }
1687 : #line 1688 "repl_gram.c"
1688 0 : break;
1689 :
1690 0 : case 69: /* ident_or_keyword: K_ALTER_REPLICATION_SLOT */
1691 : #line 434 "repl_gram.y"
1692 : { (yyval.str) = "alter_replication_slot"; }
1693 : #line 1694 "repl_gram.c"
1694 0 : break;
1695 :
1696 0 : case 70: /* ident_or_keyword: K_TIMELINE_HISTORY */
1697 : #line 435 "repl_gram.y"
1698 : { (yyval.str) = "timeline_history"; }
1699 : #line 1700 "repl_gram.c"
1700 0 : break;
1701 :
1702 330 : case 71: /* ident_or_keyword: K_WAIT */
1703 : #line 436 "repl_gram.y"
1704 : { (yyval.str) = "wait"; }
1705 : #line 1706 "repl_gram.c"
1706 330 : break;
1707 :
1708 0 : case 72: /* ident_or_keyword: K_TIMELINE */
1709 : #line 437 "repl_gram.y"
1710 : { (yyval.str) = "timeline"; }
1711 : #line 1712 "repl_gram.c"
1712 0 : break;
1713 :
1714 0 : case 73: /* ident_or_keyword: K_PHYSICAL */
1715 : #line 438 "repl_gram.y"
1716 : { (yyval.str) = "physical"; }
1717 : #line 1718 "repl_gram.c"
1718 0 : break;
1719 :
1720 0 : case 74: /* ident_or_keyword: K_LOGICAL */
1721 : #line 439 "repl_gram.y"
1722 : { (yyval.str) = "logical"; }
1723 : #line 1724 "repl_gram.c"
1724 0 : break;
1725 :
1726 0 : case 75: /* ident_or_keyword: K_SLOT */
1727 : #line 440 "repl_gram.y"
1728 : { (yyval.str) = "slot"; }
1729 : #line 1730 "repl_gram.c"
1730 0 : break;
1731 :
1732 262 : case 76: /* ident_or_keyword: K_RESERVE_WAL */
1733 : #line 441 "repl_gram.y"
1734 : { (yyval.str) = "reserve_wal"; }
1735 : #line 1736 "repl_gram.c"
1736 262 : break;
1737 :
1738 0 : case 77: /* ident_or_keyword: K_TEMPORARY */
1739 : #line 442 "repl_gram.y"
1740 : { (yyval.str) = "temporary"; }
1741 : #line 1742 "repl_gram.c"
1742 0 : break;
1743 :
1744 6 : case 78: /* ident_or_keyword: K_TWO_PHASE */
1745 : #line 443 "repl_gram.y"
1746 : { (yyval.str) = "two_phase"; }
1747 : #line 1748 "repl_gram.c"
1748 6 : break;
1749 :
1750 0 : case 79: /* ident_or_keyword: K_EXPORT_SNAPSHOT */
1751 : #line 444 "repl_gram.y"
1752 : { (yyval.str) = "export_snapshot"; }
1753 : #line 1754 "repl_gram.c"
1754 0 : break;
1755 :
1756 0 : case 80: /* ident_or_keyword: K_NOEXPORT_SNAPSHOT */
1757 : #line 445 "repl_gram.y"
1758 : { (yyval.str) = "noexport_snapshot"; }
1759 : #line 1760 "repl_gram.c"
1760 0 : break;
1761 :
1762 0 : case 81: /* ident_or_keyword: K_USE_SNAPSHOT */
1763 : #line 446 "repl_gram.y"
1764 : { (yyval.str) = "use_snapshot"; }
1765 : #line 1766 "repl_gram.c"
1766 0 : break;
1767 :
1768 0 : case 82: /* ident_or_keyword: K_UPLOAD_MANIFEST */
1769 : #line 447 "repl_gram.y"
1770 : { (yyval.str) = "upload_manifest"; }
1771 : #line 1772 "repl_gram.c"
1772 0 : break;
1773 :
1774 :
1775 : #line 1776 "repl_gram.c"
1776 :
1777 11160 : default: break;
1778 : }
1779 : /* User semantic actions sometimes alter yychar, and that requires
1780 : that yytoken be updated with the new translation. We take the
1781 : approach of translating immediately before every use of yytoken.
1782 : One alternative is translating here after every semantic action,
1783 : but that translation would be missed if the semantic action invokes
1784 : YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1785 : if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1786 : incorrect destructor might then be invoked immediately. In the
1787 : case of YYERROR or YYBACKUP, subsequent parser actions might lead
1788 : to an incorrect destructor call or verbose syntax error message
1789 : before the lookahead is translated. */
1790 : YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1791 :
1792 43818 : YYPOPSTACK (yylen);
1793 43818 : yylen = 0;
1794 :
1795 43818 : *++yyvsp = yyval;
1796 :
1797 : /* Now 'shift' the result of the reduction. Determine what state
1798 : that goes to, based on the state we popped back to and the rule
1799 : number reduced by. */
1800 : {
1801 43818 : const int yylhs = yyr1[yyn] - YYNTOKENS;
1802 43818 : const int yyi = yypgoto[yylhs] + *yyssp;
1803 18036 : yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1804 6490 : ? yytable[yyi]
1805 61854 : : yydefgoto[yylhs]);
1806 : }
1807 :
1808 43818 : goto yynewstate;
1809 :
1810 :
1811 : /*--------------------------------------.
1812 : | yyerrlab -- here on detecting error. |
1813 : `--------------------------------------*/
1814 0 : yyerrlab:
1815 : /* Make sure we have latest lookahead translation. See comments at
1816 : user semantic actions for why this is necessary. */
1817 0 : yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1818 : /* If not already recovering from an error, report this error. */
1819 0 : if (!yyerrstatus)
1820 : {
1821 0 : ++yynerrs;
1822 0 : yyerror (YY_("syntax error"));
1823 : }
1824 :
1825 0 : if (yyerrstatus == 3)
1826 : {
1827 : /* If just tried and failed to reuse lookahead token after an
1828 : error, discard it. */
1829 :
1830 0 : if (yychar <= YYEOF)
1831 : {
1832 : /* Return failure if at end of input. */
1833 0 : if (yychar == YYEOF)
1834 0 : YYABORT;
1835 : }
1836 : else
1837 : {
1838 0 : yydestruct ("Error: discarding",
1839 : yytoken, &yylval);
1840 0 : yychar = YYEMPTY;
1841 : }
1842 : }
1843 :
1844 : /* Else will try to reuse lookahead token after shifting the error
1845 : token. */
1846 0 : goto yyerrlab1;
1847 :
1848 :
1849 : /*---------------------------------------------------.
1850 : | yyerrorlab -- error raised explicitly by YYERROR. |
1851 : `---------------------------------------------------*/
1852 : yyerrorlab:
1853 : /* Pacify compilers when the user code never invokes YYERROR and the
1854 : label yyerrorlab therefore never appears in user code. */
1855 : if (0)
1856 : YYERROR;
1857 :
1858 : /* Do not reclaim the symbols of the rule whose action triggered
1859 : this YYERROR. */
1860 : YYPOPSTACK (yylen);
1861 : yylen = 0;
1862 : YY_STACK_PRINT (yyss, yyssp);
1863 : yystate = *yyssp;
1864 : goto yyerrlab1;
1865 :
1866 :
1867 : /*-------------------------------------------------------------.
1868 : | yyerrlab1 -- common code for both syntax error and YYERROR. |
1869 : `-------------------------------------------------------------*/
1870 0 : yyerrlab1:
1871 0 : yyerrstatus = 3; /* Each real token shifted decrements this. */
1872 :
1873 : /* Pop stack until we find a state that shifts the error token. */
1874 : for (;;)
1875 : {
1876 0 : yyn = yypact[yystate];
1877 0 : if (!yypact_value_is_default (yyn))
1878 : {
1879 0 : yyn += YYSYMBOL_YYerror;
1880 0 : if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1881 : {
1882 0 : yyn = yytable[yyn];
1883 0 : if (0 < yyn)
1884 0 : break;
1885 : }
1886 : }
1887 :
1888 : /* Pop the current state because it cannot handle the error token. */
1889 0 : if (yyssp == yyss)
1890 0 : YYABORT;
1891 :
1892 :
1893 0 : yydestruct ("Error: popping",
1894 0 : YY_ACCESSING_SYMBOL (yystate), yyvsp);
1895 0 : YYPOPSTACK (1);
1896 0 : yystate = *yyssp;
1897 : YY_STACK_PRINT (yyss, yyssp);
1898 : }
1899 :
1900 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1901 0 : *++yyvsp = yylval;
1902 : YY_IGNORE_MAYBE_UNINITIALIZED_END
1903 :
1904 :
1905 : /* Shift the error token. */
1906 : YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1907 :
1908 0 : yystate = yyn;
1909 0 : goto yynewstate;
1910 :
1911 :
1912 : /*-------------------------------------.
1913 : | yyacceptlab -- YYACCEPT comes here. |
1914 : `-------------------------------------*/
1915 5324 : yyacceptlab:
1916 5324 : yyresult = 0;
1917 5324 : goto yyreturn;
1918 :
1919 :
1920 : /*-----------------------------------.
1921 : | yyabortlab -- YYABORT comes here. |
1922 : `-----------------------------------*/
1923 0 : yyabortlab:
1924 0 : yyresult = 1;
1925 0 : goto yyreturn;
1926 :
1927 :
1928 : #if !defined yyoverflow
1929 : /*-------------------------------------------------.
1930 : | yyexhaustedlab -- memory exhaustion comes here. |
1931 : `-------------------------------------------------*/
1932 0 : yyexhaustedlab:
1933 0 : yyerror (YY_("memory exhausted"));
1934 : yyresult = 2;
1935 : goto yyreturn;
1936 : #endif
1937 :
1938 :
1939 : /*-------------------------------------------------------.
1940 : | yyreturn -- parsing is finished, clean up and return. |
1941 : `-------------------------------------------------------*/
1942 5324 : yyreturn:
1943 5324 : if (yychar != YYEMPTY)
1944 : {
1945 : /* Make sure we have latest lookahead translation. See comments at
1946 : user semantic actions for why this is necessary. */
1947 0 : yytoken = YYTRANSLATE (yychar);
1948 0 : yydestruct ("Cleanup: discarding lookahead",
1949 : yytoken, &yylval);
1950 : }
1951 : /* Do not reclaim the symbols of the rule whose action triggered
1952 : this YYABORT or YYACCEPT. */
1953 5324 : YYPOPSTACK (yylen);
1954 : YY_STACK_PRINT (yyss, yyssp);
1955 15972 : while (yyssp != yyss)
1956 : {
1957 10648 : yydestruct ("Cleanup: popping",
1958 10648 : YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
1959 10648 : YYPOPSTACK (1);
1960 : }
1961 : #ifndef yyoverflow
1962 5324 : if (yyss != yyssa)
1963 0 : YYSTACK_FREE (yyss);
1964 : #endif
1965 :
1966 5324 : return yyresult;
1967 : }
1968 :
1969 : #line 450 "repl_gram.y"
1970 :
|
