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