Line data Source code
1 : #line 2 "bootscanner.c"
2 :
3 : #line 4 "bootscanner.c"
4 :
5 : #define YY_INT_ALIGNED short int
6 :
7 : /* A lexical scanner generated by flex */
8 :
9 : #define yy_create_buffer boot_yy_create_buffer
10 : #define yy_delete_buffer boot_yy_delete_buffer
11 : #define yy_flex_debug boot_yy_flex_debug
12 : #define yy_init_buffer boot_yy_init_buffer
13 : #define yy_flush_buffer boot_yy_flush_buffer
14 : #define yy_load_buffer_state boot_yy_load_buffer_state
15 : #define yy_switch_to_buffer boot_yy_switch_to_buffer
16 : #define yyin boot_yyin
17 : #define yyleng boot_yyleng
18 : #define yylex boot_yylex
19 : #define yylineno boot_yylineno
20 : #define yyout boot_yyout
21 : #define yyrestart boot_yyrestart
22 : #define yytext boot_yytext
23 : #define yywrap boot_yywrap
24 : #define yyalloc boot_yyalloc
25 : #define yyrealloc boot_yyrealloc
26 : #define yyfree boot_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 boot_yyrestart(boot_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 boot_yyleng;
190 :
191 : extern FILE *boot_yyin, *boot_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 boot_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 boot_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 boot_yyrestart()), so that the user can continue scanning by
274 : * just pointing boot_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 boot_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 boot_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 boot_yywrap()'s to do buffer switches
312 : * instead of setting up a fresh boot_yyin. A bit of a hack ...
313 : */
314 : static int yy_did_buffer_switch_on_eof;
315 :
316 : void boot_yyrestart (FILE *input_file );
317 : void boot_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
318 : YY_BUFFER_STATE boot_yy_create_buffer (FILE *file,int size );
319 : void boot_yy_delete_buffer (YY_BUFFER_STATE b );
320 : void boot_yy_flush_buffer (YY_BUFFER_STATE b );
321 : void boot_yypush_buffer_state (YY_BUFFER_STATE new_buffer );
322 : void boot_yypop_buffer_state (void );
323 :
324 : static void boot_yyensure_buffer_stack (void );
325 : static void boot_yy_load_buffer_state (void );
326 : static void boot_yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
327 :
328 : #define YY_FLUSH_BUFFER boot_yy_flush_buffer(YY_CURRENT_BUFFER )
329 :
330 : YY_BUFFER_STATE boot_yy_scan_buffer (char *base,yy_size_t size );
331 : YY_BUFFER_STATE boot_yy_scan_string (yyconst char *yy_str );
332 : YY_BUFFER_STATE boot_yy_scan_bytes (yyconst char *bytes,yy_size_t len );
333 :
334 : void *boot_yyalloc (yy_size_t );
335 : void *boot_yyrealloc (void *,yy_size_t );
336 : void boot_yyfree (void * );
337 :
338 : #define yy_new_buffer boot_yy_create_buffer
339 :
340 : #define yy_set_interactive(is_interactive) \
341 : { \
342 : if ( ! YY_CURRENT_BUFFER ){ \
343 : boot_yyensure_buffer_stack (); \
344 : YY_CURRENT_BUFFER_LVALUE = \
345 : boot_yy_create_buffer(boot_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 : boot_yyensure_buffer_stack (); \
354 : YY_CURRENT_BUFFER_LVALUE = \
355 : boot_yy_create_buffer(boot_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 boot_yywrap() 1
365 : #define YY_SKIP_YYWRAP
366 :
367 : typedef unsigned char YY_CHAR;
368 :
369 : FILE *boot_yyin = (FILE *) 0, *boot_yyout = (FILE *) 0;
370 :
371 : typedef int yy_state_type;
372 :
373 : extern int boot_yylineno;
374 :
375 : int boot_yylineno = 1;
376 :
377 : extern char *boot_yytext;
378 : #define yytext_ptr boot_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 boot_yytext.
387 : */
388 : #define YY_DO_BEFORE_ACTION \
389 : (yytext_ptr) = yy_bp; \
390 : boot_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 34
396 : #define YY_END_OF_BUFFER 35
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[150] =
405 : { 0,
406 : 0, 0, 35, 33, 16, 15, 17, 33, 13, 14,
407 : 11, 31, 31, 12, 31, 31, 31, 33, 31, 31,
408 : 31, 31, 31, 31, 31, 31, 31, 31, 31, 18,
409 : 0, 32, 31, 0, 31, 0, 31, 31, 31, 31,
410 : 0, 31, 31, 31, 31, 31, 31, 31, 24, 31,
411 : 31, 31, 31, 31, 31, 31, 18, 0, 30, 31,
412 : 28, 31, 4, 0, 31, 31, 31, 31, 31, 31,
413 : 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
414 : 29, 31, 31, 31, 31, 31, 31, 31, 31, 31,
415 : 1, 31, 31, 31, 31, 31, 31, 27, 31, 31,
416 :
417 : 20, 2, 31, 31, 23, 31, 31, 31, 31, 26,
418 : 31, 25, 31, 9, 31, 3, 31, 31, 10, 31,
419 : 31, 22, 31, 31, 19, 21, 31, 31, 31, 31,
420 : 31, 31, 31, 5, 31, 31, 31, 31, 31, 31,
421 : 8, 31, 31, 31, 7, 31, 31, 6, 0
422 : } ;
423 :
424 : static yyconst flex_int32_t yy_ec[256] =
425 : { 0,
426 : 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
427 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
428 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
429 : 1, 4, 1, 5, 6, 1, 1, 1, 1, 7,
430 : 8, 1, 1, 9, 10, 1, 1, 11, 11, 11,
431 : 11, 11, 11, 11, 11, 11, 11, 1, 1, 1,
432 : 12, 1, 1, 1, 13, 13, 14, 15, 16, 17,
433 : 13, 13, 18, 13, 13, 19, 13, 20, 21, 13,
434 : 13, 22, 13, 23, 24, 13, 13, 13, 13, 13,
435 : 25, 26, 27, 1, 28, 1, 29, 30, 31, 32,
436 :
437 : 33, 13, 34, 35, 36, 13, 13, 37, 13, 38,
438 : 39, 40, 41, 42, 43, 44, 45, 13, 46, 47,
439 : 48, 13, 1, 1, 1, 1, 1, 1, 1, 1,
440 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
441 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
442 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
443 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
444 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
446 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
447 :
448 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
449 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
450 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
451 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
452 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
453 : 1, 1, 1, 1, 1
454 : } ;
455 :
456 : static yyconst flex_int32_t yy_meta[49] =
457 : { 0,
458 : 1, 1, 2, 1, 1, 1, 1, 1, 1, 3,
459 : 3, 1, 3, 3, 3, 3, 3, 3, 3, 3,
460 : 3, 3, 3, 3, 4, 3, 1, 3, 3, 3,
461 : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
462 : 3, 3, 3, 3, 3, 3, 3, 3
463 : } ;
464 :
465 : static yyconst flex_int16_t yy_base[154] =
466 : { 0,
467 : 0, 77, 82, 671, 671, 671, 671, 76, 671, 671,
468 : 671, 34, 39, 671, 41, 47, 51, 47, 49, 53,
469 : 60, 70, 74, 79, 81, 83, 100, 103, 106, 0,
470 : 51, 671, 29, 43, 111, 100, 123, 128, 133, 140,
471 : 42, 137, 146, 150, 154, 158, 163, 171, 180, 182,
472 : 185, 191, 199, 208, 211, 213, 0, 103, 671, 216,
473 : 225, 230, 233, 41, 235, 238, 242, 244, 252, 263,
474 : 265, 270, 282, 284, 287, 289, 292, 296, 301, 314,
475 : 321, 325, 327, 331, 333, 335, 339, 357, 359, 361,
476 : 363, 366, 368, 371, 385, 392, 395, 397, 399, 403,
477 :
478 : 406, 423, 425, 427, 429, 431, 434, 436, 455, 457,
479 : 460, 463, 465, 469, 474, 482, 486, 488, 492, 495,
480 : 499, 512, 516, 519, 524, 526, 529, 533, 536, 543,
481 : 546, 553, 555, 563, 566, 572, 574, 580, 591, 593,
482 : 597, 601, 603, 605, 611, 614, 622, 624, 671, 660,
483 : 47, 662, 666
484 : } ;
485 :
486 : static yyconst flex_int16_t yy_def[154] =
487 : { 0,
488 : 149, 1, 149, 149, 149, 149, 149, 150, 149, 149,
489 : 149, 151, 152, 149, 152, 152, 152, 149, 152, 152,
490 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 153,
491 : 150, 149, 151, 149, 152, 149, 152, 152, 152, 152,
492 : 149, 152, 152, 152, 152, 152, 152, 152, 152, 152,
493 : 152, 152, 152, 152, 152, 152, 153, 149, 149, 152,
494 : 152, 152, 152, 149, 152, 152, 152, 152, 152, 152,
495 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
496 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
497 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
498 :
499 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
500 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
501 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
502 : 152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
503 : 152, 152, 152, 152, 152, 152, 152, 152, 0, 149,
504 : 149, 149, 149
505 : } ;
506 :
507 : static yyconst flex_int16_t yy_nxt[720] =
508 : { 0,
509 : 4, 5, 6, 7, 8, 4, 9, 10, 11, 12,
510 : 13, 14, 13, 13, 13, 13, 15, 13, 13, 16,
511 : 17, 13, 13, 13, 4, 18, 4, 19, 13, 20,
512 : 21, 22, 13, 13, 13, 23, 13, 13, 24, 13,
513 : 13, 25, 26, 27, 28, 29, 13, 13, 33, 33,
514 : 33, 33, 64, 41, 34, 32, 33, 41, 33, 34,
515 : 33, 37, 33, 36, 34, 36, 34, 38, 40, 33,
516 : 39, 36, 34, 36, 34, 36, 34, 36, 34, 33,
517 : 32, 149, 30, 33, 36, 34, 42, 149, 33, 149,
518 : 33, 43, 33, 149, 36, 34, 45, 44, 36, 34,
519 :
520 : 149, 46, 47, 36, 34, 36, 34, 36, 34, 33,
521 : 58, 48, 33, 58, 149, 33, 49, 52, 50, 51,
522 : 33, 149, 149, 149, 36, 34, 59, 36, 34, 59,
523 : 36, 34, 33, 149, 149, 36, 34, 33, 53, 149,
524 : 54, 56, 33, 149, 60, 55, 33, 36, 34, 33,
525 : 61, 62, 36, 34, 63, 33, 149, 36, 34, 33,
526 : 149, 36, 34, 33, 36, 34, 149, 33, 149, 149,
527 : 36, 34, 33, 149, 36, 34, 149, 149, 36, 34,
528 : 33, 65, 36, 34, 66, 67, 149, 36, 34, 33,
529 : 69, 33, 68, 70, 33, 36, 34, 149, 149, 149,
530 :
531 : 33, 149, 71, 149, 36, 34, 36, 34, 33, 36,
532 : 34, 149, 149, 72, 73, 36, 34, 33, 149, 75,
533 : 33, 149, 33, 36, 34, 33, 149, 76, 149, 80,
534 : 74, 149, 36, 34, 33, 36, 34, 36, 34, 33,
535 : 36, 34, 33, 77, 33, 149, 78, 33, 81, 36,
536 : 34, 33, 149, 33, 36, 34, 79, 36, 34, 36,
537 : 34, 33, 36, 34, 149, 149, 36, 34, 36, 34,
538 : 149, 82, 33, 149, 33, 149, 36, 34, 84, 33,
539 : 86, 83, 149, 149, 149, 149, 85, 36, 34, 36,
540 : 34, 33, 149, 33, 36, 34, 33, 88, 33, 87,
541 :
542 : 89, 33, 90, 149, 149, 33, 36, 34, 36, 34,
543 : 33, 36, 34, 36, 34, 149, 36, 34, 149, 91,
544 : 36, 34, 149, 33, 149, 36, 34, 92, 93, 98,
545 : 33, 94, 95, 96, 33, 97, 33, 149, 36, 34,
546 : 33, 149, 33, 149, 33, 36, 34, 149, 33, 36,
547 : 34, 36, 34, 149, 149, 36, 34, 36, 34, 36,
548 : 34, 99, 101, 36, 34, 102, 33, 104, 33, 100,
549 : 33, 149, 33, 149, 149, 33, 149, 33, 103, 149,
550 : 33, 36, 34, 36, 34, 36, 34, 36, 34, 106,
551 : 36, 34, 36, 34, 33, 36, 34, 149, 149, 149,
552 :
553 : 109, 33, 107, 105, 33, 149, 33, 149, 33, 36,
554 : 34, 149, 33, 108, 110, 33, 36, 34, 149, 36,
555 : 34, 36, 34, 36, 34, 112, 114, 36, 34, 111,
556 : 36, 34, 33, 113, 33, 149, 33, 149, 33, 149,
557 : 33, 149, 149, 33, 149, 33, 115, 36, 34, 36,
558 : 34, 36, 34, 36, 34, 36, 34, 116, 36, 34,
559 : 36, 34, 149, 118, 33, 149, 33, 149, 117, 33,
560 : 149, 149, 33, 149, 33, 120, 149, 119, 33, 36,
561 : 34, 36, 34, 33, 36, 34, 121, 36, 34, 36,
562 : 34, 33, 122, 36, 34, 33, 149, 33, 36, 34,
563 :
564 : 149, 33, 149, 149, 33, 149, 36, 34, 33, 123,
565 : 36, 34, 36, 34, 149, 124, 36, 34, 125, 36,
566 : 34, 33, 149, 36, 34, 33, 128, 127, 33, 149,
567 : 126, 149, 149, 33, 149, 33, 36, 34, 33, 149,
568 : 36, 34, 33, 36, 34, 33, 149, 130, 36, 34,
569 : 36, 34, 33, 36, 34, 33, 131, 36, 34, 129,
570 : 36, 34, 33, 133, 33, 149, 149, 36, 34, 149,
571 : 36, 34, 33, 149, 132, 33, 149, 36, 34, 36,
572 : 34, 33, 134, 33, 135, 136, 149, 36, 34, 33,
573 : 36, 34, 149, 137, 149, 149, 36, 34, 36, 34,
574 :
575 : 33, 138, 33, 149, 36, 34, 33, 149, 139, 140,
576 : 33, 141, 33, 149, 33, 36, 34, 36, 34, 142,
577 : 33, 36, 34, 33, 143, 36, 34, 36, 34, 36,
578 : 34, 33, 149, 33, 149, 36, 34, 149, 36, 34,
579 : 146, 149, 149, 149, 144, 145, 36, 34, 36, 34,
580 : 149, 149, 147, 149, 149, 149, 149, 149, 149, 148,
581 : 31, 31, 31, 31, 35, 35, 57, 149, 57, 57,
582 : 3, 149, 149, 149, 149, 149, 149, 149, 149, 149,
583 : 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
584 : 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
585 :
586 : 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
587 : 149, 149, 149, 149, 149, 149, 149, 149, 149
588 : } ;
589 :
590 : static yyconst flex_int16_t yy_chk[720] =
591 : { 0,
592 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
593 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
594 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
595 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
596 : 1, 1, 1, 1, 1, 1, 1, 1, 13, 151,
597 : 15, 64, 41, 34, 33, 31, 16, 18, 19, 12,
598 : 17, 15, 20, 13, 13, 15, 15, 16, 17, 21,
599 : 16, 16, 16, 19, 19, 17, 17, 20, 20, 22,
600 : 8, 3, 2, 23, 21, 21, 19, 0, 24, 0,
601 : 25, 20, 26, 0, 22, 22, 21, 20, 23, 23,
602 :
603 : 0, 21, 22, 24, 24, 25, 25, 26, 26, 27,
604 : 36, 23, 28, 58, 0, 29, 24, 26, 24, 25,
605 : 35, 0, 0, 0, 27, 27, 36, 28, 28, 58,
606 : 29, 29, 37, 0, 0, 35, 35, 38, 27, 0,
607 : 28, 29, 39, 0, 37, 28, 42, 37, 37, 40,
608 : 38, 39, 38, 38, 40, 43, 0, 39, 39, 44,
609 : 0, 42, 42, 45, 40, 40, 0, 46, 0, 0,
610 : 43, 43, 47, 0, 44, 44, 0, 0, 45, 45,
611 : 48, 42, 46, 46, 43, 44, 0, 47, 47, 49,
612 : 46, 50, 45, 47, 51, 48, 48, 0, 0, 0,
613 :
614 : 52, 0, 48, 0, 49, 49, 50, 50, 53, 51,
615 : 51, 0, 0, 48, 50, 52, 52, 54, 0, 52,
616 : 55, 0, 56, 53, 53, 60, 0, 53, 0, 60,
617 : 51, 0, 54, 54, 61, 55, 55, 56, 56, 62,
618 : 60, 60, 63, 54, 65, 0, 55, 66, 62, 61,
619 : 61, 67, 0, 68, 62, 62, 56, 63, 63, 65,
620 : 65, 69, 66, 66, 0, 0, 67, 67, 68, 68,
621 : 0, 65, 70, 0, 71, 0, 69, 69, 67, 72,
622 : 69, 66, 0, 0, 0, 0, 68, 70, 70, 71,
623 : 71, 73, 0, 74, 72, 72, 75, 71, 76, 70,
624 :
625 : 71, 77, 72, 0, 0, 78, 73, 73, 74, 74,
626 : 79, 75, 75, 76, 76, 0, 77, 77, 0, 73,
627 : 78, 78, 0, 80, 0, 79, 79, 74, 75, 80,
628 : 81, 76, 77, 78, 82, 79, 83, 0, 80, 80,
629 : 84, 0, 85, 0, 86, 81, 81, 0, 87, 82,
630 : 82, 83, 83, 0, 0, 84, 84, 85, 85, 86,
631 : 86, 82, 84, 87, 87, 85, 88, 87, 89, 83,
632 : 90, 0, 91, 0, 0, 92, 0, 93, 86, 0,
633 : 94, 88, 88, 89, 89, 90, 90, 91, 91, 89,
634 : 92, 92, 93, 93, 95, 94, 94, 0, 0, 0,
635 :
636 : 93, 96, 90, 88, 97, 0, 98, 0, 99, 95,
637 : 95, 0, 100, 92, 94, 101, 96, 96, 0, 97,
638 : 97, 98, 98, 99, 99, 96, 99, 100, 100, 95,
639 : 101, 101, 102, 97, 103, 0, 104, 0, 105, 0,
640 : 106, 0, 0, 107, 0, 108, 100, 102, 102, 103,
641 : 103, 104, 104, 105, 105, 106, 106, 103, 107, 107,
642 : 108, 108, 0, 106, 109, 0, 110, 0, 104, 111,
643 : 0, 0, 112, 0, 113, 108, 0, 107, 114, 109,
644 : 109, 110, 110, 115, 111, 111, 109, 112, 112, 113,
645 : 113, 116, 111, 114, 114, 117, 0, 118, 115, 115,
646 :
647 : 0, 119, 0, 0, 120, 0, 116, 116, 121, 113,
648 : 117, 117, 118, 118, 0, 115, 119, 119, 117, 120,
649 : 120, 122, 0, 121, 121, 123, 121, 120, 124, 0,
650 : 118, 0, 0, 125, 0, 126, 122, 122, 127, 0,
651 : 123, 123, 128, 124, 124, 129, 0, 124, 125, 125,
652 : 126, 126, 130, 127, 127, 131, 127, 128, 128, 123,
653 : 129, 129, 132, 129, 133, 0, 0, 130, 130, 0,
654 : 131, 131, 134, 0, 128, 135, 0, 132, 132, 133,
655 : 133, 136, 130, 137, 131, 132, 0, 134, 134, 138,
656 : 135, 135, 0, 133, 0, 0, 136, 136, 137, 137,
657 :
658 : 139, 135, 140, 0, 138, 138, 141, 0, 136, 137,
659 : 142, 138, 143, 0, 144, 139, 139, 140, 140, 139,
660 : 145, 141, 141, 146, 140, 142, 142, 143, 143, 144,
661 : 144, 147, 0, 148, 0, 145, 145, 0, 146, 146,
662 : 144, 0, 0, 0, 142, 143, 147, 147, 148, 148,
663 : 0, 0, 146, 0, 0, 0, 0, 0, 0, 147,
664 : 150, 150, 150, 150, 152, 152, 153, 0, 153, 153,
665 : 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
666 : 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
667 : 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
668 :
669 : 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
670 : 149, 149, 149, 149, 149, 149, 149, 149, 149
671 : } ;
672 :
673 : static yy_state_type yy_last_accepting_state;
674 : static char *yy_last_accepting_cpos;
675 :
676 : extern int boot_yy_flex_debug;
677 : int boot_yy_flex_debug = 0;
678 :
679 : /* The intent behind this definition is that it'll catch
680 : * any uses of REJECT which flex missed.
681 : */
682 : #define REJECT reject_used_but_not_detected
683 : #define yymore() yymore_used_but_not_detected
684 : #define YY_MORE_ADJ 0
685 : #define YY_RESTORE_YY_MORE_OFFSET
686 : char *boot_yytext;
687 : #line 1 "bootscanner.l"
688 : #line 2 "bootscanner.l"
689 : /*-------------------------------------------------------------------------
690 : *
691 : * bootscanner.l
692 : * a lexical scanner for the bootstrap parser
693 : *
694 : * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
695 : * Portions Copyright (c) 1994, Regents of the University of California
696 : *
697 : *
698 : * IDENTIFICATION
699 : * src/backend/bootstrap/bootscanner.l
700 : *
701 : *-------------------------------------------------------------------------
702 : */
703 : #include "postgres.h"
704 :
705 : #include "access/attnum.h"
706 : #include "access/htup.h"
707 : #include "access/itup.h"
708 : #include "access/tupdesc.h"
709 : #include "bootstrap/bootstrap.h"
710 : #include "catalog/pg_am.h"
711 : #include "catalog/pg_attribute.h"
712 : #include "catalog/pg_class.h"
713 : #include "nodes/nodes.h"
714 : #include "nodes/parsenodes.h"
715 : #include "nodes/pg_list.h"
716 : #include "nodes/primnodes.h"
717 : #include "parser/scansup.h"
718 : #include "rewrite/prs2lock.h"
719 : #include "storage/block.h"
720 : #include "storage/fd.h"
721 : #include "storage/itemptr.h"
722 : #include "storage/off.h"
723 : #include "utils/rel.h"
724 :
725 : /* Not needed now that this file is compiled as part of bootparse. */
726 : /* #include "bootparse.h" */
727 :
728 :
729 : /* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
730 : #undef fprintf
731 : #define fprintf(file, fmt, msg) fprintf_to_ereport(fmt, msg)
732 :
733 : static void
734 : fprintf_to_ereport(const char *fmt, const char *msg)
735 : {
736 : ereport(ERROR, (errmsg_internal("%s", msg)));
737 : }
738 :
739 :
740 : static int yyline = 1; /* line number for error reporting */
741 :
742 : #define YY_NO_INPUT 1
743 : #line 744 "bootscanner.c"
744 :
745 : #define INITIAL 0
746 :
747 : #ifndef YY_NO_UNISTD_H
748 : /* Special case for "unistd.h", since it is non-ANSI. We include it way
749 : * down here because we want the user's section 1 to have been scanned first.
750 : * The user has a chance to override it with an option.
751 : */
752 : #include <unistd.h>
753 : #endif
754 :
755 : #ifndef YY_EXTRA_TYPE
756 : #define YY_EXTRA_TYPE void *
757 : #endif
758 :
759 : static int yy_init_globals (void );
760 :
761 : /* Accessor methods to globals.
762 : These are made visible to non-reentrant scanners for convenience. */
763 :
764 : int boot_yylex_destroy (void );
765 :
766 : int boot_yyget_debug (void );
767 :
768 : void boot_yyset_debug (int debug_flag );
769 :
770 : YY_EXTRA_TYPE boot_yyget_extra (void );
771 :
772 : void boot_yyset_extra (YY_EXTRA_TYPE user_defined );
773 :
774 : FILE *boot_yyget_in (void );
775 :
776 : void boot_yyset_in (FILE * in_str );
777 :
778 : FILE *boot_yyget_out (void );
779 :
780 : void boot_yyset_out (FILE * out_str );
781 :
782 : yy_size_t boot_yyget_leng (void );
783 :
784 : char *boot_yyget_text (void );
785 :
786 : int boot_yyget_lineno (void );
787 :
788 : void boot_yyset_lineno (int line_number );
789 :
790 : /* Macros after this point can all be overridden by user definitions in
791 : * section 1.
792 : */
793 :
794 : #ifndef YY_SKIP_YYWRAP
795 : #ifdef __cplusplus
796 : extern "C" int boot_yywrap (void );
797 : #else
798 : extern int boot_yywrap (void );
799 : #endif
800 : #endif
801 :
802 : #ifndef yytext_ptr
803 : static void yy_flex_strncpy (char *,yyconst char *,int );
804 : #endif
805 :
806 : #ifdef YY_NEED_STRLEN
807 : static int yy_flex_strlen (yyconst char * );
808 : #endif
809 :
810 : #ifndef YY_NO_INPUT
811 :
812 : #ifdef __cplusplus
813 : static int yyinput (void );
814 : #else
815 : static int input (void );
816 : #endif
817 :
818 : #endif
819 :
820 : /* Amount of stuff to slurp up with each read. */
821 : #ifndef YY_READ_BUF_SIZE
822 : #ifdef __ia64__
823 : /* On IA-64, the buffer size is 16k, not 8k */
824 : #define YY_READ_BUF_SIZE 16384
825 : #else
826 : #define YY_READ_BUF_SIZE 8192
827 : #endif /* __ia64__ */
828 : #endif
829 :
830 : /* Copy whatever the last rule matched to the standard output. */
831 : #ifndef ECHO
832 : /* This used to be an fputs(), but since the string might contain NUL's,
833 : * we now use fwrite().
834 : */
835 : #define ECHO do { if (fwrite( boot_yytext, boot_yyleng, 1, boot_yyout )) {} } while (0)
836 : #endif
837 :
838 : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
839 : * is returned in "result".
840 : */
841 : #ifndef YY_INPUT
842 : #define YY_INPUT(buf,result,max_size) \
843 : if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
844 : { \
845 : int c = '*'; \
846 : int n; \
847 : for ( n = 0; n < max_size && \
848 : (c = getc( boot_yyin )) != EOF && c != '\n'; ++n ) \
849 : buf[n] = (char) c; \
850 : if ( c == '\n' ) \
851 : buf[n++] = (char) c; \
852 : if ( c == EOF && ferror( boot_yyin ) ) \
853 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
854 : result = n; \
855 : } \
856 : else \
857 : { \
858 : errno=0; \
859 : while ( (result = fread(buf, 1, (yy_size_t) max_size, boot_yyin)) == 0 && ferror(boot_yyin)) \
860 : { \
861 : if( errno != EINTR) \
862 : { \
863 : YY_FATAL_ERROR( "input in flex scanner failed" ); \
864 : break; \
865 : } \
866 : errno=0; \
867 : clearerr(boot_yyin); \
868 : } \
869 : }\
870 : \
871 :
872 : #endif
873 :
874 : /* No semi-colon after return; correct usage is to write "yyterminate();" -
875 : * we don't want an extra ';' after the "return" because that will cause
876 : * some compilers to complain about unreachable statements.
877 : */
878 : #ifndef yyterminate
879 : #define yyterminate() return YY_NULL
880 : #endif
881 :
882 : /* Number of entries by which start-condition stack grows. */
883 : #ifndef YY_START_STACK_INCR
884 : #define YY_START_STACK_INCR 25
885 : #endif
886 :
887 : /* Report a fatal error. */
888 : #ifndef YY_FATAL_ERROR
889 : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
890 : #endif
891 :
892 : /* end tables serialization structures and prototypes */
893 :
894 : /* Default declaration of generated scanner - a define so the user can
895 : * easily add parameters.
896 : */
897 : #ifndef YY_DECL
898 : #define YY_DECL_IS_OURS 1
899 :
900 : extern int boot_yylex (void);
901 :
902 : #define YY_DECL int boot_yylex (void)
903 : #endif /* !YY_DECL */
904 :
905 : /* Code executed at the beginning of each rule, after boot_yytext and boot_yyleng
906 : * have been set up.
907 : */
908 : #ifndef YY_USER_ACTION
909 : #define YY_USER_ACTION
910 : #endif
911 :
912 : /* Code executed at the end of each rule. */
913 : #ifndef YY_BREAK
914 : #define YY_BREAK break;
915 : #endif
916 :
917 : #define YY_RULE_SETUP \
918 : if ( boot_yyleng > 0 ) \
919 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
920 : (boot_yytext[boot_yyleng - 1] == '\n'); \
921 : YY_USER_ACTION
922 :
923 : /** The main scanner function which does all the work.
924 : */
925 147963 : 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 147963 : if ( !(yy_init) )
932 : {
933 1 : (yy_init) = 1;
934 :
935 : #ifdef YY_USER_INIT
936 : YY_USER_INIT;
937 : #endif
938 :
939 1 : if ( ! (yy_start) )
940 1 : (yy_start) = 1; /* first start state */
941 :
942 1 : if ( ! boot_yyin )
943 1 : boot_yyin = stdin;
944 :
945 1 : if ( ! boot_yyout )
946 1 : boot_yyout = stdout;
947 :
948 1 : if ( ! YY_CURRENT_BUFFER ) {
949 1 : boot_yyensure_buffer_stack ();
950 2 : YY_CURRENT_BUFFER_LVALUE =
951 1 : boot_yy_create_buffer(boot_yyin,YY_BUF_SIZE );
952 : }
953 :
954 1 : boot_yy_load_buffer_state( );
955 : }
956 :
957 : {
958 : #line 73 "bootscanner.l"
959 :
960 :
961 : #line 962 "bootscanner.c"
962 :
963 : while ( 1 ) /* loops until end-of-file is reached */
964 : {
965 296146 : yy_cp = (yy_c_buf_p);
966 :
967 : /* Support of boot_yytext. */
968 296146 : *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 296146 : yy_bp = yy_cp;
974 :
975 296146 : yy_current_state = (yy_start);
976 296146 : yy_current_state += YY_AT_BOL();
977 : yy_match:
978 : do
979 : {
980 934864 : register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
981 934864 : if ( yy_accept[yy_current_state] )
982 : {
983 609113 : (yy_last_accepting_state) = yy_current_state;
984 609113 : (yy_last_accepting_cpos) = yy_cp;
985 : }
986 2478336 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
987 : {
988 608608 : yy_current_state = (int) yy_def[yy_current_state];
989 608608 : if ( yy_current_state >= 150 )
990 305695 : yy_c = yy_meta[(unsigned int) yy_c];
991 : }
992 934864 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
993 934864 : ++yy_cp;
994 : }
995 934864 : while ( yy_current_state != 149 );
996 296224 : yy_cp = (yy_last_accepting_cpos);
997 296224 : yy_current_state = (yy_last_accepting_state);
998 :
999 : yy_find_action:
1000 296225 : yy_act = yy_accept[yy_current_state];
1001 :
1002 296225 : YY_DO_BEFORE_ACTION;
1003 :
1004 : do_action: /* This label is used only to access EOF actions. */
1005 :
1006 296226 : switch ( yy_act )
1007 : { /* beginning of action switch */
1008 : case 0: /* must back up */
1009 : /* undo the effects of YY_DO_BEFORE_ACTION */
1010 0 : *yy_cp = (yy_hold_char);
1011 0 : yy_cp = (yy_last_accepting_cpos);
1012 0 : yy_current_state = (yy_last_accepting_state);
1013 0 : goto yy_find_action;
1014 :
1015 : case 1:
1016 58 : YY_RULE_SETUP
1017 : #line 75 "bootscanner.l"
1018 : { return(OPEN); }
1019 : YY_BREAK
1020 : case 2:
1021 : YY_RULE_SETUP
1022 : #line 77 "bootscanner.l"
1023 : { return(XCLOSE); }
1024 : YY_BREAK
1025 : case 3:
1026 : YY_RULE_SETUP
1027 : #line 79 "bootscanner.l"
1028 : { return(XCREATE); }
1029 : YY_BREAK
1030 : case 4:
1031 : YY_RULE_SETUP
1032 : #line 81 "bootscanner.l"
1033 : { return(OBJ_ID); }
1034 : YY_BREAK
1035 : case 5:
1036 : YY_RULE_SETUP
1037 : #line 82 "bootscanner.l"
1038 : { return(XBOOTSTRAP); }
1039 : YY_BREAK
1040 : case 6:
1041 : YY_RULE_SETUP
1042 : #line 83 "bootscanner.l"
1043 : { return(XSHARED_RELATION); }
1044 : YY_BREAK
1045 : case 7:
1046 : YY_RULE_SETUP
1047 : #line 84 "bootscanner.l"
1048 : { return(XWITHOUT_OIDS); }
1049 : YY_BREAK
1050 : case 8:
1051 : YY_RULE_SETUP
1052 : #line 85 "bootscanner.l"
1053 : { return(XROWTYPE_OID); }
1054 : YY_BREAK
1055 : case 9:
1056 : YY_RULE_SETUP
1057 : #line 86 "bootscanner.l"
1058 : { return(NULLVAL); }
1059 : YY_BREAK
1060 : case 10:
1061 : YY_RULE_SETUP
1062 : #line 88 "bootscanner.l"
1063 : { return(INSERT_TUPLE); }
1064 : YY_BREAK
1065 : case 11:
1066 : YY_RULE_SETUP
1067 : #line 90 "bootscanner.l"
1068 : { return(COMMA); }
1069 : YY_BREAK
1070 : case 12:
1071 : YY_RULE_SETUP
1072 : #line 91 "bootscanner.l"
1073 : { return(EQUALS); }
1074 : YY_BREAK
1075 : case 13:
1076 : YY_RULE_SETUP
1077 : #line 92 "bootscanner.l"
1078 : { return(LPAREN); }
1079 : YY_BREAK
1080 : case 14:
1081 : YY_RULE_SETUP
1082 : #line 93 "bootscanner.l"
1083 : { return(RPAREN); }
1084 : YY_BREAK
1085 : case 15:
1086 : /* rule 15 can match eol */
1087 : YY_RULE_SETUP
1088 : #line 95 "bootscanner.l"
1089 : { yyline++; }
1090 : YY_BREAK
1091 : case 16:
1092 : YY_RULE_SETUP
1093 : #line 96 "bootscanner.l"
1094 : ;
1095 : YY_BREAK
1096 : case 17:
1097 : YY_RULE_SETUP
1098 : #line 97 "bootscanner.l"
1099 : ;
1100 : YY_BREAK
1101 : case 18:
1102 : YY_RULE_SETUP
1103 : #line 99 "bootscanner.l"
1104 : ; /* drop everything after "#" for comments */
1105 : YY_BREAK
1106 : case 19:
1107 : YY_RULE_SETUP
1108 : #line 102 "bootscanner.l"
1109 : { return(XDECLARE); }
1110 : YY_BREAK
1111 : case 20:
1112 : YY_RULE_SETUP
1113 : #line 103 "bootscanner.l"
1114 : { return(XBUILD); }
1115 : YY_BREAK
1116 : case 21:
1117 : YY_RULE_SETUP
1118 : #line 104 "bootscanner.l"
1119 : { return(INDICES); }
1120 : YY_BREAK
1121 : case 22:
1122 : YY_RULE_SETUP
1123 : #line 105 "bootscanner.l"
1124 : { return(UNIQUE); }
1125 : YY_BREAK
1126 : case 23:
1127 : YY_RULE_SETUP
1128 : #line 106 "bootscanner.l"
1129 : { return(INDEX); }
1130 : YY_BREAK
1131 : case 24:
1132 : YY_RULE_SETUP
1133 : #line 107 "bootscanner.l"
1134 : { return(ON); }
1135 : YY_BREAK
1136 : case 25:
1137 : YY_RULE_SETUP
1138 : #line 108 "bootscanner.l"
1139 : { return(USING); }
1140 : YY_BREAK
1141 : case 26:
1142 : YY_RULE_SETUP
1143 : #line 109 "bootscanner.l"
1144 : { return(XTOAST); }
1145 : YY_BREAK
1146 : case 27:
1147 : YY_RULE_SETUP
1148 : #line 110 "bootscanner.l"
1149 : { return(XFORCE); }
1150 : YY_BREAK
1151 : case 28:
1152 : YY_RULE_SETUP
1153 : #line 111 "bootscanner.l"
1154 : { return(XNOT); }
1155 : YY_BREAK
1156 : case 29:
1157 : YY_RULE_SETUP
1158 : #line 112 "bootscanner.l"
1159 : { return(XNULL); }
1160 : YY_BREAK
1161 : case 30:
1162 : YY_RULE_SETUP
1163 : #line 114 "bootscanner.l"
1164 : {
1165 : yylval.str = MapArrayTypeName(boot_yytext);
1166 : return(ID);
1167 : }
1168 : YY_BREAK
1169 : case 31:
1170 : YY_RULE_SETUP
1171 : #line 118 "bootscanner.l"
1172 : {
1173 : yylval.str = scanstr(boot_yytext);
1174 : return(ID);
1175 : }
1176 : YY_BREAK
1177 : case 32:
1178 : /* rule 32 can match eol */
1179 : YY_RULE_SETUP
1180 : #line 122 "bootscanner.l"
1181 : {
1182 : boot_yytext[strlen(boot_yytext)-1] = '\0'; /* strip off quotes */
1183 : yylval.str = scanstr(boot_yytext+1);
1184 : boot_yytext[strlen(boot_yytext)] = '"'; /* restore quotes */
1185 : return(ID);
1186 : }
1187 : YY_BREAK
1188 : case 33:
1189 : YY_RULE_SETUP
1190 : #line 129 "bootscanner.l"
1191 : {
1192 : elog(ERROR, "syntax error at line %d: unexpected character \"%s\"", yyline, boot_yytext);
1193 : }
1194 : YY_BREAK
1195 : case 34:
1196 : YY_RULE_SETUP
1197 : #line 135 "bootscanner.l"
1198 : YY_FATAL_ERROR( "flex scanner jammed" );
1199 : YY_BREAK
1200 : #line 1201 "bootscanner.c"
1201 : case YY_STATE_EOF(INITIAL):
1202 1 : yyterminate();
1203 :
1204 : case YY_END_OF_BUFFER:
1205 : {
1206 : /* Amount of text matched not including the EOB char. */
1207 80 : int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1208 :
1209 : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1210 80 : *yy_cp = (yy_hold_char);
1211 : YY_RESTORE_YY_MORE_OFFSET
1212 :
1213 80 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1214 : {
1215 : /* We're scanning a new file or input source. It's
1216 : * possible that this happened because the user
1217 : * just pointed boot_yyin at a new source and called
1218 : * boot_yylex(). If so, then we have to assure
1219 : * consistency between YY_CURRENT_BUFFER and our
1220 : * globals. Here is the right place to do so, because
1221 : * this is the first action (other than possibly a
1222 : * back-up) that will match for the new input source.
1223 : */
1224 1 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1225 1 : YY_CURRENT_BUFFER_LVALUE->yy_input_file = boot_yyin;
1226 1 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1227 : }
1228 :
1229 : /* Note that here we test for yy_c_buf_p "<=" to the position
1230 : * of the first EOB in the buffer, since yy_c_buf_p will
1231 : * already have been incremented past the NUL character
1232 : * (since all states make transitions on EOB to the
1233 : * end-of-buffer state). Contrast this with the test
1234 : * in input().
1235 : */
1236 80 : if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1237 : { /* This was really a NUL. */
1238 : yy_state_type yy_next_state;
1239 :
1240 0 : (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1241 :
1242 0 : yy_current_state = yy_get_previous_state( );
1243 :
1244 : /* Okay, we're now positioned to make the NUL
1245 : * transition. We couldn't have
1246 : * yy_get_previous_state() go ahead and do it
1247 : * for us because it doesn't know how to deal
1248 : * with the possibility of jamming (and we don't
1249 : * want to build jamming into it because then it
1250 : * will run more slowly).
1251 : */
1252 :
1253 0 : yy_next_state = yy_try_NUL_trans( yy_current_state );
1254 :
1255 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1256 :
1257 0 : if ( yy_next_state )
1258 : {
1259 : /* Consume the NUL. */
1260 0 : yy_cp = ++(yy_c_buf_p);
1261 0 : yy_current_state = yy_next_state;
1262 0 : goto yy_match;
1263 : }
1264 :
1265 : else
1266 : {
1267 0 : yy_cp = (yy_last_accepting_cpos);
1268 0 : yy_current_state = (yy_last_accepting_state);
1269 0 : goto yy_find_action;
1270 : }
1271 : }
1272 :
1273 80 : else switch ( yy_get_next_buffer( ) )
1274 : {
1275 : case EOB_ACT_END_OF_FILE:
1276 : {
1277 1 : (yy_did_buffer_switch_on_eof) = 0;
1278 :
1279 : if ( boot_yywrap( ) )
1280 : {
1281 : /* Note: because we've taken care in
1282 : * yy_get_next_buffer() to have set up
1283 : * boot_yytext, we can now set up
1284 : * yy_c_buf_p so that if some total
1285 : * hoser (like flex itself) wants to
1286 : * call the scanner after we return the
1287 : * YY_NULL, it'll still work - another
1288 : * YY_NULL will get returned.
1289 : */
1290 1 : (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1291 :
1292 1 : yy_act = YY_STATE_EOF(YY_START);
1293 1 : goto do_action;
1294 : }
1295 :
1296 : else
1297 : {
1298 : if ( ! (yy_did_buffer_switch_on_eof) )
1299 : YY_NEW_FILE;
1300 : }
1301 : break;
1302 : }
1303 :
1304 : case EOB_ACT_CONTINUE_SCAN:
1305 78 : (yy_c_buf_p) =
1306 78 : (yytext_ptr) + yy_amount_of_matched_text;
1307 :
1308 78 : yy_current_state = yy_get_previous_state( );
1309 :
1310 78 : yy_cp = (yy_c_buf_p);
1311 78 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1312 78 : goto yy_match;
1313 :
1314 : case EOB_ACT_LAST_MATCH:
1315 1 : (yy_c_buf_p) =
1316 1 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1317 :
1318 1 : yy_current_state = yy_get_previous_state( );
1319 :
1320 1 : yy_cp = (yy_c_buf_p);
1321 1 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1322 1 : goto yy_find_action;
1323 : }
1324 0 : break;
1325 : }
1326 :
1327 : default:
1328 0 : YY_FATAL_ERROR(
1329 : "fatal flex scanner internal error--no action found" );
1330 : } /* end of action switch */
1331 148183 : } /* end of scanning one token */
1332 : } /* end of user's declarations */
1333 : } /* end of boot_yylex */
1334 :
1335 : /* yy_get_next_buffer - try to read in a new buffer
1336 : *
1337 : * Returns a code representing an action:
1338 : * EOB_ACT_LAST_MATCH -
1339 : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1340 : * EOB_ACT_END_OF_FILE - end of file
1341 : */
1342 80 : static int yy_get_next_buffer (void)
1343 : {
1344 80 : register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1345 80 : register char *source = (yytext_ptr);
1346 : register int number_to_move, i;
1347 : int ret_val;
1348 :
1349 80 : if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1350 0 : YY_FATAL_ERROR(
1351 : "fatal flex scanner internal error--end of buffer missed" );
1352 :
1353 80 : if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1354 : { /* Don't try to fill the buffer, so this is an EOF. */
1355 0 : if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1356 : {
1357 : /* We matched a single character, the EOB, so
1358 : * treat this as a final EOF.
1359 : */
1360 0 : return EOB_ACT_END_OF_FILE;
1361 : }
1362 :
1363 : else
1364 : {
1365 : /* We matched some text prior to the EOB, first
1366 : * process it.
1367 : */
1368 0 : return EOB_ACT_LAST_MATCH;
1369 : }
1370 : }
1371 :
1372 : /* Try to read more data. */
1373 :
1374 : /* First move last chars to start of buffer. */
1375 80 : number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1376 :
1377 333 : for ( i = 0; i < number_to_move; ++i )
1378 253 : *(dest++) = *(source++);
1379 :
1380 80 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1381 : /* don't do the read, it's not guaranteed to return an EOF,
1382 : * just force an EOF
1383 : */
1384 1 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1385 :
1386 : else
1387 : {
1388 79 : int num_to_read =
1389 79 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1390 :
1391 158 : while ( num_to_read <= 0 )
1392 : { /* Not enough room in the buffer - grow it. */
1393 :
1394 : /* just a shorter name for the current buffer */
1395 0 : YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1396 :
1397 0 : int yy_c_buf_p_offset =
1398 0 : (int) ((yy_c_buf_p) - b->yy_ch_buf);
1399 :
1400 0 : if ( b->yy_is_our_buffer )
1401 : {
1402 0 : yy_size_t new_size = b->yy_buf_size * 2;
1403 :
1404 0 : if ( new_size <= 0 )
1405 0 : b->yy_buf_size += b->yy_buf_size / 8;
1406 : else
1407 0 : b->yy_buf_size *= 2;
1408 :
1409 0 : b->yy_ch_buf = (char *)
1410 : /* Include room in for 2 EOB chars. */
1411 0 : boot_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1412 : }
1413 : else
1414 : /* Can't grow it, we don't own it. */
1415 0 : b->yy_ch_buf = 0;
1416 :
1417 0 : if ( ! b->yy_ch_buf )
1418 0 : YY_FATAL_ERROR(
1419 : "fatal error - scanner input buffer overflow" );
1420 :
1421 0 : (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1422 :
1423 0 : num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1424 0 : number_to_move - 1;
1425 :
1426 : }
1427 :
1428 79 : if ( num_to_read > YY_READ_BUF_SIZE )
1429 79 : num_to_read = YY_READ_BUF_SIZE;
1430 :
1431 : /* Read in more data. */
1432 79 : YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1433 : (yy_n_chars), num_to_read );
1434 :
1435 79 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1436 : }
1437 :
1438 80 : if ( (yy_n_chars) == 0 )
1439 : {
1440 2 : if ( number_to_move == YY_MORE_ADJ )
1441 : {
1442 1 : ret_val = EOB_ACT_END_OF_FILE;
1443 1 : boot_yyrestart(boot_yyin );
1444 : }
1445 :
1446 : else
1447 : {
1448 1 : ret_val = EOB_ACT_LAST_MATCH;
1449 1 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1450 : YY_BUFFER_EOF_PENDING;
1451 : }
1452 : }
1453 :
1454 : else
1455 78 : ret_val = EOB_ACT_CONTINUE_SCAN;
1456 :
1457 80 : if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1458 : /* Extend the array by 50%, plus the number we really need. */
1459 0 : yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1460 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) boot_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1461 0 : if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1462 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1463 : }
1464 :
1465 80 : (yy_n_chars) += number_to_move;
1466 80 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1467 80 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1468 :
1469 80 : (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1470 :
1471 80 : return ret_val;
1472 : }
1473 :
1474 : /* yy_get_previous_state - get the state just before the EOB char was reached */
1475 :
1476 79 : static yy_state_type yy_get_previous_state (void)
1477 : {
1478 : register yy_state_type yy_current_state;
1479 : register char *yy_cp;
1480 :
1481 79 : yy_current_state = (yy_start);
1482 79 : yy_current_state += YY_AT_BOL();
1483 :
1484 332 : for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1485 : {
1486 253 : register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1487 253 : if ( yy_accept[yy_current_state] )
1488 : {
1489 163 : (yy_last_accepting_state) = yy_current_state;
1490 163 : (yy_last_accepting_cpos) = yy_cp;
1491 : }
1492 623 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1493 : {
1494 117 : yy_current_state = (int) yy_def[yy_current_state];
1495 117 : if ( yy_current_state >= 150 )
1496 114 : yy_c = yy_meta[(unsigned int) yy_c];
1497 : }
1498 253 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1499 : }
1500 :
1501 79 : return yy_current_state;
1502 : }
1503 :
1504 : /* yy_try_NUL_trans - try to make a transition on the NUL character
1505 : *
1506 : * synopsis
1507 : * next_state = yy_try_NUL_trans( current_state );
1508 : */
1509 0 : static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1510 : {
1511 : register int yy_is_jam;
1512 0 : register char *yy_cp = (yy_c_buf_p);
1513 :
1514 0 : register YY_CHAR yy_c = 1;
1515 0 : if ( yy_accept[yy_current_state] )
1516 : {
1517 0 : (yy_last_accepting_state) = yy_current_state;
1518 0 : (yy_last_accepting_cpos) = yy_cp;
1519 : }
1520 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1521 : {
1522 0 : yy_current_state = (int) yy_def[yy_current_state];
1523 0 : if ( yy_current_state >= 150 )
1524 0 : yy_c = yy_meta[(unsigned int) yy_c];
1525 : }
1526 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1527 0 : yy_is_jam = (yy_current_state == 149);
1528 :
1529 0 : return yy_is_jam ? 0 : yy_current_state;
1530 : }
1531 :
1532 : #ifndef YY_NO_INPUT
1533 : #ifdef __cplusplus
1534 : static int yyinput (void)
1535 : #else
1536 : static int input (void)
1537 : #endif
1538 :
1539 : {
1540 : int c;
1541 :
1542 : *(yy_c_buf_p) = (yy_hold_char);
1543 :
1544 : if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1545 : {
1546 : /* yy_c_buf_p now points to the character we want to return.
1547 : * If this occurs *before* the EOB characters, then it's a
1548 : * valid NUL; if not, then we've hit the end of the buffer.
1549 : */
1550 : if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1551 : /* This was really a NUL. */
1552 : *(yy_c_buf_p) = '\0';
1553 :
1554 : else
1555 : { /* need more input */
1556 : yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1557 : ++(yy_c_buf_p);
1558 :
1559 : switch ( yy_get_next_buffer( ) )
1560 : {
1561 : case EOB_ACT_LAST_MATCH:
1562 : /* This happens because yy_g_n_b()
1563 : * sees that we've accumulated a
1564 : * token and flags that we need to
1565 : * try matching the token before
1566 : * proceeding. But for input(),
1567 : * there's no matching to consider.
1568 : * So convert the EOB_ACT_LAST_MATCH
1569 : * to EOB_ACT_END_OF_FILE.
1570 : */
1571 :
1572 : /* Reset buffer status. */
1573 : boot_yyrestart(boot_yyin );
1574 :
1575 : /*FALLTHROUGH*/
1576 :
1577 : case EOB_ACT_END_OF_FILE:
1578 : {
1579 : if ( boot_yywrap( ) )
1580 : return EOF;
1581 :
1582 : if ( ! (yy_did_buffer_switch_on_eof) )
1583 : YY_NEW_FILE;
1584 : #ifdef __cplusplus
1585 : return yyinput();
1586 : #else
1587 : return input();
1588 : #endif
1589 : }
1590 :
1591 : case EOB_ACT_CONTINUE_SCAN:
1592 : (yy_c_buf_p) = (yytext_ptr) + offset;
1593 : break;
1594 : }
1595 : }
1596 : }
1597 :
1598 : c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1599 : *(yy_c_buf_p) = '\0'; /* preserve boot_yytext */
1600 : (yy_hold_char) = *++(yy_c_buf_p);
1601 :
1602 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1603 :
1604 : return c;
1605 : }
1606 : #endif /* ifndef YY_NO_INPUT */
1607 :
1608 : /** Immediately switch to a different input stream.
1609 : * @param input_file A readable stream.
1610 : *
1611 : * @note This function does not reset the start condition to @c INITIAL .
1612 : */
1613 1 : void boot_yyrestart (FILE * input_file )
1614 : {
1615 :
1616 1 : if ( ! YY_CURRENT_BUFFER ){
1617 0 : boot_yyensure_buffer_stack ();
1618 0 : YY_CURRENT_BUFFER_LVALUE =
1619 0 : boot_yy_create_buffer(boot_yyin,YY_BUF_SIZE );
1620 : }
1621 :
1622 1 : boot_yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1623 1 : boot_yy_load_buffer_state( );
1624 1 : }
1625 :
1626 : /** Switch to a different input buffer.
1627 : * @param new_buffer The new input buffer.
1628 : *
1629 : */
1630 0 : void boot_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1631 : {
1632 :
1633 : /* TODO. We should be able to replace this entire function body
1634 : * with
1635 : * boot_yypop_buffer_state();
1636 : * boot_yypush_buffer_state(new_buffer);
1637 : */
1638 0 : boot_yyensure_buffer_stack ();
1639 0 : if ( YY_CURRENT_BUFFER == new_buffer )
1640 0 : return;
1641 :
1642 0 : if ( YY_CURRENT_BUFFER )
1643 : {
1644 : /* Flush out information for old buffer. */
1645 0 : *(yy_c_buf_p) = (yy_hold_char);
1646 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1647 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1648 : }
1649 :
1650 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1651 0 : boot_yy_load_buffer_state( );
1652 :
1653 : /* We don't actually know whether we did this switch during
1654 : * EOF (boot_yywrap()) processing, but the only time this flag
1655 : * is looked at is after boot_yywrap() is called, so it's safe
1656 : * to go ahead and always set it.
1657 : */
1658 0 : (yy_did_buffer_switch_on_eof) = 1;
1659 : }
1660 :
1661 3 : static void boot_yy_load_buffer_state (void)
1662 : {
1663 3 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1664 3 : (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1665 3 : boot_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1666 3 : (yy_hold_char) = *(yy_c_buf_p);
1667 3 : }
1668 :
1669 : /** Allocate and initialize an input buffer state.
1670 : * @param file A readable stream.
1671 : * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1672 : *
1673 : * @return the allocated buffer state.
1674 : */
1675 1 : YY_BUFFER_STATE boot_yy_create_buffer (FILE * file, int size )
1676 : {
1677 : YY_BUFFER_STATE b;
1678 :
1679 1 : b = (YY_BUFFER_STATE) boot_yyalloc(sizeof( struct yy_buffer_state ) );
1680 1 : if ( ! b )
1681 0 : YY_FATAL_ERROR( "out of dynamic memory in boot_yy_create_buffer()" );
1682 :
1683 1 : b->yy_buf_size = size;
1684 :
1685 : /* yy_ch_buf has to be 2 characters longer than the size given because
1686 : * we need to put in 2 end-of-buffer characters.
1687 : */
1688 1 : b->yy_ch_buf = (char *) boot_yyalloc(b->yy_buf_size + 2 );
1689 1 : if ( ! b->yy_ch_buf )
1690 0 : YY_FATAL_ERROR( "out of dynamic memory in boot_yy_create_buffer()" );
1691 :
1692 1 : b->yy_is_our_buffer = 1;
1693 :
1694 1 : boot_yy_init_buffer(b,file );
1695 :
1696 1 : return b;
1697 : }
1698 :
1699 : /** Destroy the buffer.
1700 : * @param b a buffer created with boot_yy_create_buffer()
1701 : *
1702 : */
1703 0 : void boot_yy_delete_buffer (YY_BUFFER_STATE b )
1704 : {
1705 :
1706 0 : if ( ! b )
1707 0 : return;
1708 :
1709 0 : if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1710 0 : YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1711 :
1712 0 : if ( b->yy_is_our_buffer )
1713 0 : boot_yyfree((void *) b->yy_ch_buf );
1714 :
1715 0 : boot_yyfree((void *) b );
1716 : }
1717 :
1718 : /* Initializes or reinitializes a buffer.
1719 : * This function is sometimes called more than once on the same buffer,
1720 : * such as during a boot_yyrestart() or at EOF.
1721 : */
1722 2 : static void boot_yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1723 :
1724 : {
1725 2 : int oerrno = errno;
1726 :
1727 2 : boot_yy_flush_buffer(b );
1728 :
1729 2 : b->yy_input_file = file;
1730 2 : b->yy_fill_buffer = 1;
1731 :
1732 : /* If b is the current buffer, then boot_yy_init_buffer was _probably_
1733 : * called from boot_yyrestart() or through yy_get_next_buffer.
1734 : * In that case, we don't want to reset the lineno or column.
1735 : */
1736 2 : if (b != YY_CURRENT_BUFFER){
1737 1 : b->yy_bs_lineno = 1;
1738 1 : b->yy_bs_column = 0;
1739 : }
1740 :
1741 2 : b->yy_is_interactive = 0;
1742 :
1743 2 : errno = oerrno;
1744 2 : }
1745 :
1746 : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1747 : * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1748 : *
1749 : */
1750 2 : void boot_yy_flush_buffer (YY_BUFFER_STATE b )
1751 : {
1752 2 : if ( ! b )
1753 2 : return;
1754 :
1755 2 : b->yy_n_chars = 0;
1756 :
1757 : /* We always need two end-of-buffer characters. The first causes
1758 : * a transition to the end-of-buffer state. The second causes
1759 : * a jam in that state.
1760 : */
1761 2 : b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1762 2 : b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1763 :
1764 2 : b->yy_buf_pos = &b->yy_ch_buf[0];
1765 :
1766 2 : b->yy_at_bol = 1;
1767 2 : b->yy_buffer_status = YY_BUFFER_NEW;
1768 :
1769 2 : if ( b == YY_CURRENT_BUFFER )
1770 1 : boot_yy_load_buffer_state( );
1771 : }
1772 :
1773 : /** Pushes the new state onto the stack. The new state becomes
1774 : * the current state. This function will allocate the stack
1775 : * if necessary.
1776 : * @param new_buffer The new state.
1777 : *
1778 : */
1779 0 : void boot_yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1780 : {
1781 0 : if (new_buffer == NULL)
1782 0 : return;
1783 :
1784 0 : boot_yyensure_buffer_stack();
1785 :
1786 : /* This block is copied from boot_yy_switch_to_buffer. */
1787 0 : if ( YY_CURRENT_BUFFER )
1788 : {
1789 : /* Flush out information for old buffer. */
1790 0 : *(yy_c_buf_p) = (yy_hold_char);
1791 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1792 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1793 : }
1794 :
1795 : /* Only push if top exists. Otherwise, replace top. */
1796 0 : if (YY_CURRENT_BUFFER)
1797 0 : (yy_buffer_stack_top)++;
1798 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1799 :
1800 : /* copied from boot_yy_switch_to_buffer. */
1801 0 : boot_yy_load_buffer_state( );
1802 0 : (yy_did_buffer_switch_on_eof) = 1;
1803 : }
1804 :
1805 : /** Removes and deletes the top of the stack, if present.
1806 : * The next element becomes the new top.
1807 : *
1808 : */
1809 0 : void boot_yypop_buffer_state (void)
1810 : {
1811 0 : if (!YY_CURRENT_BUFFER)
1812 0 : return;
1813 :
1814 0 : boot_yy_delete_buffer(YY_CURRENT_BUFFER );
1815 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
1816 0 : if ((yy_buffer_stack_top) > 0)
1817 0 : --(yy_buffer_stack_top);
1818 :
1819 0 : if (YY_CURRENT_BUFFER) {
1820 0 : boot_yy_load_buffer_state( );
1821 0 : (yy_did_buffer_switch_on_eof) = 1;
1822 : }
1823 : }
1824 :
1825 : /* Allocates the stack if it does not exist.
1826 : * Guarantees space for at least one push.
1827 : */
1828 1 : static void boot_yyensure_buffer_stack (void)
1829 : {
1830 : yy_size_t num_to_alloc;
1831 :
1832 1 : if (!(yy_buffer_stack)) {
1833 :
1834 : /* First allocation is just for 2 elements, since we don't know if this
1835 : * scanner will even need a stack. We use 2 instead of 1 to avoid an
1836 : * immediate realloc on the next call.
1837 : */
1838 1 : num_to_alloc = 1;
1839 1 : (yy_buffer_stack) = (struct yy_buffer_state**)boot_yyalloc
1840 : (num_to_alloc * sizeof(struct yy_buffer_state*)
1841 : );
1842 1 : if ( ! (yy_buffer_stack) )
1843 0 : YY_FATAL_ERROR( "out of dynamic memory in boot_yyensure_buffer_stack()" );
1844 :
1845 1 : memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1846 :
1847 1 : (yy_buffer_stack_max) = num_to_alloc;
1848 1 : (yy_buffer_stack_top) = 0;
1849 2 : return;
1850 : }
1851 :
1852 0 : if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1853 :
1854 : /* Increase the buffer to prepare for a possible push. */
1855 0 : int grow_size = 8 /* arbitrary grow size */;
1856 :
1857 0 : num_to_alloc = (yy_buffer_stack_max) + grow_size;
1858 0 : (yy_buffer_stack) = (struct yy_buffer_state**)boot_yyrealloc
1859 : ((yy_buffer_stack),
1860 : num_to_alloc * sizeof(struct yy_buffer_state*)
1861 : );
1862 0 : if ( ! (yy_buffer_stack) )
1863 0 : YY_FATAL_ERROR( "out of dynamic memory in boot_yyensure_buffer_stack()" );
1864 :
1865 : /* zero only the new slots.*/
1866 0 : memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1867 0 : (yy_buffer_stack_max) = num_to_alloc;
1868 : }
1869 : }
1870 :
1871 : /** Setup the input buffer state to scan directly from a user-specified character buffer.
1872 : * @param base the character buffer
1873 : * @param size the size in bytes of the character buffer
1874 : *
1875 : * @return the newly allocated buffer state object.
1876 : */
1877 0 : YY_BUFFER_STATE boot_yy_scan_buffer (char * base, yy_size_t size )
1878 : {
1879 : YY_BUFFER_STATE b;
1880 :
1881 0 : if ( size < 2 ||
1882 0 : base[size-2] != YY_END_OF_BUFFER_CHAR ||
1883 0 : base[size-1] != YY_END_OF_BUFFER_CHAR )
1884 : /* They forgot to leave room for the EOB's. */
1885 0 : return 0;
1886 :
1887 0 : b = (YY_BUFFER_STATE) boot_yyalloc(sizeof( struct yy_buffer_state ) );
1888 0 : if ( ! b )
1889 0 : YY_FATAL_ERROR( "out of dynamic memory in boot_yy_scan_buffer()" );
1890 :
1891 0 : b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1892 0 : b->yy_buf_pos = b->yy_ch_buf = base;
1893 0 : b->yy_is_our_buffer = 0;
1894 0 : b->yy_input_file = 0;
1895 0 : b->yy_n_chars = b->yy_buf_size;
1896 0 : b->yy_is_interactive = 0;
1897 0 : b->yy_at_bol = 1;
1898 0 : b->yy_fill_buffer = 0;
1899 0 : b->yy_buffer_status = YY_BUFFER_NEW;
1900 :
1901 0 : boot_yy_switch_to_buffer(b );
1902 :
1903 0 : return b;
1904 : }
1905 :
1906 : /** Setup the input buffer state to scan a string. The next call to boot_yylex() will
1907 : * scan from a @e copy of @a str.
1908 : * @param yystr a NUL-terminated string to scan
1909 : *
1910 : * @return the newly allocated buffer state object.
1911 : * @note If you want to scan bytes that may contain NUL values, then use
1912 : * boot_yy_scan_bytes() instead.
1913 : */
1914 0 : YY_BUFFER_STATE boot_yy_scan_string (yyconst char * yystr )
1915 : {
1916 :
1917 0 : return boot_yy_scan_bytes(yystr,strlen(yystr) );
1918 : }
1919 :
1920 : /** Setup the input buffer state to scan the given bytes. The next call to boot_yylex() will
1921 : * scan from a @e copy of @a bytes.
1922 : * @param yybytes the byte buffer to scan
1923 : * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1924 : *
1925 : * @return the newly allocated buffer state object.
1926 : */
1927 0 : YY_BUFFER_STATE boot_yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
1928 : {
1929 : YY_BUFFER_STATE b;
1930 : char *buf;
1931 : yy_size_t n;
1932 : yy_size_t i;
1933 :
1934 : /* Get memory for full buffer, including space for trailing EOB's. */
1935 0 : n = _yybytes_len + 2;
1936 0 : buf = (char *) boot_yyalloc(n );
1937 0 : if ( ! buf )
1938 0 : YY_FATAL_ERROR( "out of dynamic memory in boot_yy_scan_bytes()" );
1939 :
1940 0 : for ( i = 0; i < _yybytes_len; ++i )
1941 0 : buf[i] = yybytes[i];
1942 :
1943 0 : buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1944 :
1945 0 : b = boot_yy_scan_buffer(buf,n );
1946 0 : if ( ! b )
1947 0 : YY_FATAL_ERROR( "bad buffer in boot_yy_scan_bytes()" );
1948 :
1949 : /* It's okay to grow etc. this buffer, and we should throw it
1950 : * away when we're done.
1951 : */
1952 0 : b->yy_is_our_buffer = 1;
1953 :
1954 0 : return b;
1955 : }
1956 :
1957 : #ifndef YY_EXIT_FAILURE
1958 : #define YY_EXIT_FAILURE 2
1959 : #endif
1960 :
1961 0 : static void yy_fatal_error (yyconst char* msg )
1962 : {
1963 0 : (void) fprintf( stderr, "%s\n", msg );
1964 0 : exit( YY_EXIT_FAILURE );
1965 : }
1966 :
1967 : /* Redefine yyless() so it works in section 3 code. */
1968 :
1969 : #undef yyless
1970 : #define yyless(n) \
1971 : do \
1972 : { \
1973 : /* Undo effects of setting up boot_yytext. */ \
1974 : int yyless_macro_arg = (n); \
1975 : YY_LESS_LINENO(yyless_macro_arg);\
1976 : boot_yytext[boot_yyleng] = (yy_hold_char); \
1977 : (yy_c_buf_p) = boot_yytext + yyless_macro_arg; \
1978 : (yy_hold_char) = *(yy_c_buf_p); \
1979 : *(yy_c_buf_p) = '\0'; \
1980 : boot_yyleng = yyless_macro_arg; \
1981 : } \
1982 : while ( 0 )
1983 :
1984 : /* Accessor methods (get/set functions) to struct members. */
1985 :
1986 : /** Get the current line number.
1987 : *
1988 : */
1989 0 : int boot_yyget_lineno (void)
1990 : {
1991 :
1992 0 : return boot_yylineno;
1993 : }
1994 :
1995 : /** Get the input stream.
1996 : *
1997 : */
1998 0 : FILE *boot_yyget_in (void)
1999 : {
2000 0 : return boot_yyin;
2001 : }
2002 :
2003 : /** Get the output stream.
2004 : *
2005 : */
2006 0 : FILE *boot_yyget_out (void)
2007 : {
2008 0 : return boot_yyout;
2009 : }
2010 :
2011 : /** Get the length of the current token.
2012 : *
2013 : */
2014 0 : yy_size_t boot_yyget_leng (void)
2015 : {
2016 0 : return boot_yyleng;
2017 : }
2018 :
2019 : /** Get the current token.
2020 : *
2021 : */
2022 :
2023 0 : char *boot_yyget_text (void)
2024 : {
2025 0 : return boot_yytext;
2026 : }
2027 :
2028 : /** Set the current line number.
2029 : * @param line_number
2030 : *
2031 : */
2032 0 : void boot_yyset_lineno (int line_number )
2033 : {
2034 :
2035 0 : boot_yylineno = line_number;
2036 0 : }
2037 :
2038 : /** Set the input stream. This does not discard the current
2039 : * input buffer.
2040 : * @param in_str A readable stream.
2041 : *
2042 : * @see boot_yy_switch_to_buffer
2043 : */
2044 0 : void boot_yyset_in (FILE * in_str )
2045 : {
2046 0 : boot_yyin = in_str ;
2047 0 : }
2048 :
2049 0 : void boot_yyset_out (FILE * out_str )
2050 : {
2051 0 : boot_yyout = out_str ;
2052 0 : }
2053 :
2054 0 : int boot_yyget_debug (void)
2055 : {
2056 0 : return boot_yy_flex_debug;
2057 : }
2058 :
2059 0 : void boot_yyset_debug (int bdebug )
2060 : {
2061 0 : boot_yy_flex_debug = bdebug ;
2062 0 : }
2063 :
2064 0 : static int yy_init_globals (void)
2065 : {
2066 : /* Initialization is the same as for the non-reentrant scanner.
2067 : * This function is called from boot_yylex_destroy(), so don't allocate here.
2068 : */
2069 :
2070 0 : (yy_buffer_stack) = 0;
2071 0 : (yy_buffer_stack_top) = 0;
2072 0 : (yy_buffer_stack_max) = 0;
2073 0 : (yy_c_buf_p) = (char *) 0;
2074 0 : (yy_init) = 0;
2075 0 : (yy_start) = 0;
2076 :
2077 : /* Defined in main.c */
2078 : #ifdef YY_STDINIT
2079 : boot_yyin = stdin;
2080 : boot_yyout = stdout;
2081 : #else
2082 0 : boot_yyin = (FILE *) 0;
2083 0 : boot_yyout = (FILE *) 0;
2084 : #endif
2085 :
2086 : /* For future reference: Set errno on error, since we are called by
2087 : * boot_yylex_init()
2088 : */
2089 0 : return 0;
2090 : }
2091 :
2092 : /* boot_yylex_destroy is for both reentrant and non-reentrant scanners. */
2093 0 : int boot_yylex_destroy (void)
2094 : {
2095 :
2096 : /* Pop the buffer stack, destroying each element. */
2097 0 : while(YY_CURRENT_BUFFER){
2098 0 : boot_yy_delete_buffer(YY_CURRENT_BUFFER );
2099 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2100 0 : boot_yypop_buffer_state();
2101 : }
2102 :
2103 : /* Destroy the stack itself. */
2104 0 : boot_yyfree((yy_buffer_stack) );
2105 0 : (yy_buffer_stack) = NULL;
2106 :
2107 : /* Reset the globals. This is important in a non-reentrant scanner so the next time
2108 : * boot_yylex() is called, initialization will occur. */
2109 0 : yy_init_globals( );
2110 :
2111 0 : return 0;
2112 : }
2113 :
2114 : /*
2115 : * Internal utility routines.
2116 : */
2117 :
2118 : #ifndef yytext_ptr
2119 : static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2120 : {
2121 : register int i;
2122 : for ( i = 0; i < n; ++i )
2123 : s1[i] = s2[i];
2124 : }
2125 : #endif
2126 :
2127 : #ifdef YY_NEED_STRLEN
2128 : static int yy_flex_strlen (yyconst char * s )
2129 : {
2130 : register int n;
2131 : for ( n = 0; s[n]; ++n )
2132 : ;
2133 :
2134 : return n;
2135 : }
2136 : #endif
2137 :
2138 3 : void *boot_yyalloc (yy_size_t size )
2139 : {
2140 3 : return (void *) malloc( size );
2141 : }
2142 :
2143 0 : void *boot_yyrealloc (void * ptr, yy_size_t size )
2144 : {
2145 : /* The cast to (char *) in the following accommodates both
2146 : * implementations that use char* generic pointers, and those
2147 : * that use void* generic pointers. It works with the latter
2148 : * because both ANSI C and C++ allow castless assignment from
2149 : * any pointer type to void*, and deal with argument conversions
2150 : * as though doing an assignment.
2151 : */
2152 0 : return (void *) realloc( (char *) ptr, size );
2153 : }
2154 :
2155 0 : void boot_yyfree (void * ptr )
2156 : {
2157 0 : free( (char *) ptr ); /* see boot_yyrealloc() for (char *) cast */
2158 0 : }
2159 :
2160 : #define YYTABLES_NAME "yytables"
2161 :
2162 : #line 134 "bootscanner.l"
2163 :
2164 :
2165 :
2166 : void
2167 : yyerror(const char *message)
2168 : {
2169 : elog(ERROR, "%s at line %d", message, yyline);
2170 : }
2171 :
|
