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