Line data Source code
1 : #line 2 "repl_scanner.c"
2 :
3 : #line 4 "repl_scanner.c"
4 :
5 : #define YY_INT_ALIGNED short int
6 :
7 : /* A lexical scanner generated by flex */
8 :
9 : #define yy_create_buffer replication_yy_create_buffer
10 : #define yy_delete_buffer replication_yy_delete_buffer
11 : #define yy_flex_debug replication_yy_flex_debug
12 : #define yy_init_buffer replication_yy_init_buffer
13 : #define yy_flush_buffer replication_yy_flush_buffer
14 : #define yy_load_buffer_state replication_yy_load_buffer_state
15 : #define yy_switch_to_buffer replication_yy_switch_to_buffer
16 : #define yyin replication_yyin
17 : #define yyleng replication_yyleng
18 : #define yylex replication_yylex
19 : #define yylineno replication_yylineno
20 : #define yyout replication_yyout
21 : #define yyrestart replication_yyrestart
22 : #define yytext replication_yytext
23 : #define yywrap replication_yywrap
24 : #define yyalloc replication_yyalloc
25 : #define yyrealloc replication_yyrealloc
26 : #define yyfree replication_yyfree
27 :
28 : #define FLEX_SCANNER
29 : #define YY_FLEX_MAJOR_VERSION 2
30 : #define YY_FLEX_MINOR_VERSION 5
31 : #define YY_FLEX_SUBMINOR_VERSION 39
32 : #if YY_FLEX_SUBMINOR_VERSION > 0
33 : #define FLEX_BETA
34 : #endif
35 :
36 : /* First, we deal with platform-specific or compiler-specific issues. */
37 :
38 : /* begin standard C headers. */
39 : #include <stdio.h>
40 : #include <string.h>
41 : #include <errno.h>
42 : #include <stdlib.h>
43 :
44 : /* end standard C headers. */
45 :
46 : /* flex integer type definitions */
47 :
48 : #ifndef FLEXINT_H
49 : #define FLEXINT_H
50 :
51 : /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52 :
53 : #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54 :
55 : /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56 : * if you want the limit (max/min) macros for int types.
57 : */
58 : #ifndef __STDC_LIMIT_MACROS
59 : #define __STDC_LIMIT_MACROS 1
60 : #endif
61 :
62 : #include <inttypes.h>
63 : typedef int8_t flex_int8_t;
64 : typedef uint8_t flex_uint8_t;
65 : typedef int16_t flex_int16_t;
66 : typedef uint16_t flex_uint16_t;
67 : typedef int32_t flex_int32_t;
68 : typedef uint32_t flex_uint32_t;
69 : #else
70 : typedef signed char flex_int8_t;
71 : typedef short int flex_int16_t;
72 : typedef int flex_int32_t;
73 : typedef unsigned char flex_uint8_t;
74 : typedef unsigned short int flex_uint16_t;
75 : typedef unsigned int flex_uint32_t;
76 :
77 : /* Limits of integral types. */
78 : #ifndef INT8_MIN
79 : #define INT8_MIN (-128)
80 : #endif
81 : #ifndef INT16_MIN
82 : #define INT16_MIN (-32767-1)
83 : #endif
84 : #ifndef INT32_MIN
85 : #define INT32_MIN (-2147483647-1)
86 : #endif
87 : #ifndef INT8_MAX
88 : #define INT8_MAX (127)
89 : #endif
90 : #ifndef INT16_MAX
91 : #define INT16_MAX (32767)
92 : #endif
93 : #ifndef INT32_MAX
94 : #define INT32_MAX (2147483647)
95 : #endif
96 : #ifndef UINT8_MAX
97 : #define UINT8_MAX (255U)
98 : #endif
99 : #ifndef UINT16_MAX
100 : #define UINT16_MAX (65535U)
101 : #endif
102 : #ifndef UINT32_MAX
103 : #define UINT32_MAX (4294967295U)
104 : #endif
105 :
106 : #endif /* ! C99 */
107 :
108 : #endif /* ! FLEXINT_H */
109 :
110 : #ifdef __cplusplus
111 :
112 : /* The "const" storage-class-modifier is valid. */
113 : #define YY_USE_CONST
114 :
115 : #else /* ! __cplusplus */
116 :
117 : /* C99 requires __STDC__ to be defined as 1. */
118 : #if defined (__STDC__)
119 :
120 : #define YY_USE_CONST
121 :
122 : #endif /* defined (__STDC__) */
123 : #endif /* ! __cplusplus */
124 :
125 : #ifdef YY_USE_CONST
126 : #define yyconst const
127 : #else
128 : #define yyconst
129 : #endif
130 :
131 : /* Returned upon end-of-file. */
132 : #define YY_NULL 0
133 :
134 : /* Promotes a possibly negative, possibly signed char to an unsigned
135 : * integer for use as an array index. If the signed char is negative,
136 : * we want to instead treat it as an 8-bit unsigned char, hence the
137 : * double cast.
138 : */
139 : #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
140 :
141 : /* Enter a start condition. This macro really ought to take a parameter,
142 : * but we do it the disgusting crufty way forced on us by the ()-less
143 : * definition of BEGIN.
144 : */
145 : #define BEGIN (yy_start) = 1 + 2 *
146 :
147 : /* Translate the current start state into a value that can be later handed
148 : * to BEGIN to return to the state. The YYSTATE alias is for lex
149 : * compatibility.
150 : */
151 : #define YY_START (((yy_start) - 1) / 2)
152 : #define YYSTATE YY_START
153 :
154 : /* Action number for EOF rule of a given start state. */
155 : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
156 :
157 : /* Special action meaning "start processing a new file". */
158 : #define YY_NEW_FILE replication_yyrestart(replication_yyin )
159 :
160 : #define YY_END_OF_BUFFER_CHAR 0
161 :
162 : /* Size of default input buffer. */
163 : #ifndef YY_BUF_SIZE
164 : #ifdef __ia64__
165 : /* On IA-64, the buffer size is 16k, not 8k.
166 : * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
167 : * Ditto for the __ia64__ case accordingly.
168 : */
169 : #define YY_BUF_SIZE 32768
170 : #else
171 : #define YY_BUF_SIZE 16384
172 : #endif /* __ia64__ */
173 : #endif
174 :
175 : /* The state buf must be large enough to hold one state per character in the main buffer.
176 : */
177 : #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
178 :
179 : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
180 : #define YY_TYPEDEF_YY_BUFFER_STATE
181 : typedef struct yy_buffer_state *YY_BUFFER_STATE;
182 : #endif
183 :
184 : #ifndef YY_TYPEDEF_YY_SIZE_T
185 : #define YY_TYPEDEF_YY_SIZE_T
186 : typedef size_t yy_size_t;
187 : #endif
188 :
189 : extern yy_size_t replication_yyleng;
190 :
191 : extern FILE *replication_yyin, *replication_yyout;
192 :
193 : #define EOB_ACT_CONTINUE_SCAN 0
194 : #define EOB_ACT_END_OF_FILE 1
195 : #define EOB_ACT_LAST_MATCH 2
196 :
197 : #define YY_LESS_LINENO(n)
198 : #define YY_LINENO_REWIND_TO(ptr)
199 :
200 : /* Return all but the first "n" matched characters back to the input stream. */
201 : #define yyless(n) \
202 : do \
203 : { \
204 : /* Undo effects of setting up replication_yytext. */ \
205 : int yyless_macro_arg = (n); \
206 : YY_LESS_LINENO(yyless_macro_arg);\
207 : *yy_cp = (yy_hold_char); \
208 : YY_RESTORE_YY_MORE_OFFSET \
209 : (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
210 : YY_DO_BEFORE_ACTION; /* set up replication_yytext again */ \
211 : } \
212 : while ( 0 )
213 :
214 : #define unput(c) yyunput( c, (yytext_ptr) )
215 :
216 : #ifndef YY_STRUCT_YY_BUFFER_STATE
217 : #define YY_STRUCT_YY_BUFFER_STATE
218 : struct yy_buffer_state
219 : {
220 : FILE *yy_input_file;
221 :
222 : char *yy_ch_buf; /* input buffer */
223 : char *yy_buf_pos; /* current position in input buffer */
224 :
225 : /* Size of input buffer in bytes, not including room for EOB
226 : * characters.
227 : */
228 : yy_size_t yy_buf_size;
229 :
230 : /* Number of characters read into yy_ch_buf, not including EOB
231 : * characters.
232 : */
233 : yy_size_t yy_n_chars;
234 :
235 : /* Whether we "own" the buffer - i.e., we know we created it,
236 : * and can realloc() it to grow it, and should free() it to
237 : * delete it.
238 : */
239 : int yy_is_our_buffer;
240 :
241 : /* Whether this is an "interactive" input source; if so, and
242 : * if we're using stdio for input, then we want to use getc()
243 : * instead of fread(), to make sure we stop fetching input after
244 : * each newline.
245 : */
246 : int yy_is_interactive;
247 :
248 : /* Whether we're considered to be at the beginning of a line.
249 : * If so, '^' rules will be active on the next match, otherwise
250 : * not.
251 : */
252 : int yy_at_bol;
253 :
254 : int yy_bs_lineno; /**< The line count. */
255 : int yy_bs_column; /**< The column count. */
256 :
257 : /* Whether to try to fill the input buffer when we reach the
258 : * end of it.
259 : */
260 : int yy_fill_buffer;
261 :
262 : int yy_buffer_status;
263 :
264 : #define YY_BUFFER_NEW 0
265 : #define YY_BUFFER_NORMAL 1
266 : /* When an EOF's been seen but there's still some text to process
267 : * then we mark the buffer as YY_EOF_PENDING, to indicate that we
268 : * shouldn't try reading from the input source any more. We might
269 : * still have a bunch of tokens to match, though, because of
270 : * possible backing-up.
271 : *
272 : * When we actually see the EOF, we change the status to "new"
273 : * (via replication_yyrestart()), so that the user can continue scanning by
274 : * just pointing replication_yyin at a new input file.
275 : */
276 : #define YY_BUFFER_EOF_PENDING 2
277 :
278 : };
279 : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
280 :
281 : /* Stack of input buffers. */
282 : static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
283 : static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
284 : static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
285 :
286 : /* We provide macros for accessing buffer states in case in the
287 : * future we want to put the buffer states in a more general
288 : * "scanner state".
289 : *
290 : * Returns the top of the stack, or NULL.
291 : */
292 : #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
293 : ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
294 : : NULL)
295 :
296 : /* Same as previous macro, but useful when we know that the buffer stack is not
297 : * NULL or when we need an lvalue. For internal use only.
298 : */
299 : #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
300 :
301 : /* yy_hold_char holds the character lost when replication_yytext is formed. */
302 : static char yy_hold_char;
303 : static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
304 : yy_size_t replication_yyleng;
305 :
306 : /* Points to current character in buffer. */
307 : static char *yy_c_buf_p = (char *) 0;
308 : static int yy_init = 0; /* whether we need to initialize */
309 : static int yy_start = 0; /* start state number */
310 :
311 : /* Flag which is used to allow replication_yywrap()'s to do buffer switches
312 : * instead of setting up a fresh replication_yyin. A bit of a hack ...
313 : */
314 : static int yy_did_buffer_switch_on_eof;
315 :
316 : void replication_yyrestart (FILE *input_file );
317 : void replication_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
318 : YY_BUFFER_STATE replication_yy_create_buffer (FILE *file,int size );
319 : void replication_yy_delete_buffer (YY_BUFFER_STATE b );
320 : void replication_yy_flush_buffer (YY_BUFFER_STATE b );
321 : void replication_yypush_buffer_state (YY_BUFFER_STATE new_buffer );
322 : void replication_yypop_buffer_state (void );
323 :
324 : static void replication_yyensure_buffer_stack (void );
325 : static void replication_yy_load_buffer_state (void );
326 : static void replication_yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
327 :
328 : #define YY_FLUSH_BUFFER replication_yy_flush_buffer(YY_CURRENT_BUFFER )
329 :
330 : YY_BUFFER_STATE replication_yy_scan_buffer (char *base,yy_size_t size );
331 : YY_BUFFER_STATE replication_yy_scan_string (yyconst char *yy_str );
332 : YY_BUFFER_STATE replication_yy_scan_bytes (yyconst char *bytes,yy_size_t len );
333 :
334 : void *replication_yyalloc (yy_size_t );
335 : void *replication_yyrealloc (void *,yy_size_t );
336 : void replication_yyfree (void * );
337 :
338 : #define yy_new_buffer replication_yy_create_buffer
339 :
340 : #define yy_set_interactive(is_interactive) \
341 : { \
342 : if ( ! YY_CURRENT_BUFFER ){ \
343 : replication_yyensure_buffer_stack (); \
344 : YY_CURRENT_BUFFER_LVALUE = \
345 : replication_yy_create_buffer(replication_yyin,YY_BUF_SIZE ); \
346 : } \
347 : YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
348 : }
349 :
350 : #define yy_set_bol(at_bol) \
351 : { \
352 : if ( ! YY_CURRENT_BUFFER ){\
353 : replication_yyensure_buffer_stack (); \
354 : YY_CURRENT_BUFFER_LVALUE = \
355 : replication_yy_create_buffer(replication_yyin,YY_BUF_SIZE ); \
356 : } \
357 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
358 : }
359 :
360 : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
361 :
362 : /* Begin user sect3 */
363 :
364 : #define replication_yywrap() 1
365 : #define YY_SKIP_YYWRAP
366 :
367 : typedef unsigned char YY_CHAR;
368 :
369 : FILE *replication_yyin = (FILE *) 0, *replication_yyout = (FILE *) 0;
370 :
371 : typedef int yy_state_type;
372 :
373 : extern int replication_yylineno;
374 :
375 : int replication_yylineno = 1;
376 :
377 : extern char *replication_yytext;
378 : #define yytext_ptr replication_yytext
379 :
380 : static yy_state_type yy_get_previous_state (void );
381 : static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
382 : static int yy_get_next_buffer (void );
383 : static void yy_fatal_error (yyconst char msg[] );
384 :
385 : /* Done after the current pattern has been matched and before the
386 : * corresponding action - sets up replication_yytext.
387 : */
388 : #define YY_DO_BEFORE_ACTION \
389 : (yytext_ptr) = yy_bp; \
390 : replication_yyleng = (size_t) (yy_cp - yy_bp); \
391 : (yy_hold_char) = *yy_cp; \
392 : *yy_cp = '\0'; \
393 : (yy_c_buf_p) = yy_cp;
394 :
395 : #define YY_NUM_RULES 43
396 : #define YY_END_OF_BUFFER 44
397 : /* This struct is not used in this scanner,
398 : but its presence is necessary. */
399 : struct yy_trans_info
400 : {
401 : flex_int32_t yy_verify;
402 : flex_int32_t yy_nxt;
403 : };
404 : static yyconst flex_int16_t yy_accept[267] =
405 : { 0,
406 : 0, 0, 0, 0, 0, 0, 44, 42, 30, 29,
407 : 31, 38, 34, 27, 28, 25, 32, 26, 41, 41,
408 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
409 : 41, 41, 41, 41, 41, 37, 35, 40, 39, 0,
410 : 32, 0, 41, 41, 41, 41, 41, 41, 41, 41,
411 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
412 : 41, 41, 41, 41, 41, 37, 36, 40, 33, 41,
413 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
414 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
415 : 41, 9, 41, 41, 41, 41, 2, 41, 41, 41,
416 :
417 : 41, 41, 41, 41, 41, 41, 4, 19, 41, 41,
418 : 41, 41, 41, 24, 41, 41, 41, 41, 41, 5,
419 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
420 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
421 : 6, 41, 41, 41, 41, 41, 41, 41, 41, 41,
422 : 41, 41, 41, 41, 18, 41, 41, 41, 41, 41,
423 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
424 : 8, 41, 16, 7, 41, 41, 41, 41, 11, 41,
425 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 20,
426 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
427 :
428 : 41, 41, 41, 1, 41, 41, 41, 41, 41, 17,
429 : 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
430 : 41, 41, 23, 41, 41, 41, 41, 41, 41, 41,
431 : 41, 41, 41, 41, 41, 41, 41, 10, 41, 41,
432 : 41, 21, 3, 41, 41, 41, 41, 41, 41, 41,
433 : 15, 41, 41, 22, 12, 41, 41, 41, 41, 41,
434 : 41, 41, 14, 41, 13, 0
435 : } ;
436 :
437 : static yyconst flex_int32_t yy_ec[256] =
438 : { 0,
439 : 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
440 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
441 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
442 : 1, 4, 1, 5, 1, 6, 1, 1, 7, 8,
443 : 9, 1, 1, 10, 1, 1, 11, 12, 12, 12,
444 : 12, 12, 12, 12, 12, 12, 12, 1, 13, 1,
445 : 1, 1, 1, 1, 14, 15, 16, 17, 18, 19,
446 : 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
447 : 23, 30, 31, 32, 33, 34, 35, 36, 37, 23,
448 : 1, 1, 1, 1, 38, 1, 23, 23, 23, 23,
449 :
450 : 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
451 : 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
452 : 23, 23, 1, 1, 1, 1, 1, 39, 39, 39,
453 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
454 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
455 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
456 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
457 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
458 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
459 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
460 :
461 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
462 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
463 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
464 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
465 : 39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
466 : 39, 39, 39, 39, 39
467 : } ;
468 :
469 : static yyconst flex_int32_t yy_meta[40] =
470 : { 0,
471 : 1, 1, 1, 1, 2, 3, 4, 1, 1, 1,
472 : 5, 6, 1, 6, 6, 6, 6, 6, 6, 6,
473 : 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
474 : 6, 6, 6, 6, 6, 6, 6, 3, 3
475 : } ;
476 :
477 : static yyconst flex_int16_t yy_base[275] =
478 : { 0,
479 : 0, 0, 540, 539, 540, 539, 543, 548, 548, 548,
480 : 548, 548, 548, 548, 548, 548, 29, 548, 36, 38,
481 : 40, 42, 48, 44, 50, 84, 29, 57, 78, 79,
482 : 88, 82, 87, 77, 0, 0, 535, 0, 548, 0,
483 : 51, 530, 0, 89, 97, 112, 105, 107, 110, 125,
484 : 117, 128, 123, 132, 133, 130, 135, 140, 141, 143,
485 : 150, 148, 158, 159, 166, 0, 548, 0, 0, 161,
486 : 167, 168, 171, 176, 178, 184, 179, 186, 189, 195,
487 : 199, 201, 204, 205, 206, 214, 221, 222, 225, 217,
488 : 233, 234, 238, 240, 242, 243, 246, 249, 250, 268,
489 :
490 : 510, 265, 269, 273, 272, 275, 271, 276, 278, 293,
491 : 284, 294, 508, 295, 523, 299, 507, 300, 302, 301,
492 : 306, 522, 311, 312, 317, 323, 321, 322, 328, 324,
493 : 339, 508, 520, 334, 515, 343, 349, 350, 500, 352,
494 : 351, 355, 356, 371, 501, 362, 360, 378, 516, 513,
495 : 498, 498, 495, 372, 379, 507, 380, 388, 383, 382,
496 : 506, 387, 389, 404, 494, 498, 503, 495, 492, 407,
497 : 0, 409, 410, 411, 483, 488, 412, 413, 415, 485,
498 : 482, 485, 491, 498, 480, 479, 495, 483, 416, 428,
499 : 486, 485, 476, 475, 480, 462, 453, 459, 444, 446,
500 :
501 : 432, 445, 438, 0, 443, 450, 432, 431, 447, 0,
502 : 443, 432, 426, 423, 438, 420, 430, 417, 419, 422,
503 : 419, 399, 0, 390, 376, 367, 355, 327, 315, 317,
504 : 315, 286, 260, 237, 241, 238, 236, 0, 211, 215,
505 : 199, 0, 0, 188, 183, 173, 155, 114, 102, 102,
506 : 0, 100, 83, 0, 0, 56, 48, 38, 40, 41,
507 : 33, 36, 0, 28, 0, 548, 470, 476, 478, 482,
508 : 486, 492, 498, 39
509 : } ;
510 :
511 : static yyconst flex_int16_t yy_def[275] =
512 : { 0,
513 : 266, 1, 267, 267, 268, 268, 266, 266, 266, 266,
514 : 266, 266, 266, 266, 266, 266, 269, 266, 270, 270,
515 : 270, 270, 270, 270, 270, 270, 26, 26, 26, 26,
516 : 26, 26, 26, 26, 271, 272, 266, 273, 266, 274,
517 : 269, 269, 271, 26, 26, 26, 26, 26, 26, 26,
518 : 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
519 : 26, 26, 26, 26, 26, 272, 266, 273, 274, 26,
520 : 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
521 : 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
522 : 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
523 :
524 : 271, 26, 26, 26, 26, 26, 26, 26, 26, 26,
525 : 26, 26, 271, 26, 271, 26, 271, 26, 26, 26,
526 : 26, 271, 26, 26, 26, 26, 26, 26, 26, 26,
527 : 26, 271, 271, 26, 271, 26, 26, 26, 271, 26,
528 : 26, 26, 26, 26, 271, 26, 26, 26, 271, 271,
529 : 271, 271, 271, 26, 26, 271, 26, 26, 26, 26,
530 : 271, 26, 26, 26, 271, 271, 271, 271, 271, 26,
531 : 271, 26, 26, 26, 271, 271, 26, 26, 26, 271,
532 : 271, 271, 271, 271, 271, 271, 271, 271, 26, 26,
533 : 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
534 :
535 : 26, 271, 271, 271, 271, 271, 271, 271, 271, 271,
536 : 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
537 : 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
538 : 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
539 : 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
540 : 271, 271, 271, 271, 271, 271, 271, 271, 271, 271,
541 : 271, 271, 271, 271, 271, 0, 266, 266, 266, 266,
542 : 266, 266, 266, 266
543 : } ;
544 :
545 : static yyconst flex_int16_t yy_nxt[588] =
546 : { 0,
547 : 8, 9, 10, 11, 12, 8, 13, 14, 15, 16,
548 : 8, 17, 18, 19, 20, 21, 22, 23, 24, 19,
549 : 19, 25, 19, 19, 26, 27, 28, 19, 29, 30,
550 : 31, 32, 33, 19, 34, 19, 19, 35, 35, 40,
551 : 41, 43, 53, 43, 69, 43, 40, 43, 40, 43,
552 : 40, 45, 40, 43, 40, 43, 44, 49, 40, 265,
553 : 40, 40, 41, 264, 263, 262, 50, 261, 260, 46,
554 : 44, 47, 259, 43, 43, 43, 43, 43, 43, 43,
555 : 43, 43, 43, 48, 54, 43, 43, 43, 43, 43,
556 : 65, 44, 44, 258, 40, 61, 57, 51, 55, 62,
557 :
558 : 44, 44, 44, 63, 44, 44, 44, 56, 58, 44,
559 : 44, 52, 59, 257, 44, 44, 44, 64, 44, 60,
560 : 44, 43, 43, 44, 44, 44, 256, 70, 255, 71,
561 : 44, 76, 72, 254, 44, 73, 44, 44, 44, 44,
562 : 74, 44, 75, 44, 44, 44, 44, 77, 44, 79,
563 : 44, 253, 44, 44, 44, 44, 86, 82, 78, 44,
564 : 44, 44, 44, 44, 87, 83, 80, 84, 85, 81,
565 : 44, 44, 44, 88, 44, 44, 90, 44, 93, 44,
566 : 94, 44, 252, 89, 44, 44, 44, 91, 44, 44,
567 : 92, 44, 44, 44, 44, 44, 95, 44, 96, 44,
568 :
569 : 100, 99, 44, 44, 98, 44, 44, 97, 103, 251,
570 : 250, 44, 44, 44, 44, 249, 44, 44, 44, 44,
571 : 105, 106, 44, 101, 102, 248, 44, 44, 44, 104,
572 : 44, 44, 44, 44, 44, 44, 247, 108, 44, 107,
573 : 246, 44, 112, 109, 44, 110, 44, 44, 44, 44,
574 : 111, 44, 44, 44, 113, 44, 44, 245, 244, 44,
575 : 44, 44, 44, 44, 114, 44, 243, 44, 242, 44,
576 : 44, 116, 118, 44, 120, 115, 44, 44, 44, 117,
577 : 119, 44, 44, 121, 44, 44, 44, 241, 44, 44,
578 : 124, 44, 44, 123, 125, 44, 44, 44, 44, 44,
579 :
580 : 44, 126, 44, 44, 127, 44, 44, 44, 44, 128,
581 : 129, 130, 44, 44, 44, 44, 134, 240, 131, 138,
582 : 44, 44, 44, 137, 44, 44, 44, 44, 44, 44,
583 : 44, 136, 142, 44, 44, 44, 44, 44, 140, 44,
584 : 143, 44, 239, 141, 44, 238, 237, 44, 44, 44,
585 : 44, 44, 44, 147, 144, 44, 44, 236, 146, 145,
586 : 148, 44, 44, 44, 44, 44, 44, 154, 158, 44,
587 : 44, 151, 235, 163, 155, 44, 44, 44, 44, 44,
588 : 153, 157, 44, 44, 44, 44, 159, 44, 160, 44,
589 : 162, 44, 44, 44, 234, 44, 44, 233, 44, 44,
590 :
591 : 177, 44, 44, 232, 164, 44, 44, 44, 170, 44,
592 : 44, 172, 173, 174, 44, 44, 44, 44, 178, 175,
593 : 44, 179, 44, 44, 44, 44, 44, 189, 44, 44,
594 : 231, 44, 230, 201, 44, 229, 44, 44, 44, 44,
595 : 44, 44, 44, 44, 185, 44, 186, 228, 227, 190,
596 : 226, 225, 191, 224, 223, 44, 222, 221, 220, 44,
597 : 219, 218, 217, 216, 215, 214, 213, 211, 210, 212,
598 : 36, 36, 36, 36, 36, 36, 38, 38, 38, 38,
599 : 38, 38, 42, 42, 44, 209, 44, 44, 43, 208,
600 : 207, 43, 66, 66, 66, 206, 66, 66, 68, 205,
601 :
602 : 68, 68, 68, 68, 204, 203, 202, 200, 199, 198,
603 : 197, 196, 195, 194, 193, 192, 188, 187, 184, 183,
604 : 182, 181, 180, 176, 171, 169, 168, 167, 166, 165,
605 : 161, 156, 152, 150, 149, 139, 135, 133, 132, 122,
606 : 40, 67, 266, 39, 39, 37, 37, 7, 266, 266,
607 : 266, 266, 266, 266, 266, 266, 266, 266, 266, 266,
608 : 266, 266, 266, 266, 266, 266, 266, 266, 266, 266,
609 : 266, 266, 266, 266, 266, 266, 266, 266, 266, 266,
610 : 266, 266, 266, 266, 266, 266, 266
611 : } ;
612 :
613 : static yyconst flex_int16_t yy_chk[588] =
614 : { 0,
615 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
616 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
617 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
618 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 17,
619 : 17, 19, 27, 20, 274, 21, 19, 22, 20, 24,
620 : 21, 20, 22, 23, 24, 25, 27, 24, 23, 264,
621 : 25, 41, 41, 262, 261, 260, 25, 259, 258, 21,
622 : 28, 22, 257, 19, 19, 20, 20, 21, 21, 22,
623 : 22, 24, 24, 23, 28, 23, 23, 25, 25, 26,
624 : 34, 29, 30, 256, 26, 32, 30, 26, 29, 32,
625 :
626 : 33, 31, 44, 32, 34, 29, 30, 29, 31, 32,
627 : 45, 26, 31, 253, 33, 31, 44, 33, 47, 31,
628 : 48, 26, 26, 49, 45, 46, 252, 45, 250, 46,
629 : 51, 51, 47, 249, 48, 48, 53, 49, 50, 46,
630 : 49, 52, 50, 56, 51, 54, 55, 52, 57, 54,
631 : 53, 248, 50, 58, 59, 52, 60, 56, 53, 54,
632 : 55, 62, 57, 61, 61, 57, 54, 58, 59, 55,
633 : 60, 63, 64, 62, 70, 62, 64, 61, 70, 65,
634 : 71, 72, 247, 63, 73, 63, 64, 65, 70, 74,
635 : 65, 75, 77, 65, 71, 72, 72, 76, 73, 78,
636 :
637 : 77, 76, 79, 74, 75, 75, 77, 74, 80, 246,
638 : 245, 76, 81, 78, 82, 244, 79, 83, 84, 85,
639 : 82, 83, 80, 78, 79, 241, 81, 86, 82, 81,
640 : 90, 83, 84, 85, 87, 88, 240, 85, 89, 84,
641 : 239, 86, 89, 86, 90, 87, 91, 92, 87, 88,
642 : 88, 93, 89, 94, 90, 95, 96, 237, 236, 97,
643 : 91, 92, 98, 99, 91, 93, 235, 94, 234, 95,
644 : 96, 94, 96, 97, 99, 93, 98, 99, 102, 95,
645 : 98, 100, 103, 100, 107, 105, 104, 233, 106, 108,
646 : 103, 109, 102, 102, 104, 100, 103, 111, 107, 105,
647 :
648 : 104, 105, 106, 108, 106, 109, 110, 112, 114, 109,
649 : 110, 111, 116, 118, 120, 119, 116, 232, 112, 121,
650 : 110, 112, 114, 119, 123, 124, 116, 118, 120, 119,
651 : 125, 118, 125, 121, 127, 128, 126, 130, 123, 124,
652 : 126, 129, 231, 124, 125, 230, 229, 134, 127, 128,
653 : 126, 130, 131, 130, 127, 129, 136, 228, 129, 128,
654 : 131, 134, 137, 138, 141, 140, 131, 137, 142, 143,
655 : 136, 134, 227, 147, 138, 146, 137, 138, 141, 140,
656 : 136, 140, 142, 143, 144, 154, 143, 147, 144, 146,
657 : 146, 148, 155, 157, 226, 160, 159, 225, 144, 154,
658 :
659 : 162, 158, 163, 224, 148, 148, 155, 157, 154, 160,
660 : 159, 157, 158, 159, 162, 158, 163, 164, 163, 160,
661 : 170, 164, 172, 173, 174, 177, 178, 177, 179, 189,
662 : 222, 164, 221, 189, 170, 220, 172, 173, 174, 177,
663 : 178, 190, 179, 189, 170, 201, 172, 219, 218, 178,
664 : 217, 216, 179, 215, 214, 190, 213, 212, 211, 201,
665 : 209, 208, 207, 206, 205, 203, 202, 200, 199, 201,
666 : 267, 267, 267, 267, 267, 267, 268, 268, 268, 268,
667 : 268, 268, 269, 269, 270, 198, 270, 270, 271, 197,
668 : 196, 271, 272, 272, 272, 195, 272, 272, 273, 194,
669 :
670 : 273, 273, 273, 273, 193, 192, 191, 188, 187, 186,
671 : 185, 184, 183, 182, 181, 180, 176, 175, 169, 168,
672 : 167, 166, 165, 161, 156, 153, 152, 151, 150, 149,
673 : 145, 139, 135, 133, 132, 122, 117, 115, 113, 101,
674 : 42, 37, 7, 6, 5, 4, 3, 266, 266, 266,
675 : 266, 266, 266, 266, 266, 266, 266, 266, 266, 266,
676 : 266, 266, 266, 266, 266, 266, 266, 266, 266, 266,
677 : 266, 266, 266, 266, 266, 266, 266, 266, 266, 266,
678 : 266, 266, 266, 266, 266, 266, 266
679 : } ;
680 :
681 : static yy_state_type yy_last_accepting_state;
682 : static char *yy_last_accepting_cpos;
683 :
684 : extern int replication_yy_flex_debug;
685 : int replication_yy_flex_debug = 0;
686 :
687 : /* The intent behind this definition is that it'll catch
688 : * any uses of REJECT which flex missed.
689 : */
690 : #define REJECT reject_used_but_not_detected
691 : #define yymore() yymore_used_but_not_detected
692 : #define YY_MORE_ADJ 0
693 : #define YY_RESTORE_YY_MORE_OFFSET
694 : char *replication_yytext;
695 : #line 1 "repl_scanner.l"
696 : #line 2 "repl_scanner.l"
697 : /*-------------------------------------------------------------------------
698 : *
699 : * repl_scanner.l
700 : * a lexical scanner for the replication commands
701 : *
702 : * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
703 : * Portions Copyright (c) 1994, Regents of the University of California
704 : *
705 : *
706 : * IDENTIFICATION
707 : * src/backend/replication/repl_scanner.l
708 : *
709 : *-------------------------------------------------------------------------
710 : */
711 : #include "postgres.h"
712 :
713 : #include "utils/builtins.h"
714 : #include "parser/scansup.h"
715 :
716 : /* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
717 : #undef fprintf
718 : #define fprintf(file, fmt, msg) fprintf_to_ereport(fmt, msg)
719 :
720 : static void
721 : fprintf_to_ereport(const char *fmt, const char *msg)
722 : {
723 : ereport(ERROR, (errmsg_internal("%s", msg)));
724 : }
725 :
726 : /* Handle to the buffer that the lexer uses internally */
727 : static YY_BUFFER_STATE scanbufhandle;
728 :
729 : static StringInfoData litbuf;
730 :
731 : static void startlit(void);
732 : static char *litbufdup(void);
733 : static void addlit(char *ytext, int yleng);
734 : static void addlitchar(unsigned char ychar);
735 :
736 : #define YY_NO_INPUT 1
737 :
738 : /* Extended quote
739 : * xqdouble implements embedded quote, ''''
740 : */
741 : /* Double quote
742 : * Allows embedded spaces and other special characters into identifiers.
743 : */
744 : #line 745 "repl_scanner.c"
745 :
746 : #define INITIAL 0
747 : #define xq 1
748 : #define xd 2
749 :
750 : #ifndef YY_NO_UNISTD_H
751 : /* Special case for "unistd.h", since it is non-ANSI. We include it way
752 : * down here because we want the user's section 1 to have been scanned first.
753 : * The user has a chance to override it with an option.
754 : */
755 : #include <unistd.h>
756 : #endif
757 :
758 : #ifndef YY_EXTRA_TYPE
759 : #define YY_EXTRA_TYPE void *
760 : #endif
761 :
762 : static int yy_init_globals (void );
763 :
764 : /* Accessor methods to globals.
765 : These are made visible to non-reentrant scanners for convenience. */
766 :
767 : int replication_yylex_destroy (void );
768 :
769 : int replication_yyget_debug (void );
770 :
771 : void replication_yyset_debug (int debug_flag );
772 :
773 : YY_EXTRA_TYPE replication_yyget_extra (void );
774 :
775 : void replication_yyset_extra (YY_EXTRA_TYPE user_defined );
776 :
777 : FILE *replication_yyget_in (void );
778 :
779 : void replication_yyset_in (FILE * in_str );
780 :
781 : FILE *replication_yyget_out (void );
782 :
783 : void replication_yyset_out (FILE * out_str );
784 :
785 : yy_size_t replication_yyget_leng (void );
786 :
787 : char *replication_yyget_text (void );
788 :
789 : int replication_yyget_lineno (void );
790 :
791 : void replication_yyset_lineno (int line_number );
792 :
793 : /* Macros after this point can all be overridden by user definitions in
794 : * section 1.
795 : */
796 :
797 : #ifndef YY_SKIP_YYWRAP
798 : #ifdef __cplusplus
799 : extern "C" int replication_yywrap (void );
800 : #else
801 : extern int replication_yywrap (void );
802 : #endif
803 : #endif
804 :
805 : #ifndef yytext_ptr
806 : static void yy_flex_strncpy (char *,yyconst char *,int );
807 : #endif
808 :
809 : #ifdef YY_NEED_STRLEN
810 : static int yy_flex_strlen (yyconst char * );
811 : #endif
812 :
813 : #ifndef YY_NO_INPUT
814 :
815 : #ifdef __cplusplus
816 : static int yyinput (void );
817 : #else
818 : static int input (void );
819 : #endif
820 :
821 : #endif
822 :
823 : /* Amount of stuff to slurp up with each read. */
824 : #ifndef YY_READ_BUF_SIZE
825 : #ifdef __ia64__
826 : /* On IA-64, the buffer size is 16k, not 8k */
827 : #define YY_READ_BUF_SIZE 16384
828 : #else
829 : #define YY_READ_BUF_SIZE 8192
830 : #endif /* __ia64__ */
831 : #endif
832 :
833 : /* Copy whatever the last rule matched to the standard output. */
834 : #ifndef ECHO
835 : /* This used to be an fputs(), but since the string might contain NUL's,
836 : * we now use fwrite().
837 : */
838 : #define ECHO do { if (fwrite( replication_yytext, replication_yyleng, 1, replication_yyout )) {} } while (0)
839 : #endif
840 :
841 : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
842 : * is returned in "result".
843 : */
844 : #ifndef YY_INPUT
845 : #define YY_INPUT(buf,result,max_size) \
846 : if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
847 : { \
848 : int c = '*'; \
849 : int n; \
850 : for ( n = 0; n < max_size && \
851 : (c = getc( replication_yyin )) != EOF && c != '\n'; ++n ) \
852 : buf[n] = (char) c; \
853 : if ( c == '\n' ) \
854 : buf[n++] = (char) c; \
855 : if ( c == EOF && ferror( replication_yyin ) ) \
856 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
857 : result = n; \
858 : } \
859 : else \
860 : { \
861 : errno=0; \
862 : while ( (result = fread(buf, 1, (yy_size_t) max_size, replication_yyin)) == 0 && ferror(replication_yyin)) \
863 : { \
864 : if( errno != EINTR) \
865 : { \
866 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
867 : break; \
868 : } \
869 : errno=0; \
870 : clearerr(replication_yyin); \
871 : } \
872 : }\
873 : \
874 :
875 : #endif
876 :
877 : /* No semi-colon after return; correct usage is to write "yyterminate();" -
878 : * we don't want an extra ';' after the "return" because that will cause
879 : * some compilers to complain about unreachable statements.
880 : */
881 : #ifndef yyterminate
882 : #define yyterminate() return YY_NULL
883 : #endif
884 :
885 : /* Number of entries by which start-condition stack grows. */
886 : #ifndef YY_START_STACK_INCR
887 : #define YY_START_STACK_INCR 25
888 : #endif
889 :
890 : /* Report a fatal error. */
891 : #ifndef YY_FATAL_ERROR
892 : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
893 : #endif
894 :
895 : /* end tables serialization structures and prototypes */
896 :
897 : /* Default declaration of generated scanner - a define so the user can
898 : * easily add parameters.
899 : */
900 : #ifndef YY_DECL
901 : #define YY_DECL_IS_OURS 1
902 :
903 : extern int replication_yylex (void);
904 :
905 : #define YY_DECL int replication_yylex (void)
906 : #endif /* !YY_DECL */
907 :
908 : /* Code executed at the beginning of each rule, after replication_yytext and replication_yyleng
909 : * have been set up.
910 : */
911 : #ifndef YY_USER_ACTION
912 : #define YY_USER_ACTION
913 : #endif
914 :
915 : /* Code executed at the end of each rule. */
916 : #ifndef YY_BREAK
917 : #define YY_BREAK break;
918 : #endif
919 :
920 : #define YY_RULE_SETUP \
921 : YY_USER_ACTION
922 :
923 : /** The main scanner function which does all the work.
924 : */
925 0 : YY_DECL
926 : {
927 : register yy_state_type yy_current_state;
928 : register char *yy_cp, *yy_bp;
929 : register int yy_act;
930 :
931 0 : if ( !(yy_init) )
932 : {
933 0 : (yy_init) = 1;
934 :
935 : #ifdef YY_USER_INIT
936 : YY_USER_INIT;
937 : #endif
938 :
939 0 : if ( ! (yy_start) )
940 0 : (yy_start) = 1; /* first start state */
941 :
942 0 : if ( ! replication_yyin )
943 0 : replication_yyin = stdin;
944 :
945 0 : if ( ! replication_yyout )
946 0 : replication_yyout = stdout;
947 :
948 0 : if ( ! YY_CURRENT_BUFFER ) {
949 0 : replication_yyensure_buffer_stack ();
950 0 : YY_CURRENT_BUFFER_LVALUE =
951 0 : replication_yy_create_buffer(replication_yyin,YY_BUF_SIZE );
952 : }
953 :
954 0 : replication_yy_load_buffer_state( );
955 : }
956 :
957 : {
958 : #line 81 "repl_scanner.l"
959 :
960 :
961 : #line 962 "repl_scanner.c"
962 :
963 : while ( 1 ) /* loops until end-of-file is reached */
964 : {
965 0 : yy_cp = (yy_c_buf_p);
966 :
967 : /* Support of replication_yytext. */
968 0 : *yy_cp = (yy_hold_char);
969 :
970 : /* yy_bp points to the position in yy_ch_buf of the start of
971 : * the current run.
972 : */
973 0 : yy_bp = yy_cp;
974 :
975 0 : yy_current_state = (yy_start);
976 : yy_match:
977 : do
978 : {
979 0 : register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
980 0 : if ( yy_accept[yy_current_state] )
981 : {
982 0 : (yy_last_accepting_state) = yy_current_state;
983 0 : (yy_last_accepting_cpos) = yy_cp;
984 : }
985 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
986 : {
987 0 : yy_current_state = (int) yy_def[yy_current_state];
988 0 : if ( yy_current_state >= 267 )
989 0 : yy_c = yy_meta[(unsigned int) yy_c];
990 : }
991 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
992 0 : ++yy_cp;
993 : }
994 0 : while ( yy_current_state != 266 );
995 0 : yy_cp = (yy_last_accepting_cpos);
996 0 : yy_current_state = (yy_last_accepting_state);
997 :
998 : yy_find_action:
999 0 : yy_act = yy_accept[yy_current_state];
1000 :
1001 0 : YY_DO_BEFORE_ACTION;
1002 :
1003 : do_action: /* This label is used only to access EOF actions. */
1004 :
1005 0 : switch ( yy_act )
1006 : { /* beginning of action switch */
1007 : case 0: /* must back up */
1008 : /* undo the effects of YY_DO_BEFORE_ACTION */
1009 0 : *yy_cp = (yy_hold_char);
1010 0 : yy_cp = (yy_last_accepting_cpos);
1011 0 : yy_current_state = (yy_last_accepting_state);
1012 0 : goto yy_find_action;
1013 :
1014 : case 1:
1015 : YY_RULE_SETUP
1016 : #line 83 "repl_scanner.l"
1017 : { return K_BASE_BACKUP; }
1018 : YY_BREAK
1019 : case 2:
1020 : YY_RULE_SETUP
1021 : #line 84 "repl_scanner.l"
1022 : { return K_FAST; }
1023 : YY_BREAK
1024 : case 3:
1025 : YY_RULE_SETUP
1026 : #line 85 "repl_scanner.l"
1027 : { return K_IDENTIFY_SYSTEM; }
1028 : YY_BREAK
1029 : case 4:
1030 : YY_RULE_SETUP
1031 : #line 86 "repl_scanner.l"
1032 : { return K_SHOW; }
1033 : YY_BREAK
1034 : case 5:
1035 : YY_RULE_SETUP
1036 : #line 87 "repl_scanner.l"
1037 : { return K_LABEL; }
1038 : YY_BREAK
1039 : case 6:
1040 : YY_RULE_SETUP
1041 : #line 88 "repl_scanner.l"
1042 : { return K_NOWAIT; }
1043 : YY_BREAK
1044 : case 7:
1045 : YY_RULE_SETUP
1046 : #line 89 "repl_scanner.l"
1047 : { return K_PROGRESS; }
1048 : YY_BREAK
1049 : case 8:
1050 : YY_RULE_SETUP
1051 : #line 90 "repl_scanner.l"
1052 : { return K_MAX_RATE; }
1053 : YY_BREAK
1054 : case 9:
1055 : YY_RULE_SETUP
1056 : #line 91 "repl_scanner.l"
1057 : { return K_WAL; }
1058 : YY_BREAK
1059 : case 10:
1060 : YY_RULE_SETUP
1061 : #line 92 "repl_scanner.l"
1062 : { return K_TABLESPACE_MAP; }
1063 : YY_BREAK
1064 : case 11:
1065 : YY_RULE_SETUP
1066 : #line 93 "repl_scanner.l"
1067 : { return K_TIMELINE; }
1068 : YY_BREAK
1069 : case 12:
1070 : YY_RULE_SETUP
1071 : #line 94 "repl_scanner.l"
1072 : { return K_START_REPLICATION; }
1073 : YY_BREAK
1074 : case 13:
1075 : YY_RULE_SETUP
1076 : #line 95 "repl_scanner.l"
1077 : { return K_CREATE_REPLICATION_SLOT; }
1078 : YY_BREAK
1079 : case 14:
1080 : YY_RULE_SETUP
1081 : #line 96 "repl_scanner.l"
1082 : { return K_DROP_REPLICATION_SLOT; }
1083 : YY_BREAK
1084 : case 15:
1085 : YY_RULE_SETUP
1086 : #line 97 "repl_scanner.l"
1087 : { return K_TIMELINE_HISTORY; }
1088 : YY_BREAK
1089 : case 16:
1090 : YY_RULE_SETUP
1091 : #line 98 "repl_scanner.l"
1092 : { return K_PHYSICAL; }
1093 : YY_BREAK
1094 : case 17:
1095 : YY_RULE_SETUP
1096 : #line 99 "repl_scanner.l"
1097 : { return K_RESERVE_WAL; }
1098 : YY_BREAK
1099 : case 18:
1100 : YY_RULE_SETUP
1101 : #line 100 "repl_scanner.l"
1102 : { return K_LOGICAL; }
1103 : YY_BREAK
1104 : case 19:
1105 : YY_RULE_SETUP
1106 : #line 101 "repl_scanner.l"
1107 : { return K_SLOT; }
1108 : YY_BREAK
1109 : case 20:
1110 : YY_RULE_SETUP
1111 : #line 102 "repl_scanner.l"
1112 : { return K_TEMPORARY; }
1113 : YY_BREAK
1114 : case 21:
1115 : YY_RULE_SETUP
1116 : #line 103 "repl_scanner.l"
1117 : { return K_EXPORT_SNAPSHOT; }
1118 : YY_BREAK
1119 : case 22:
1120 : YY_RULE_SETUP
1121 : #line 104 "repl_scanner.l"
1122 : { return K_NOEXPORT_SNAPSHOT; }
1123 : YY_BREAK
1124 : case 23:
1125 : YY_RULE_SETUP
1126 : #line 105 "repl_scanner.l"
1127 : { return K_USE_SNAPSHOT; }
1128 : YY_BREAK
1129 : case 24:
1130 : YY_RULE_SETUP
1131 : #line 106 "repl_scanner.l"
1132 : { return K_WAIT; }
1133 : YY_BREAK
1134 : case 25:
1135 : YY_RULE_SETUP
1136 : #line 108 "repl_scanner.l"
1137 : { return ','; }
1138 : YY_BREAK
1139 : case 26:
1140 : YY_RULE_SETUP
1141 : #line 109 "repl_scanner.l"
1142 : { return ';'; }
1143 : YY_BREAK
1144 : case 27:
1145 : YY_RULE_SETUP
1146 : #line 110 "repl_scanner.l"
1147 : { return '('; }
1148 : YY_BREAK
1149 : case 28:
1150 : YY_RULE_SETUP
1151 : #line 111 "repl_scanner.l"
1152 : { return ')'; }
1153 : YY_BREAK
1154 : case 29:
1155 : /* rule 29 can match eol */
1156 : YY_RULE_SETUP
1157 : #line 113 "repl_scanner.l"
1158 : ;
1159 : YY_BREAK
1160 : case 30:
1161 : YY_RULE_SETUP
1162 : #line 114 "repl_scanner.l"
1163 : ;
1164 : YY_BREAK
1165 : case 31:
1166 : YY_RULE_SETUP
1167 : #line 115 "repl_scanner.l"
1168 : ;
1169 : YY_BREAK
1170 : case 32:
1171 : YY_RULE_SETUP
1172 : #line 117 "repl_scanner.l"
1173 : {
1174 : yylval.uintval = strtoul(replication_yytext, NULL, 10);
1175 : return UCONST;
1176 : }
1177 : YY_BREAK
1178 : case 33:
1179 : YY_RULE_SETUP
1180 : #line 122 "repl_scanner.l"
1181 : {
1182 : uint32 hi,
1183 : lo;
1184 : if (sscanf(replication_yytext, "%X/%X", &hi, &lo) != 2)
1185 : yyerror("invalid streaming start location");
1186 : yylval.recptr = ((uint64) hi) << 32 | lo;
1187 : return RECPTR;
1188 : }
1189 : YY_BREAK
1190 : case 34:
1191 : YY_RULE_SETUP
1192 : #line 131 "repl_scanner.l"
1193 : {
1194 : BEGIN(xq);
1195 : startlit();
1196 : }
1197 : YY_BREAK
1198 : case 35:
1199 : YY_RULE_SETUP
1200 : #line 136 "repl_scanner.l"
1201 : {
1202 : yyless(1);
1203 : BEGIN(INITIAL);
1204 : yylval.str = litbufdup();
1205 : return SCONST;
1206 : }
1207 : YY_BREAK
1208 : case 36:
1209 : YY_RULE_SETUP
1210 : #line 143 "repl_scanner.l"
1211 : {
1212 : addlitchar('\'');
1213 : }
1214 : YY_BREAK
1215 : case 37:
1216 : /* rule 37 can match eol */
1217 : YY_RULE_SETUP
1218 : #line 147 "repl_scanner.l"
1219 : {
1220 : addlit(replication_yytext, replication_yyleng);
1221 : }
1222 : YY_BREAK
1223 : case 38:
1224 : YY_RULE_SETUP
1225 : #line 151 "repl_scanner.l"
1226 : {
1227 : BEGIN(xd);
1228 : startlit();
1229 : }
1230 : YY_BREAK
1231 : case 39:
1232 : YY_RULE_SETUP
1233 : #line 156 "repl_scanner.l"
1234 : {
1235 : int len;
1236 : yyless(1);
1237 : BEGIN(INITIAL);
1238 : yylval.str = litbufdup();
1239 : len = strlen(yylval.str);
1240 : truncate_identifier(yylval.str, len, true);
1241 : return IDENT;
1242 : }
1243 : YY_BREAK
1244 : case 40:
1245 : /* rule 40 can match eol */
1246 : YY_RULE_SETUP
1247 : #line 166 "repl_scanner.l"
1248 : {
1249 : addlit(replication_yytext, replication_yyleng);
1250 : }
1251 : YY_BREAK
1252 : case 41:
1253 : YY_RULE_SETUP
1254 : #line 170 "repl_scanner.l"
1255 : {
1256 : int len = strlen(replication_yytext);
1257 :
1258 : yylval.str = downcase_truncate_identifier(replication_yytext, len, true);
1259 : return IDENT;
1260 : }
1261 : YY_BREAK
1262 : case YY_STATE_EOF(xq):
1263 : case YY_STATE_EOF(xd):
1264 : #line 177 "repl_scanner.l"
1265 : { yyerror("unterminated quoted string"); }
1266 : YY_BREAK
1267 : case YY_STATE_EOF(INITIAL):
1268 : #line 180 "repl_scanner.l"
1269 : {
1270 : yyterminate();
1271 : }
1272 : YY_BREAK
1273 : case 42:
1274 : YY_RULE_SETUP
1275 : #line 184 "repl_scanner.l"
1276 : {
1277 : return T_WORD;
1278 : }
1279 : YY_BREAK
1280 : case 43:
1281 : YY_RULE_SETUP
1282 : #line 187 "repl_scanner.l"
1283 : YY_FATAL_ERROR( "flex scanner jammed" );
1284 : YY_BREAK
1285 : #line 1286 "repl_scanner.c"
1286 :
1287 : case YY_END_OF_BUFFER:
1288 : {
1289 : /* Amount of text matched not including the EOB char. */
1290 0 : int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1291 :
1292 : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1293 0 : *yy_cp = (yy_hold_char);
1294 : YY_RESTORE_YY_MORE_OFFSET
1295 :
1296 0 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1297 : {
1298 : /* We're scanning a new file or input source. It's
1299 : * possible that this happened because the user
1300 : * just pointed replication_yyin at a new source and called
1301 : * replication_yylex(). If so, then we have to assure
1302 : * consistency between YY_CURRENT_BUFFER and our
1303 : * globals. Here is the right place to do so, because
1304 : * this is the first action (other than possibly a
1305 : * back-up) that will match for the new input source.
1306 : */
1307 0 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1308 0 : YY_CURRENT_BUFFER_LVALUE->yy_input_file = replication_yyin;
1309 0 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1310 : }
1311 :
1312 : /* Note that here we test for yy_c_buf_p "<=" to the position
1313 : * of the first EOB in the buffer, since yy_c_buf_p will
1314 : * already have been incremented past the NUL character
1315 : * (since all states make transitions on EOB to the
1316 : * end-of-buffer state). Contrast this with the test
1317 : * in input().
1318 : */
1319 0 : if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1320 : { /* This was really a NUL. */
1321 : yy_state_type yy_next_state;
1322 :
1323 0 : (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1324 :
1325 0 : yy_current_state = yy_get_previous_state( );
1326 :
1327 : /* Okay, we're now positioned to make the NUL
1328 : * transition. We couldn't have
1329 : * yy_get_previous_state() go ahead and do it
1330 : * for us because it doesn't know how to deal
1331 : * with the possibility of jamming (and we don't
1332 : * want to build jamming into it because then it
1333 : * will run more slowly).
1334 : */
1335 :
1336 0 : yy_next_state = yy_try_NUL_trans( yy_current_state );
1337 :
1338 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1339 :
1340 0 : if ( yy_next_state )
1341 : {
1342 : /* Consume the NUL. */
1343 0 : yy_cp = ++(yy_c_buf_p);
1344 0 : yy_current_state = yy_next_state;
1345 0 : goto yy_match;
1346 : }
1347 :
1348 : else
1349 : {
1350 0 : yy_cp = (yy_last_accepting_cpos);
1351 0 : yy_current_state = (yy_last_accepting_state);
1352 0 : goto yy_find_action;
1353 : }
1354 : }
1355 :
1356 0 : else switch ( yy_get_next_buffer( ) )
1357 : {
1358 : case EOB_ACT_END_OF_FILE:
1359 : {
1360 0 : (yy_did_buffer_switch_on_eof) = 0;
1361 :
1362 : if ( replication_yywrap( ) )
1363 : {
1364 : /* Note: because we've taken care in
1365 : * yy_get_next_buffer() to have set up
1366 : * replication_yytext, we can now set up
1367 : * yy_c_buf_p so that if some total
1368 : * hoser (like flex itself) wants to
1369 : * call the scanner after we return the
1370 : * YY_NULL, it'll still work - another
1371 : * YY_NULL will get returned.
1372 : */
1373 0 : (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1374 :
1375 0 : yy_act = YY_STATE_EOF(YY_START);
1376 0 : goto do_action;
1377 : }
1378 :
1379 : else
1380 : {
1381 : if ( ! (yy_did_buffer_switch_on_eof) )
1382 : YY_NEW_FILE;
1383 : }
1384 : break;
1385 : }
1386 :
1387 : case EOB_ACT_CONTINUE_SCAN:
1388 0 : (yy_c_buf_p) =
1389 0 : (yytext_ptr) + yy_amount_of_matched_text;
1390 :
1391 0 : yy_current_state = yy_get_previous_state( );
1392 :
1393 0 : yy_cp = (yy_c_buf_p);
1394 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1395 0 : goto yy_match;
1396 :
1397 : case EOB_ACT_LAST_MATCH:
1398 0 : (yy_c_buf_p) =
1399 0 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1400 :
1401 0 : yy_current_state = yy_get_previous_state( );
1402 :
1403 0 : yy_cp = (yy_c_buf_p);
1404 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1405 0 : goto yy_find_action;
1406 : }
1407 0 : break;
1408 : }
1409 :
1410 : default:
1411 0 : YY_FATAL_ERROR(
1412 : "fatal flex scanner internal error--no action found" );
1413 : } /* end of action switch */
1414 0 : } /* end of scanning one token */
1415 : } /* end of user's declarations */
1416 : } /* end of replication_yylex */
1417 :
1418 : /* yy_get_next_buffer - try to read in a new buffer
1419 : *
1420 : * Returns a code representing an action:
1421 : * EOB_ACT_LAST_MATCH -
1422 : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1423 : * EOB_ACT_END_OF_FILE - end of file
1424 : */
1425 0 : static int yy_get_next_buffer (void)
1426 : {
1427 0 : register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1428 0 : register char *source = (yytext_ptr);
1429 : register int number_to_move, i;
1430 : int ret_val;
1431 :
1432 0 : if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1433 0 : YY_FATAL_ERROR(
1434 : "fatal flex scanner internal error--end of buffer missed" );
1435 :
1436 0 : if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1437 : { /* Don't try to fill the buffer, so this is an EOF. */
1438 0 : if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1439 : {
1440 : /* We matched a single character, the EOB, so
1441 : * treat this as a final EOF.
1442 : */
1443 0 : return EOB_ACT_END_OF_FILE;
1444 : }
1445 :
1446 : else
1447 : {
1448 : /* We matched some text prior to the EOB, first
1449 : * process it.
1450 : */
1451 0 : return EOB_ACT_LAST_MATCH;
1452 : }
1453 : }
1454 :
1455 : /* Try to read more data. */
1456 :
1457 : /* First move last chars to start of buffer. */
1458 0 : number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1459 :
1460 0 : for ( i = 0; i < number_to_move; ++i )
1461 0 : *(dest++) = *(source++);
1462 :
1463 0 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1464 : /* don't do the read, it's not guaranteed to return an EOF,
1465 : * just force an EOF
1466 : */
1467 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1468 :
1469 : else
1470 : {
1471 0 : int num_to_read =
1472 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1473 :
1474 0 : while ( num_to_read <= 0 )
1475 : { /* Not enough room in the buffer - grow it. */
1476 :
1477 : /* just a shorter name for the current buffer */
1478 0 : YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1479 :
1480 0 : int yy_c_buf_p_offset =
1481 0 : (int) ((yy_c_buf_p) - b->yy_ch_buf);
1482 :
1483 0 : if ( b->yy_is_our_buffer )
1484 : {
1485 0 : yy_size_t new_size = b->yy_buf_size * 2;
1486 :
1487 0 : if ( new_size <= 0 )
1488 0 : b->yy_buf_size += b->yy_buf_size / 8;
1489 : else
1490 0 : b->yy_buf_size *= 2;
1491 :
1492 0 : b->yy_ch_buf = (char *)
1493 : /* Include room in for 2 EOB chars. */
1494 0 : replication_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1495 : }
1496 : else
1497 : /* Can't grow it, we don't own it. */
1498 0 : b->yy_ch_buf = 0;
1499 :
1500 0 : if ( ! b->yy_ch_buf )
1501 0 : YY_FATAL_ERROR(
1502 : "fatal error - scanner input buffer overflow" );
1503 :
1504 0 : (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1505 :
1506 0 : num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1507 0 : number_to_move - 1;
1508 :
1509 : }
1510 :
1511 0 : if ( num_to_read > YY_READ_BUF_SIZE )
1512 0 : num_to_read = YY_READ_BUF_SIZE;
1513 :
1514 : /* Read in more data. */
1515 0 : YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1516 : (yy_n_chars), num_to_read );
1517 :
1518 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1519 : }
1520 :
1521 0 : if ( (yy_n_chars) == 0 )
1522 : {
1523 0 : if ( number_to_move == YY_MORE_ADJ )
1524 : {
1525 0 : ret_val = EOB_ACT_END_OF_FILE;
1526 0 : replication_yyrestart(replication_yyin );
1527 : }
1528 :
1529 : else
1530 : {
1531 0 : ret_val = EOB_ACT_LAST_MATCH;
1532 0 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1533 : YY_BUFFER_EOF_PENDING;
1534 : }
1535 : }
1536 :
1537 : else
1538 0 : ret_val = EOB_ACT_CONTINUE_SCAN;
1539 :
1540 0 : if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1541 : /* Extend the array by 50%, plus the number we really need. */
1542 0 : yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1543 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) replication_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1544 0 : if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1545 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1546 : }
1547 :
1548 0 : (yy_n_chars) += number_to_move;
1549 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1550 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1551 :
1552 0 : (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1553 :
1554 0 : return ret_val;
1555 : }
1556 :
1557 : /* yy_get_previous_state - get the state just before the EOB char was reached */
1558 :
1559 0 : static yy_state_type yy_get_previous_state (void)
1560 : {
1561 : register yy_state_type yy_current_state;
1562 : register char *yy_cp;
1563 :
1564 0 : yy_current_state = (yy_start);
1565 :
1566 0 : for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1567 : {
1568 0 : register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1569 0 : if ( yy_accept[yy_current_state] )
1570 : {
1571 0 : (yy_last_accepting_state) = yy_current_state;
1572 0 : (yy_last_accepting_cpos) = yy_cp;
1573 : }
1574 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1575 : {
1576 0 : yy_current_state = (int) yy_def[yy_current_state];
1577 0 : if ( yy_current_state >= 267 )
1578 0 : yy_c = yy_meta[(unsigned int) yy_c];
1579 : }
1580 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1581 : }
1582 :
1583 0 : return yy_current_state;
1584 : }
1585 :
1586 : /* yy_try_NUL_trans - try to make a transition on the NUL character
1587 : *
1588 : * synopsis
1589 : * next_state = yy_try_NUL_trans( current_state );
1590 : */
1591 0 : static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1592 : {
1593 : register int yy_is_jam;
1594 0 : register char *yy_cp = (yy_c_buf_p);
1595 :
1596 0 : register YY_CHAR yy_c = 1;
1597 0 : if ( yy_accept[yy_current_state] )
1598 : {
1599 0 : (yy_last_accepting_state) = yy_current_state;
1600 0 : (yy_last_accepting_cpos) = yy_cp;
1601 : }
1602 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1603 : {
1604 0 : yy_current_state = (int) yy_def[yy_current_state];
1605 0 : if ( yy_current_state >= 267 )
1606 0 : yy_c = yy_meta[(unsigned int) yy_c];
1607 : }
1608 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1609 0 : yy_is_jam = (yy_current_state == 266);
1610 :
1611 0 : return yy_is_jam ? 0 : yy_current_state;
1612 : }
1613 :
1614 : #ifndef YY_NO_INPUT
1615 : #ifdef __cplusplus
1616 : static int yyinput (void)
1617 : #else
1618 : static int input (void)
1619 : #endif
1620 :
1621 : {
1622 : int c;
1623 :
1624 : *(yy_c_buf_p) = (yy_hold_char);
1625 :
1626 : if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1627 : {
1628 : /* yy_c_buf_p now points to the character we want to return.
1629 : * If this occurs *before* the EOB characters, then it's a
1630 : * valid NUL; if not, then we've hit the end of the buffer.
1631 : */
1632 : if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1633 : /* This was really a NUL. */
1634 : *(yy_c_buf_p) = '\0';
1635 :
1636 : else
1637 : { /* need more input */
1638 : yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1639 : ++(yy_c_buf_p);
1640 :
1641 : switch ( yy_get_next_buffer( ) )
1642 : {
1643 : case EOB_ACT_LAST_MATCH:
1644 : /* This happens because yy_g_n_b()
1645 : * sees that we've accumulated a
1646 : * token and flags that we need to
1647 : * try matching the token before
1648 : * proceeding. But for input(),
1649 : * there's no matching to consider.
1650 : * So convert the EOB_ACT_LAST_MATCH
1651 : * to EOB_ACT_END_OF_FILE.
1652 : */
1653 :
1654 : /* Reset buffer status. */
1655 : replication_yyrestart(replication_yyin );
1656 :
1657 : /*FALLTHROUGH*/
1658 :
1659 : case EOB_ACT_END_OF_FILE:
1660 : {
1661 : if ( replication_yywrap( ) )
1662 : return EOF;
1663 :
1664 : if ( ! (yy_did_buffer_switch_on_eof) )
1665 : YY_NEW_FILE;
1666 : #ifdef __cplusplus
1667 : return yyinput();
1668 : #else
1669 : return input();
1670 : #endif
1671 : }
1672 :
1673 : case EOB_ACT_CONTINUE_SCAN:
1674 : (yy_c_buf_p) = (yytext_ptr) + offset;
1675 : break;
1676 : }
1677 : }
1678 : }
1679 :
1680 : c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1681 : *(yy_c_buf_p) = '\0'; /* preserve replication_yytext */
1682 : (yy_hold_char) = *++(yy_c_buf_p);
1683 :
1684 : return c;
1685 : }
1686 : #endif /* ifndef YY_NO_INPUT */
1687 :
1688 : /** Immediately switch to a different input stream.
1689 : * @param input_file A readable stream.
1690 : *
1691 : * @note This function does not reset the start condition to @c INITIAL .
1692 : */
1693 0 : void replication_yyrestart (FILE * input_file )
1694 : {
1695 :
1696 0 : if ( ! YY_CURRENT_BUFFER ){
1697 0 : replication_yyensure_buffer_stack ();
1698 0 : YY_CURRENT_BUFFER_LVALUE =
1699 0 : replication_yy_create_buffer(replication_yyin,YY_BUF_SIZE );
1700 : }
1701 :
1702 0 : replication_yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1703 0 : replication_yy_load_buffer_state( );
1704 0 : }
1705 :
1706 : /** Switch to a different input buffer.
1707 : * @param new_buffer The new input buffer.
1708 : *
1709 : */
1710 0 : void replication_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1711 : {
1712 :
1713 : /* TODO. We should be able to replace this entire function body
1714 : * with
1715 : * replication_yypop_buffer_state();
1716 : * replication_yypush_buffer_state(new_buffer);
1717 : */
1718 0 : replication_yyensure_buffer_stack ();
1719 0 : if ( YY_CURRENT_BUFFER == new_buffer )
1720 0 : return;
1721 :
1722 0 : if ( YY_CURRENT_BUFFER )
1723 : {
1724 : /* Flush out information for old buffer. */
1725 0 : *(yy_c_buf_p) = (yy_hold_char);
1726 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1727 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1728 : }
1729 :
1730 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1731 0 : replication_yy_load_buffer_state( );
1732 :
1733 : /* We don't actually know whether we did this switch during
1734 : * EOF (replication_yywrap()) processing, but the only time this flag
1735 : * is looked at is after replication_yywrap() is called, so it's safe
1736 : * to go ahead and always set it.
1737 : */
1738 0 : (yy_did_buffer_switch_on_eof) = 1;
1739 : }
1740 :
1741 0 : static void replication_yy_load_buffer_state (void)
1742 : {
1743 0 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1744 0 : (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1745 0 : replication_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1746 0 : (yy_hold_char) = *(yy_c_buf_p);
1747 0 : }
1748 :
1749 : /** Allocate and initialize an input buffer state.
1750 : * @param file A readable stream.
1751 : * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1752 : *
1753 : * @return the allocated buffer state.
1754 : */
1755 0 : YY_BUFFER_STATE replication_yy_create_buffer (FILE * file, int size )
1756 : {
1757 : YY_BUFFER_STATE b;
1758 :
1759 0 : b = (YY_BUFFER_STATE) replication_yyalloc(sizeof( struct yy_buffer_state ) );
1760 0 : if ( ! b )
1761 0 : YY_FATAL_ERROR( "out of dynamic memory in replication_yy_create_buffer()" );
1762 :
1763 0 : b->yy_buf_size = size;
1764 :
1765 : /* yy_ch_buf has to be 2 characters longer than the size given because
1766 : * we need to put in 2 end-of-buffer characters.
1767 : */
1768 0 : b->yy_ch_buf = (char *) replication_yyalloc(b->yy_buf_size + 2 );
1769 0 : if ( ! b->yy_ch_buf )
1770 0 : YY_FATAL_ERROR( "out of dynamic memory in replication_yy_create_buffer()" );
1771 :
1772 0 : b->yy_is_our_buffer = 1;
1773 :
1774 0 : replication_yy_init_buffer(b,file );
1775 :
1776 0 : return b;
1777 : }
1778 :
1779 : /** Destroy the buffer.
1780 : * @param b a buffer created with replication_yy_create_buffer()
1781 : *
1782 : */
1783 0 : void replication_yy_delete_buffer (YY_BUFFER_STATE b )
1784 : {
1785 :
1786 0 : if ( ! b )
1787 0 : return;
1788 :
1789 0 : if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1790 0 : YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1791 :
1792 0 : if ( b->yy_is_our_buffer )
1793 0 : replication_yyfree((void *) b->yy_ch_buf );
1794 :
1795 0 : replication_yyfree((void *) b );
1796 : }
1797 :
1798 : /* Initializes or reinitializes a buffer.
1799 : * This function is sometimes called more than once on the same buffer,
1800 : * such as during a replication_yyrestart() or at EOF.
1801 : */
1802 0 : static void replication_yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1803 :
1804 : {
1805 0 : int oerrno = errno;
1806 :
1807 0 : replication_yy_flush_buffer(b );
1808 :
1809 0 : b->yy_input_file = file;
1810 0 : b->yy_fill_buffer = 1;
1811 :
1812 : /* If b is the current buffer, then replication_yy_init_buffer was _probably_
1813 : * called from replication_yyrestart() or through yy_get_next_buffer.
1814 : * In that case, we don't want to reset the lineno or column.
1815 : */
1816 0 : if (b != YY_CURRENT_BUFFER){
1817 0 : b->yy_bs_lineno = 1;
1818 0 : b->yy_bs_column = 0;
1819 : }
1820 :
1821 0 : b->yy_is_interactive = 0;
1822 :
1823 0 : errno = oerrno;
1824 0 : }
1825 :
1826 : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1827 : * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1828 : *
1829 : */
1830 0 : void replication_yy_flush_buffer (YY_BUFFER_STATE b )
1831 : {
1832 0 : if ( ! b )
1833 0 : return;
1834 :
1835 0 : b->yy_n_chars = 0;
1836 :
1837 : /* We always need two end-of-buffer characters. The first causes
1838 : * a transition to the end-of-buffer state. The second causes
1839 : * a jam in that state.
1840 : */
1841 0 : b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1842 0 : b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1843 :
1844 0 : b->yy_buf_pos = &b->yy_ch_buf[0];
1845 :
1846 0 : b->yy_at_bol = 1;
1847 0 : b->yy_buffer_status = YY_BUFFER_NEW;
1848 :
1849 0 : if ( b == YY_CURRENT_BUFFER )
1850 0 : replication_yy_load_buffer_state( );
1851 : }
1852 :
1853 : /** Pushes the new state onto the stack. The new state becomes
1854 : * the current state. This function will allocate the stack
1855 : * if necessary.
1856 : * @param new_buffer The new state.
1857 : *
1858 : */
1859 0 : void replication_yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1860 : {
1861 0 : if (new_buffer == NULL)
1862 0 : return;
1863 :
1864 0 : replication_yyensure_buffer_stack();
1865 :
1866 : /* This block is copied from replication_yy_switch_to_buffer. */
1867 0 : if ( YY_CURRENT_BUFFER )
1868 : {
1869 : /* Flush out information for old buffer. */
1870 0 : *(yy_c_buf_p) = (yy_hold_char);
1871 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1872 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1873 : }
1874 :
1875 : /* Only push if top exists. Otherwise, replace top. */
1876 0 : if (YY_CURRENT_BUFFER)
1877 0 : (yy_buffer_stack_top)++;
1878 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1879 :
1880 : /* copied from replication_yy_switch_to_buffer. */
1881 0 : replication_yy_load_buffer_state( );
1882 0 : (yy_did_buffer_switch_on_eof) = 1;
1883 : }
1884 :
1885 : /** Removes and deletes the top of the stack, if present.
1886 : * The next element becomes the new top.
1887 : *
1888 : */
1889 0 : void replication_yypop_buffer_state (void)
1890 : {
1891 0 : if (!YY_CURRENT_BUFFER)
1892 0 : return;
1893 :
1894 0 : replication_yy_delete_buffer(YY_CURRENT_BUFFER );
1895 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
1896 0 : if ((yy_buffer_stack_top) > 0)
1897 0 : --(yy_buffer_stack_top);
1898 :
1899 0 : if (YY_CURRENT_BUFFER) {
1900 0 : replication_yy_load_buffer_state( );
1901 0 : (yy_did_buffer_switch_on_eof) = 1;
1902 : }
1903 : }
1904 :
1905 : /* Allocates the stack if it does not exist.
1906 : * Guarantees space for at least one push.
1907 : */
1908 0 : static void replication_yyensure_buffer_stack (void)
1909 : {
1910 : yy_size_t num_to_alloc;
1911 :
1912 0 : if (!(yy_buffer_stack)) {
1913 :
1914 : /* First allocation is just for 2 elements, since we don't know if this
1915 : * scanner will even need a stack. We use 2 instead of 1 to avoid an
1916 : * immediate realloc on the next call.
1917 : */
1918 0 : num_to_alloc = 1;
1919 0 : (yy_buffer_stack) = (struct yy_buffer_state**)replication_yyalloc
1920 : (num_to_alloc * sizeof(struct yy_buffer_state*)
1921 : );
1922 0 : if ( ! (yy_buffer_stack) )
1923 0 : YY_FATAL_ERROR( "out of dynamic memory in replication_yyensure_buffer_stack()" );
1924 :
1925 0 : memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1926 :
1927 0 : (yy_buffer_stack_max) = num_to_alloc;
1928 0 : (yy_buffer_stack_top) = 0;
1929 0 : return;
1930 : }
1931 :
1932 0 : if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1933 :
1934 : /* Increase the buffer to prepare for a possible push. */
1935 0 : int grow_size = 8 /* arbitrary grow size */;
1936 :
1937 0 : num_to_alloc = (yy_buffer_stack_max) + grow_size;
1938 0 : (yy_buffer_stack) = (struct yy_buffer_state**)replication_yyrealloc
1939 : ((yy_buffer_stack),
1940 : num_to_alloc * sizeof(struct yy_buffer_state*)
1941 : );
1942 0 : if ( ! (yy_buffer_stack) )
1943 0 : YY_FATAL_ERROR( "out of dynamic memory in replication_yyensure_buffer_stack()" );
1944 :
1945 : /* zero only the new slots.*/
1946 0 : memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1947 0 : (yy_buffer_stack_max) = num_to_alloc;
1948 : }
1949 : }
1950 :
1951 : /** Setup the input buffer state to scan directly from a user-specified character buffer.
1952 : * @param base the character buffer
1953 : * @param size the size in bytes of the character buffer
1954 : *
1955 : * @return the newly allocated buffer state object.
1956 : */
1957 0 : YY_BUFFER_STATE replication_yy_scan_buffer (char * base, yy_size_t size )
1958 : {
1959 : YY_BUFFER_STATE b;
1960 :
1961 0 : if ( size < 2 ||
1962 0 : base[size-2] != YY_END_OF_BUFFER_CHAR ||
1963 0 : base[size-1] != YY_END_OF_BUFFER_CHAR )
1964 : /* They forgot to leave room for the EOB's. */
1965 0 : return 0;
1966 :
1967 0 : b = (YY_BUFFER_STATE) replication_yyalloc(sizeof( struct yy_buffer_state ) );
1968 0 : if ( ! b )
1969 0 : YY_FATAL_ERROR( "out of dynamic memory in replication_yy_scan_buffer()" );
1970 :
1971 0 : b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1972 0 : b->yy_buf_pos = b->yy_ch_buf = base;
1973 0 : b->yy_is_our_buffer = 0;
1974 0 : b->yy_input_file = 0;
1975 0 : b->yy_n_chars = b->yy_buf_size;
1976 0 : b->yy_is_interactive = 0;
1977 0 : b->yy_at_bol = 1;
1978 0 : b->yy_fill_buffer = 0;
1979 0 : b->yy_buffer_status = YY_BUFFER_NEW;
1980 :
1981 0 : replication_yy_switch_to_buffer(b );
1982 :
1983 0 : return b;
1984 : }
1985 :
1986 : /** Setup the input buffer state to scan a string. The next call to replication_yylex() will
1987 : * scan from a @e copy of @a str.
1988 : * @param yystr a NUL-terminated string to scan
1989 : *
1990 : * @return the newly allocated buffer state object.
1991 : * @note If you want to scan bytes that may contain NUL values, then use
1992 : * replication_yy_scan_bytes() instead.
1993 : */
1994 0 : YY_BUFFER_STATE replication_yy_scan_string (yyconst char * yystr )
1995 : {
1996 :
1997 0 : return replication_yy_scan_bytes(yystr,strlen(yystr) );
1998 : }
1999 :
2000 : /** Setup the input buffer state to scan the given bytes. The next call to replication_yylex() will
2001 : * scan from a @e copy of @a bytes.
2002 : * @param yybytes the byte buffer to scan
2003 : * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2004 : *
2005 : * @return the newly allocated buffer state object.
2006 : */
2007 0 : YY_BUFFER_STATE replication_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
2008 : {
2009 : YY_BUFFER_STATE b;
2010 : char *buf;
2011 : yy_size_t n;
2012 : yy_size_t i;
2013 :
2014 : /* Get memory for full buffer, including space for trailing EOB's. */
2015 0 : n = _yybytes_len + 2;
2016 0 : buf = (char *) replication_yyalloc(n );
2017 0 : if ( ! buf )
2018 0 : YY_FATAL_ERROR( "out of dynamic memory in replication_yy_scan_bytes()" );
2019 :
2020 0 : for ( i = 0; i < _yybytes_len; ++i )
2021 0 : buf[i] = yybytes[i];
2022 :
2023 0 : buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2024 :
2025 0 : b = replication_yy_scan_buffer(buf,n );
2026 0 : if ( ! b )
2027 0 : YY_FATAL_ERROR( "bad buffer in replication_yy_scan_bytes()" );
2028 :
2029 : /* It's okay to grow etc. this buffer, and we should throw it
2030 : * away when we're done.
2031 : */
2032 0 : b->yy_is_our_buffer = 1;
2033 :
2034 0 : return b;
2035 : }
2036 :
2037 : #ifndef YY_EXIT_FAILURE
2038 : #define YY_EXIT_FAILURE 2
2039 : #endif
2040 :
2041 0 : static void yy_fatal_error (yyconst char* msg )
2042 : {
2043 0 : (void) fprintf( stderr, "%s\n", msg );
2044 0 : exit( YY_EXIT_FAILURE );
2045 : }
2046 :
2047 : /* Redefine yyless() so it works in section 3 code. */
2048 :
2049 : #undef yyless
2050 : #define yyless(n) \
2051 : do \
2052 : { \
2053 : /* Undo effects of setting up replication_yytext. */ \
2054 : int yyless_macro_arg = (n); \
2055 : YY_LESS_LINENO(yyless_macro_arg);\
2056 : replication_yytext[replication_yyleng] = (yy_hold_char); \
2057 : (yy_c_buf_p) = replication_yytext + yyless_macro_arg; \
2058 : (yy_hold_char) = *(yy_c_buf_p); \
2059 : *(yy_c_buf_p) = '\0'; \
2060 : replication_yyleng = yyless_macro_arg; \
2061 : } \
2062 : while ( 0 )
2063 :
2064 : /* Accessor methods (get/set functions) to struct members. */
2065 :
2066 : /** Get the current line number.
2067 : *
2068 : */
2069 0 : int replication_yyget_lineno (void)
2070 : {
2071 :
2072 0 : return replication_yylineno;
2073 : }
2074 :
2075 : /** Get the input stream.
2076 : *
2077 : */
2078 0 : FILE *replication_yyget_in (void)
2079 : {
2080 0 : return replication_yyin;
2081 : }
2082 :
2083 : /** Get the output stream.
2084 : *
2085 : */
2086 0 : FILE *replication_yyget_out (void)
2087 : {
2088 0 : return replication_yyout;
2089 : }
2090 :
2091 : /** Get the length of the current token.
2092 : *
2093 : */
2094 0 : yy_size_t replication_yyget_leng (void)
2095 : {
2096 0 : return replication_yyleng;
2097 : }
2098 :
2099 : /** Get the current token.
2100 : *
2101 : */
2102 :
2103 0 : char *replication_yyget_text (void)
2104 : {
2105 0 : return replication_yytext;
2106 : }
2107 :
2108 : /** Set the current line number.
2109 : * @param line_number
2110 : *
2111 : */
2112 0 : void replication_yyset_lineno (int line_number )
2113 : {
2114 :
2115 0 : replication_yylineno = line_number;
2116 0 : }
2117 :
2118 : /** Set the input stream. This does not discard the current
2119 : * input buffer.
2120 : * @param in_str A readable stream.
2121 : *
2122 : * @see replication_yy_switch_to_buffer
2123 : */
2124 0 : void replication_yyset_in (FILE * in_str )
2125 : {
2126 0 : replication_yyin = in_str ;
2127 0 : }
2128 :
2129 0 : void replication_yyset_out (FILE * out_str )
2130 : {
2131 0 : replication_yyout = out_str ;
2132 0 : }
2133 :
2134 0 : int replication_yyget_debug (void)
2135 : {
2136 0 : return replication_yy_flex_debug;
2137 : }
2138 :
2139 0 : void replication_yyset_debug (int bdebug )
2140 : {
2141 0 : replication_yy_flex_debug = bdebug ;
2142 0 : }
2143 :
2144 0 : static int yy_init_globals (void)
2145 : {
2146 : /* Initialization is the same as for the non-reentrant scanner.
2147 : * This function is called from replication_yylex_destroy(), so don't allocate here.
2148 : */
2149 :
2150 0 : (yy_buffer_stack) = 0;
2151 0 : (yy_buffer_stack_top) = 0;
2152 0 : (yy_buffer_stack_max) = 0;
2153 0 : (yy_c_buf_p) = (char *) 0;
2154 0 : (yy_init) = 0;
2155 0 : (yy_start) = 0;
2156 :
2157 : /* Defined in main.c */
2158 : #ifdef YY_STDINIT
2159 : replication_yyin = stdin;
2160 : replication_yyout = stdout;
2161 : #else
2162 0 : replication_yyin = (FILE *) 0;
2163 0 : replication_yyout = (FILE *) 0;
2164 : #endif
2165 :
2166 : /* For future reference: Set errno on error, since we are called by
2167 : * replication_yylex_init()
2168 : */
2169 0 : return 0;
2170 : }
2171 :
2172 : /* replication_yylex_destroy is for both reentrant and non-reentrant scanners. */
2173 0 : int replication_yylex_destroy (void)
2174 : {
2175 :
2176 : /* Pop the buffer stack, destroying each element. */
2177 0 : while(YY_CURRENT_BUFFER){
2178 0 : replication_yy_delete_buffer(YY_CURRENT_BUFFER );
2179 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2180 0 : replication_yypop_buffer_state();
2181 : }
2182 :
2183 : /* Destroy the stack itself. */
2184 0 : replication_yyfree((yy_buffer_stack) );
2185 0 : (yy_buffer_stack) = NULL;
2186 :
2187 : /* Reset the globals. This is important in a non-reentrant scanner so the next time
2188 : * replication_yylex() is called, initialization will occur. */
2189 0 : yy_init_globals( );
2190 :
2191 0 : return 0;
2192 : }
2193 :
2194 : /*
2195 : * Internal utility routines.
2196 : */
2197 :
2198 : #ifndef yytext_ptr
2199 : static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2200 : {
2201 : register int i;
2202 : for ( i = 0; i < n; ++i )
2203 : s1[i] = s2[i];
2204 : }
2205 : #endif
2206 :
2207 : #ifdef YY_NEED_STRLEN
2208 : static int yy_flex_strlen (yyconst char * s )
2209 : {
2210 : register int n;
2211 : for ( n = 0; s[n]; ++n )
2212 : ;
2213 :
2214 : return n;
2215 : }
2216 : #endif
2217 :
2218 0 : void *replication_yyalloc (yy_size_t size )
2219 : {
2220 0 : return (void *) malloc( size );
2221 : }
2222 :
2223 0 : void *replication_yyrealloc (void * ptr, yy_size_t size )
2224 : {
2225 : /* The cast to (char *) in the following accommodates both
2226 : * implementations that use char* generic pointers, and those
2227 : * that use void* generic pointers. It works with the latter
2228 : * because both ANSI C and C++ allow castless assignment from
2229 : * any pointer type to void*, and deal with argument conversions
2230 : * as though doing an assignment.
2231 : */
2232 0 : return (void *) realloc( (char *) ptr, size );
2233 : }
2234 :
2235 0 : void replication_yyfree (void * ptr )
2236 : {
2237 0 : free( (char *) ptr ); /* see replication_yyrealloc() for (char *) cast */
2238 0 : }
2239 :
2240 : #define YYTABLES_NAME "yytables"
2241 :
2242 : #line 186 "repl_scanner.l"
2243 :
2244 :
2245 :
2246 :
2247 : static void
2248 : startlit(void)
2249 : {
2250 : initStringInfo(&litbuf);
2251 : }
2252 :
2253 : static char *
2254 : litbufdup(void)
2255 : {
2256 : return litbuf.data;
2257 : }
2258 :
2259 : static void
2260 : addlit(char *ytext, int yleng)
2261 : {
2262 : appendBinaryStringInfo(&litbuf, ytext, yleng);
2263 : }
2264 :
2265 : static void
2266 : addlitchar(unsigned char ychar)
2267 : {
2268 : appendStringInfoChar(&litbuf, ychar);
2269 : }
2270 :
2271 : void
2272 : yyerror(const char *message)
2273 : {
2274 : ereport(ERROR,
2275 : (errcode(ERRCODE_SYNTAX_ERROR),
2276 : errmsg_internal("%s", message)));
2277 : }
2278 :
2279 :
2280 : void
2281 : replication_scanner_init(const char *str)
2282 : {
2283 : Size slen = strlen(str);
2284 : char *scanbuf;
2285 :
2286 : /*
2287 : * Might be left over after ereport()
2288 : */
2289 : if (YY_CURRENT_BUFFER)
2290 : replication_yy_delete_buffer(YY_CURRENT_BUFFER);
2291 :
2292 : /*
2293 : * Make a scan buffer with special termination needed by flex.
2294 : */
2295 : scanbuf = (char *) palloc(slen + 2);
2296 : memcpy(scanbuf, str, slen);
2297 : scanbuf[slen] = scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
2298 : scanbufhandle = replication_yy_scan_buffer(scanbuf,slen + 2);
2299 : }
2300 :
2301 : void
2302 : replication_scanner_finish(void)
2303 : {
2304 : replication_yy_delete_buffer(scanbufhandle);
2305 : scanbufhandle = NULL;
2306 : }
2307 :
|
