1 #line 2 "pgc.c"
2 /*-------------------------------------------------------------------------
3 *
4 * pgc.l
5 * lexical scanner for ecpg
6 *
7 * This is a modified version of src/backend/parser/scan.l
8 *
9 *
10 * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
11 * Portions Copyright (c) 1994, Regents of the University of California
12 *
13 *
14 * IDENTIFICATION
15 * src/interfaces/ecpg/preproc/pgc.l
16 *
17 *-------------------------------------------------------------------------
18 */
19 #include "postgres_fe.h"
20
21 #include <ctype.h>
22 #include <limits.h>
23
24 #include "common/string.h"
25
26 #include "extern.h"
27 #include "preproc.h"
28
29 #line 30 "pgc.c"
30
31 #define YY_INT_ALIGNED short int
32
33 /* A lexical scanner generated by flex */
34
35 #define yy_create_buffer base_yy_create_buffer
36 #define yy_delete_buffer base_yy_delete_buffer
37 #define yy_scan_buffer base_yy_scan_buffer
38 #define yy_scan_string base_yy_scan_string
39 #define yy_scan_bytes base_yy_scan_bytes
40 #define yy_init_buffer base_yy_init_buffer
41 #define yy_flush_buffer base_yy_flush_buffer
42 #define yy_load_buffer_state base_yy_load_buffer_state
43 #define yy_switch_to_buffer base_yy_switch_to_buffer
44 #define yypush_buffer_state base_yypush_buffer_state
45 #define yypop_buffer_state base_yypop_buffer_state
46 #define yyensure_buffer_stack base_yyensure_buffer_stack
47 #define yy_flex_debug base_yy_flex_debug
48 #define yyin base_yyin
49 #define yyleng base_yyleng
50 #define yylex base_yylex
51 #define yylineno base_yylineno
52 #define yyout base_yyout
53 #define yyrestart base_yyrestart
54 #define yytext base_yytext
55 #define yywrap base_yywrap
56 #define yyalloc base_yyalloc
57 #define yyrealloc base_yyrealloc
58 #define yyfree base_yyfree
59
60 #define FLEX_SCANNER
61 #define YY_FLEX_MAJOR_VERSION 2
62 #define YY_FLEX_MINOR_VERSION 6
63 #define YY_FLEX_SUBMINOR_VERSION 4
64 #if YY_FLEX_SUBMINOR_VERSION > 0
65 #define FLEX_BETA
66 #endif
67
68 #ifdef yy_create_buffer
69 #define base_yy_create_buffer_ALREADY_DEFINED
70 #else
71 #define yy_create_buffer base_yy_create_buffer
72 #endif
73
74 #ifdef yy_delete_buffer
75 #define base_yy_delete_buffer_ALREADY_DEFINED
76 #else
77 #define yy_delete_buffer base_yy_delete_buffer
78 #endif
79
80 #ifdef yy_scan_buffer
81 #define base_yy_scan_buffer_ALREADY_DEFINED
82 #else
83 #define yy_scan_buffer base_yy_scan_buffer
84 #endif
85
86 #ifdef yy_scan_string
87 #define base_yy_scan_string_ALREADY_DEFINED
88 #else
89 #define yy_scan_string base_yy_scan_string
90 #endif
91
92 #ifdef yy_scan_bytes
93 #define base_yy_scan_bytes_ALREADY_DEFINED
94 #else
95 #define yy_scan_bytes base_yy_scan_bytes
96 #endif
97
98 #ifdef yy_init_buffer
99 #define base_yy_init_buffer_ALREADY_DEFINED
100 #else
101 #define yy_init_buffer base_yy_init_buffer
102 #endif
103
104 #ifdef yy_flush_buffer
105 #define base_yy_flush_buffer_ALREADY_DEFINED
106 #else
107 #define yy_flush_buffer base_yy_flush_buffer
108 #endif
109
110 #ifdef yy_load_buffer_state
111 #define base_yy_load_buffer_state_ALREADY_DEFINED
112 #else
113 #define yy_load_buffer_state base_yy_load_buffer_state
114 #endif
115
116 #ifdef yy_switch_to_buffer
117 #define base_yy_switch_to_buffer_ALREADY_DEFINED
118 #else
119 #define yy_switch_to_buffer base_yy_switch_to_buffer
120 #endif
121
122 #ifdef yypush_buffer_state
123 #define base_yypush_buffer_state_ALREADY_DEFINED
124 #else
125 #define yypush_buffer_state base_yypush_buffer_state
126 #endif
127
128 #ifdef yypop_buffer_state
129 #define base_yypop_buffer_state_ALREADY_DEFINED
130 #else
131 #define yypop_buffer_state base_yypop_buffer_state
132 #endif
133
134 #ifdef yyensure_buffer_stack
135 #define base_yyensure_buffer_stack_ALREADY_DEFINED
136 #else
137 #define yyensure_buffer_stack base_yyensure_buffer_stack
138 #endif
139
140 #ifdef yylex
141 #define base_yylex_ALREADY_DEFINED
142 #else
143 #define yylex base_yylex
144 #endif
145
146 #ifdef yyrestart
147 #define base_yyrestart_ALREADY_DEFINED
148 #else
149 #define yyrestart base_yyrestart
150 #endif
151
152 #ifdef yylex_init
153 #define base_yylex_init_ALREADY_DEFINED
154 #else
155 #define yylex_init base_yylex_init
156 #endif
157
158 #ifdef yylex_init_extra
159 #define base_yylex_init_extra_ALREADY_DEFINED
160 #else
161 #define yylex_init_extra base_yylex_init_extra
162 #endif
163
164 #ifdef yylex_destroy
165 #define base_yylex_destroy_ALREADY_DEFINED
166 #else
167 #define yylex_destroy base_yylex_destroy
168 #endif
169
170 #ifdef yyget_debug
171 #define base_yyget_debug_ALREADY_DEFINED
172 #else
173 #define yyget_debug base_yyget_debug
174 #endif
175
176 #ifdef yyset_debug
177 #define base_yyset_debug_ALREADY_DEFINED
178 #else
179 #define yyset_debug base_yyset_debug
180 #endif
181
182 #ifdef yyget_extra
183 #define base_yyget_extra_ALREADY_DEFINED
184 #else
185 #define yyget_extra base_yyget_extra
186 #endif
187
188 #ifdef yyset_extra
189 #define base_yyset_extra_ALREADY_DEFINED
190 #else
191 #define yyset_extra base_yyset_extra
192 #endif
193
194 #ifdef yyget_in
195 #define base_yyget_in_ALREADY_DEFINED
196 #else
197 #define yyget_in base_yyget_in
198 #endif
199
200 #ifdef yyset_in
201 #define base_yyset_in_ALREADY_DEFINED
202 #else
203 #define yyset_in base_yyset_in
204 #endif
205
206 #ifdef yyget_out
207 #define base_yyget_out_ALREADY_DEFINED
208 #else
209 #define yyget_out base_yyget_out
210 #endif
211
212 #ifdef yyset_out
213 #define base_yyset_out_ALREADY_DEFINED
214 #else
215 #define yyset_out base_yyset_out
216 #endif
217
218 #ifdef yyget_leng
219 #define base_yyget_leng_ALREADY_DEFINED
220 #else
221 #define yyget_leng base_yyget_leng
222 #endif
223
224 #ifdef yyget_text
225 #define base_yyget_text_ALREADY_DEFINED
226 #else
227 #define yyget_text base_yyget_text
228 #endif
229
230 #ifdef yyget_lineno
231 #define base_yyget_lineno_ALREADY_DEFINED
232 #else
233 #define yyget_lineno base_yyget_lineno
234 #endif
235
236 #ifdef yyset_lineno
237 #define base_yyset_lineno_ALREADY_DEFINED
238 #else
239 #define yyset_lineno base_yyset_lineno
240 #endif
241
242 #ifdef yywrap
243 #define base_yywrap_ALREADY_DEFINED
244 #else
245 #define yywrap base_yywrap
246 #endif
247
248 #ifdef yyalloc
249 #define base_yyalloc_ALREADY_DEFINED
250 #else
251 #define yyalloc base_yyalloc
252 #endif
253
254 #ifdef yyrealloc
255 #define base_yyrealloc_ALREADY_DEFINED
256 #else
257 #define yyrealloc base_yyrealloc
258 #endif
259
260 #ifdef yyfree
261 #define base_yyfree_ALREADY_DEFINED
262 #else
263 #define yyfree base_yyfree
264 #endif
265
266 #ifdef yytext
267 #define base_yytext_ALREADY_DEFINED
268 #else
269 #define yytext base_yytext
270 #endif
271
272 #ifdef yyleng
273 #define base_yyleng_ALREADY_DEFINED
274 #else
275 #define yyleng base_yyleng
276 #endif
277
278 #ifdef yyin
279 #define base_yyin_ALREADY_DEFINED
280 #else
281 #define yyin base_yyin
282 #endif
283
284 #ifdef yyout
285 #define base_yyout_ALREADY_DEFINED
286 #else
287 #define yyout base_yyout
288 #endif
289
290 #ifdef yy_flex_debug
291 #define base_yy_flex_debug_ALREADY_DEFINED
292 #else
293 #define yy_flex_debug base_yy_flex_debug
294 #endif
295
296 #ifdef yylineno
297 #define base_yylineno_ALREADY_DEFINED
298 #else
299 #define yylineno base_yylineno
300 #endif
301
302 /* First, we deal with platform-specific or compiler-specific issues. */
303
304 /* begin standard C headers. */
305 #include <stdio.h>
306 #include <string.h>
307 #include <errno.h>
308 #include <stdlib.h>
309
310 /* end standard C headers. */
311
312 /* flex integer type definitions */
313
314 #ifndef FLEXINT_H
315 #define FLEXINT_H
316
317 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
318
319 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
320
321 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
322 * if you want the limit (max/min) macros for int types.
323 */
324 #ifndef __STDC_LIMIT_MACROS
325 #define __STDC_LIMIT_MACROS 1
326 #endif
327
328 #include <inttypes.h>
329 typedef int8_t flex_int8_t;
330 typedef uint8_t flex_uint8_t;
331 typedef int16_t flex_int16_t;
332 typedef uint16_t flex_uint16_t;
333 typedef int32_t flex_int32_t;
334 typedef uint32_t flex_uint32_t;
335 #else
336 typedef signed char flex_int8_t;
337 typedef short int flex_int16_t;
338 typedef int flex_int32_t;
339 typedef unsigned char flex_uint8_t;
340 typedef unsigned short int flex_uint16_t;
341 typedef unsigned int flex_uint32_t;
342
343 /* Limits of integral types. */
344 #ifndef INT8_MIN
345 #define INT8_MIN (-128)
346 #endif
347 #ifndef INT16_MIN
348 #define INT16_MIN (-32767-1)
349 #endif
350 #ifndef INT32_MIN
351 #define INT32_MIN (-2147483647-1)
352 #endif
353 #ifndef INT8_MAX
354 #define INT8_MAX (127)
355 #endif
356 #ifndef INT16_MAX
357 #define INT16_MAX (32767)
358 #endif
359 #ifndef INT32_MAX
360 #define INT32_MAX (2147483647)
361 #endif
362 #ifndef UINT8_MAX
363 #define UINT8_MAX (255U)
364 #endif
365 #ifndef UINT16_MAX
366 #define UINT16_MAX (65535U)
367 #endif
368 #ifndef UINT32_MAX
369 #define UINT32_MAX (4294967295U)
370 #endif
371
372 #ifndef SIZE_MAX
373 #define SIZE_MAX (~(size_t)0)
374 #endif
375
376 #endif /* ! C99 */
377
378 #endif /* ! FLEXINT_H */
379
380 /* begin standard C++ headers. */
381
382 /* TODO: this is always defined, so inline it */
383 #define yyconst const
384
385 #if defined(__GNUC__) && __GNUC__ >= 3
386 #define yynoreturn __attribute__((__noreturn__))
387 #else
388 #define yynoreturn
389 #endif
390
391 /* Returned upon end-of-file. */
392 #define YY_NULL 0
393
394 /* Promotes a possibly negative, possibly signed char to an
395 * integer in range [0..255] for use as an array index.
396 */
397 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
398
399 /* Enter a start condition. This macro really ought to take a parameter,
400 * but we do it the disgusting crufty way forced on us by the ()-less
401 * definition of BEGIN.
402 */
403 #define BEGIN (yy_start) = 1 + 2 *
404 /* Translate the current start state into a value that can be later handed
405 * to BEGIN to return to the state. The YYSTATE alias is for lex
406 * compatibility.
407 */
408 #define YY_START (((yy_start) - 1) / 2)
409 #define YYSTATE YY_START
410 /* Action number for EOF rule of a given start state. */
411 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
412 /* Special action meaning "start processing a new file". */
413 #define YY_NEW_FILE yyrestart( yyin )
414 #define YY_END_OF_BUFFER_CHAR 0
415
416 /* Size of default input buffer. */
417 #ifndef YY_BUF_SIZE
418 #ifdef __ia64__
419 /* On IA-64, the buffer size is 16k, not 8k.
420 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
421 * Ditto for the __ia64__ case accordingly.
422 */
423 #define YY_BUF_SIZE 32768
424 #else
425 #define YY_BUF_SIZE 16384
426 #endif /* __ia64__ */
427 #endif
428
429 /* The state buf must be large enough to hold one state per character in the main buffer.
430 */
431 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
432
433 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
434 #define YY_TYPEDEF_YY_BUFFER_STATE
435 typedef struct yy_buffer_state *YY_BUFFER_STATE;
436 #endif
437
438 #ifndef YY_TYPEDEF_YY_SIZE_T
439 #define YY_TYPEDEF_YY_SIZE_T
440 typedef size_t yy_size_t;
441 #endif
442
443 extern int yyleng;
444
445 extern FILE *yyin, *yyout;
446
447 #define EOB_ACT_CONTINUE_SCAN 0
448 #define EOB_ACT_END_OF_FILE 1
449 #define EOB_ACT_LAST_MATCH 2
450
451 /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
452 * access to the local variable yy_act. Since yyless() is a macro, it would break
453 * existing scanners that call yyless() from OUTSIDE yylex.
454 * One obvious solution it to make yy_act a global. I tried that, and saw
455 * a 5% performance hit in a non-yylineno scanner, because yy_act is
456 * normally declared as a register variable-- so it is not worth it.
457 */
458 #define YY_LESS_LINENO(n) \
459 do { \
460 int yyl;\
461 for ( yyl = n; yyl < yyleng; ++yyl )\
462 if ( yytext[yyl] == '\n' )\
463 --yylineno;\
464 }while(0)
465 #define YY_LINENO_REWIND_TO(dst) \
466 do {\
467 const char *p;\
468 for ( p = yy_cp-1; p >= (dst); --p)\
469 if ( *p == '\n' )\
470 --yylineno;\
471 }while(0)
472
473 /* Return all but the first "n" matched characters back to the input stream. */
474 #define yyless(n) \
475 do \
476 { \
477 /* Undo effects of setting up yytext. */ \
478 int yyless_macro_arg = (n); \
479 YY_LESS_LINENO(yyless_macro_arg);\
480 *yy_cp = (yy_hold_char); \
481 YY_RESTORE_YY_MORE_OFFSET \
482 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
483 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
484 } \
485 while ( 0 )
486 #define unput(c) yyunput( c, (yytext_ptr) )
487
488 #ifndef YY_STRUCT_YY_BUFFER_STATE
489 #define YY_STRUCT_YY_BUFFER_STATE
490 struct yy_buffer_state
491 {
492 FILE *yy_input_file;
493
494 char *yy_ch_buf; /* input buffer */
495 char *yy_buf_pos; /* current position in input buffer */
496
497 /* Size of input buffer in bytes, not including room for EOB
498 * characters.
499 */
500 int yy_buf_size;
501
502 /* Number of characters read into yy_ch_buf, not including EOB
503 * characters.
504 */
505 int yy_n_chars;
506
507 /* Whether we "own" the buffer - i.e., we know we created it,
508 * and can realloc() it to grow it, and should free() it to
509 * delete it.
510 */
511 int yy_is_our_buffer;
512
513 /* Whether this is an "interactive" input source; if so, and
514 * if we're using stdio for input, then we want to use getc()
515 * instead of fread(), to make sure we stop fetching input after
516 * each newline.
517 */
518 int yy_is_interactive;
519
520 /* Whether we're considered to be at the beginning of a line.
521 * If so, '^' rules will be active on the next match, otherwise
522 * not.
523 */
524 int yy_at_bol;
525
526 int yy_bs_lineno; /**< The line count. */
527 int yy_bs_column; /**< The column count. */
528
529 /* Whether to try to fill the input buffer when we reach the
530 * end of it.
531 */
532 int yy_fill_buffer;
533
534 int yy_buffer_status;
535
536 #define YY_BUFFER_NEW 0
537 #define YY_BUFFER_NORMAL 1
538 /* When an EOF's been seen but there's still some text to process
539 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
540 * shouldn't try reading from the input source any more. We might
541 * still have a bunch of tokens to match, though, because of
542 * possible backing-up.
543 *
544 * When we actually see the EOF, we change the status to "new"
545 * (via yyrestart()), so that the user can continue scanning by
546 * just pointing yyin at a new input file.
547 */
548 #define YY_BUFFER_EOF_PENDING 2
549
550 };
551 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
552
553 /* Stack of input buffers. */
554 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
555 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
556 static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
557
558 /* We provide macros for accessing buffer states in case in the
559 * future we want to put the buffer states in a more general
560 * "scanner state".
561 *
562 * Returns the top of the stack, or NULL.
563 */
564 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
565 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
566 : NULL)
567 /* Same as previous macro, but useful when we know that the buffer stack is not
568 * NULL or when we need an lvalue. For internal use only.
569 */
570 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
571
572 /* yy_hold_char holds the character lost when yytext is formed. */
573 static char yy_hold_char;
574 static int yy_n_chars; /* number of characters read into yy_ch_buf */
575 int yyleng;
576
577 /* Points to current character in buffer. */
578 static char *yy_c_buf_p = NULL;
579 static int yy_init = 0; /* whether we need to initialize */
580 static int yy_start = 0; /* start state number */
581
582 /* Flag which is used to allow yywrap()'s to do buffer switches
583 * instead of setting up a fresh yyin. A bit of a hack ...
584 */
585 static int yy_did_buffer_switch_on_eof;
586
587 void yyrestart ( FILE *input_file );
588 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
589 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
590 void yy_delete_buffer ( YY_BUFFER_STATE b );
591 void yy_flush_buffer ( YY_BUFFER_STATE b );
592 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
593 void yypop_buffer_state ( void );
594
595 static void yyensure_buffer_stack ( void );
596 static void yy_load_buffer_state ( void );
597 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
598 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
599
600 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
601 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
602 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
603
604 void *yyalloc ( yy_size_t );
605 void *yyrealloc ( void *, yy_size_t );
606 void yyfree ( void * );
607
608 #define yy_new_buffer yy_create_buffer
609 #define yy_set_interactive(is_interactive) \
610 { \
611 if ( ! YY_CURRENT_BUFFER ){ \
612 yyensure_buffer_stack (); \
613 YY_CURRENT_BUFFER_LVALUE = \
614 yy_create_buffer( yyin, YY_BUF_SIZE ); \
615 } \
616 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
617 }
618 #define yy_set_bol(at_bol) \
619 { \
620 if ( ! YY_CURRENT_BUFFER ){\
621 yyensure_buffer_stack (); \
622 YY_CURRENT_BUFFER_LVALUE = \
623 yy_create_buffer( yyin, YY_BUF_SIZE ); \
624 } \
625 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
626 }
627 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
628
629 /* Begin user sect3 */
630
631 #define base_yywrap() (/*CONSTCOND*/1)
632 #define YY_SKIP_YYWRAP
633 typedef flex_uint8_t YY_CHAR;
634
635 FILE *yyin = NULL, *yyout = NULL;
636
637 typedef int yy_state_type;
638
639 extern int yylineno;
640 int yylineno = 1;
641
642 extern char *yytext;
643 #ifdef yytext_ptr
644 #undef yytext_ptr
645 #endif
646 #define yytext_ptr yytext
647
648 static yy_state_type yy_get_previous_state ( void );
649 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
650 static int yy_get_next_buffer ( void );
651 static void yynoreturn yy_fatal_error ( const char* msg );
652
653 /* Done after the current pattern has been matched and before the
654 * corresponding action - sets up yytext.
655 */
656 #define YY_DO_BEFORE_ACTION \
657 (yytext_ptr) = yy_bp; \
658 yyleng = (int) (yy_cp - yy_bp); \
659 (yy_hold_char) = *yy_cp; \
660 *yy_cp = '\0'; \
661 (yy_c_buf_p) = yy_cp;
662 #define YY_NUM_RULES 151
663 #define YY_END_OF_BUFFER 152
664 /* This struct is not used in this scanner,
665 but its presence is necessary. */
666 struct yy_trans_info
667 {
668 flex_int32_t yy_verify;
669 flex_int32_t yy_nxt;
670 };
671 static const flex_int16_t yy_accept[831] =
672 { 0,
673 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
674 0, 0, 0, 0, 15, 15, 0, 0, 0, 0,
675 0, 0, 0, 0, 14, 14, 0, 0, 0, 0,
676 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
677 0, 0, 0, 0, 152, 150, 120, 98, 98, 120,
678 56, 120, 80, 92, 120, 22, 96, 97, 91, 94,
679 90, 95, 120, 93, 70, 70, 88, 89, 120, 103,
680 120, 86, 86, 101, 102, 99, 120, 100, 78, 1,
681 1, 68, 49, 68, 66, 67, 68, 23, 67, 67,
682 67, 67, 70, 67, 67, 67, 67, 77, 77, 77,
683
684 77, 77, 77, 149, 149, 149, 149, 145, 145, 144,
685 143, 142, 126, 126, 15, 12, 8, 8, 9, 9,
686 9, 9, 55, 51, 57, 52, 57, 14, 19, 36,
687 36, 28, 42, 35, 30, 26, 26, 35, 46, 46,
688 48, 141, 141, 139, 98, 98, 139, 139, 53, 32,
689 0, 0, 112, 0, 0, 0, 0, 0, 0, 0,
690 117, 108, 0, 87, 115, 109, 113, 110, 114, 104,
691 119, 72, 2, 0, 116, 72, 70, 0, 82, 106,
692 111, 105, 86, 86, 107, 1, 0, 68, 65, 68,
693 0, 0, 44, 69, 43, 1, 59, 72, 3, 72,
694
695 70, 74, 58, 60, 76, 62, 64, 61, 63, 77,
696 11, 24, 21, 0, 18, 0, 148, 0, 0, 0,
697 144, 142, 0, 0, 125, 15, 12, 12, 13, 8,
698 10, 7, 4, 10, 6, 5, 55, 54, 57, 14,
699 19, 19, 20, 36, 28, 28, 33, 29, 38, 39,
700 38, 38, 38, 35, 30, 30, 31, 26, 26, 27,
701 34, 46, 45, 47, 0, 0, 140, 0, 0, 0,
702 0, 0, 0, 0, 0, 0, 0, 85, 85, 0,
703 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
704 0, 0, 0, 0, 118, 2, 0, 81, 72, 0,
705
706 73, 82, 86, 68, 68, 43, 1, 1, 3, 72,
707 70, 75, 76, 0, 0, 0, 50, 25, 147, 146,
708 12, 17, 13, 12, 4, 5, 19, 16, 20, 19,
709 28, 41, 29, 28, 39, 0, 0, 40, 30, 31,
710 30, 26, 27, 26, 47, 0, 0, 0, 0, 0,
711 0, 0, 0, 0, 85, 85, 0, 0, 0, 0,
712 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
713 0, 0, 86, 68, 0, 72, 70, 76, 0, 0,
714 0, 76, 147, 147, 146, 146, 12, 12, 12, 12,
715 19, 19, 19, 19, 28, 28, 28, 28, 39, 0,
716
717 0, 40, 30, 30, 30, 30, 26, 26, 26, 26,
718 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
719 0, 0, 0, 85, 85, 0, 0, 0, 0, 0,
720 0, 0, 0, 0, 0, 0, 134, 0, 0, 0,
721 0, 0, 0, 0, 86, 68, 68, 0, 72, 72,
722 76, 0, 0, 0, 0, 12, 12, 12, 12, 12,
723 19, 19, 16, 19, 19, 28, 28, 28, 28, 28,
724 0, 0, 30, 30, 30, 30, 30, 26, 26, 26,
725 26, 26, 0, 0, 0, 0, 0, 0, 0, 41,
726 0, 0, 0, 0, 0, 0, 0, 0, 0, 85,
727
728 85, 0, 0, 0, 0, 0, 0, 0, 0, 0,
729 134, 0, 136, 0, 130, 0, 0, 124, 0, 86,
730 68, 0, 0, 72, 0, 0, 0, 0, 76, 76,
731 12, 19, 28, 0, 37, 30, 26, 0, 0, 0,
732 0, 0, 0, 0, 0, 0, 0, 122, 0, 138,
733 130, 132, 0, 124, 0, 79, 71, 0, 0, 0,
734 0, 0, 76, 0, 0, 0, 0, 0, 0, 0,
735 83, 83, 122, 132, 128, 79, 79, 86, 86, 86,
736 86, 71, 76, 0, 0, 0, 0, 0, 0, 0,
737 0, 0, 83, 83, 83, 0, 83, 0, 128, 0,
738
739 0, 0, 86, 86, 86, 86, 86, 86, 71, 76,
740 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
741 0, 0, 0, 0, 0, 0, 0, 0, 86, 86,
742 86, 86, 86, 86, 86, 86, 0, 0, 0, 0,
743 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
744 0, 0, 0, 86, 86, 86, 86, 86, 86, 86,
745 86, 133, 0, 0, 0, 0, 0, 0, 0, 0,
746 53, 0, 0, 0, 0, 0, 0, 0, 0, 0,
747 32, 0, 0, 0, 0, 0, 0, 0, 0, 0,
748 86, 133, 0, 135, 86, 86, 86, 86, 86, 0,
749
750 129, 0, 0, 0, 0, 0, 0, 0, 0, 0,
751 0, 0, 0, 0, 0, 0, 41, 0, 41, 0,
752 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
753 0, 84, 84, 0, 0, 123, 86, 0, 137, 129,
754 86, 86, 123, 131, 0, 53, 0, 0, 0, 0,
755 0, 53, 53, 0, 0, 0, 0, 0, 0, 0,
756 32, 32, 0, 0, 0, 0, 0, 32, 32, 84,
757 84, 84, 84, 121, 0, 121, 131, 86, 0, 0,
758 0, 0, 0, 0, 0, 0, 32, 0, 0, 41,
759 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
760
761 0, 127, 127, 53, 0, 0, 0, 0, 0, 0,
762 0, 0, 32, 32, 0, 0, 32, 0, 0, 0,
763 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
764 } ;
765
766 static const YY_CHAR yy_ec[256] =
767 { 0,
768 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
769 1, 2, 4, 1, 1, 1, 1, 1, 1, 1,
770 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
771 1, 2, 5, 6, 7, 8, 9, 10, 11, 12,
772 13, 14, 15, 16, 17, 18, 19, 20, 21, 21,
773 21, 21, 21, 21, 21, 22, 22, 23, 24, 25,
774 26, 27, 28, 28, 29, 30, 31, 32, 33, 34,
775 35, 35, 36, 35, 35, 37, 38, 39, 40, 41,
776 42, 43, 44, 45, 46, 35, 35, 47, 35, 35,
777 48, 49, 50, 51, 52, 28, 29, 30, 31, 32,
778
779 33, 34, 35, 35, 53, 35, 35, 37, 38, 39,
780 40, 41, 42, 43, 44, 45, 54, 35, 35, 55,
781 35, 35, 56, 57, 58, 28, 1, 59, 59, 59,
782 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
783 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
784 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
785 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
786 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
787 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
788 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
789
790 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
791 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
792 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
793 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
794 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
795 59, 59, 59, 59, 59
796 } ;
797
798 static const YY_CHAR yy_meta[60] =
799 { 0,
800 1, 2, 3, 3, 4, 5, 4, 6, 7, 4,
801 8, 9, 9, 10, 7, 1, 11, 12, 13, 14,
802 14, 14, 15, 16, 17, 18, 19, 4, 20, 20,
803 20, 20, 20, 20, 21, 21, 21, 21, 21, 21,
804 21, 21, 21, 21, 21, 21, 21, 12, 22, 9,
805 4, 21, 21, 21, 21, 1, 4, 1, 21
806 } ;
807
808 static const flex_int16_t yy_base[922] =
809 { 0,
810 0, 0, 0, 0, 59, 0, 113, 117, 122, 125,
811 149, 0, 208, 0, 1805, 1803, 263, 316, 116, 117,
812 1805, 1803, 263, 268, 1758, 1753, 273, 283, 1752, 1748,
813 1747, 1745, 260, 264, 131, 140, 373, 0, 294, 303,
814 1748, 1747, 1740, 1739, 1745, 5228, 5228, 297, 343, 1717,
815 5228, 257, 316, 1716, 1730, 5228, 5228, 5228, 289, 106,
816 5228, 302, 337, 342, 415, 420, 5228, 5228, 1713, 1711,
817 1708, 0, 232, 5228, 5228, 5228, 1675, 5228, 5228, 442,
818 448, 1704, 5228, 466, 439, 0, 0, 5228, 5228, 1712,
819 436, 1712, 445, 269, 311, 1697, 1695, 0, 1705, 1700,
820
821 1690, 1690, 1684, 1660, 0, 5228, 0, 5228, 484, 5228,
822 5228, 0, 5228, 494, 0, 497, 0, 0, 320, 1665,
823 341, 1654, 0, 1657, 5228, 5228, 275, 0, 503, 0,
824 0, 522, 483, 0, 532, 542, 538, 1641, 0, 0,
825 1639, 5228, 507, 5228, 5228, 5228, 436, 316, 548, 558,
826 564, 459, 5228, 612, 538, 540, 1609, 83, 400, 1592,
827 5228, 5228, 460, 5228, 5228, 5228, 5228, 5228, 5228, 1612,
828 5228, 560, 0, 1612, 5228, 563, 568, 588, 0, 5228,
829 5228, 5228, 0, 1572, 5228, 670, 477, 0, 0, 673,
830 430, 494, 5228, 344, 1591, 726, 5228, 578, 0, 664,
831
832 673, 687, 5228, 5228, 539, 0, 0, 0, 0, 0,
833 5228, 5228, 5228, 471, 5228, 1574, 5228, 1580, 1557, 708,
834 5228, 0, 713, 718, 5228, 0, 744, 753, 1546, 0,
835 502, 5228, 0, 508, 5228, 0, 0, 5228, 5228, 0,
836 756, 763, 1541, 0, 782, 785, 5228, 1534, 5228, 333,
837 0, 0, 0, 0, 788, 804, 1528, 807, 814, 1525,
838 5228, 0, 5228, 1533, 725, 810, 5228, 1496, 1493, 824,
839 1507, 1490, 833, 836, 1504, 1487, 862, 5228, 0, 1504,
840 0, 791, 531, 1476, 1469, 657, 1457, 1466, 1459, 807,
841 1455, 686, 1455, 1433, 5228, 0, 1454, 5228, 824, 834,
842
843 841, 0, 1420, 913, 1431, 1436, 0, 966, 0, 847,
844 853, 863, 696, 1412, 0, 908, 5228, 5228, 931, 941,
845 945, 5228, 1420, 949, 0, 0, 957, 5228, 1417, 984,
846 993, 5228, 1412, 996, 527, 0, 0, 0, 1003, 1410,
847 1022, 1025, 1407, 1028, 1415, 1390, 1031, 1373, 1047, 1397,
848 1050, 1369, 1043, 975, 1057, 1066, 1377, 1374, 1362, 1361,
849 1363, 1360, 1349, 1346, 726, 1348, 1344, 745, 1334, 1331,
850 1324, 1324, 1069, 1111, 1054, 1061, 1066, 721, 1105, 1129,
851 1139, 1146, 1087, 5228, 1149, 5228, 1155, 1167, 1173, 1178,
852 1189, 1184, 1195, 1200, 1205, 1211, 1216, 1221, 5228, 0,
853
854 0, 5228, 1228, 1232, 1238, 1244, 1248, 1254, 1260, 1264,
855 1270, 1276, 1280, 1283, 1286, 1324, 1304, 1292, 1308, 1314,
856 1339, 1316, 1345, 1331, 1362, 578, 1376, 1310, 1306, 1293,
857 680, 1301, 1300, 1285, 717, 1288, 1349, 1367, 1290, 1289,
858 1287, 722, 1279, 1371, 1263, 0, 1421, 1366, 1379, 1383,
859 841, 1478, 1405, 1535, 1416, 1439, 1450, 1460, 1488, 1456,
860 1505, 1508, 1529, 1589, 1593, 1600, 1605, 1610, 1621, 1616,
861 0, 0, 1626, 1637, 1642, 1647, 1653, 1658, 1663, 1674,
862 1679, 1669, 1557, 1262, 1685, 1690, 1273, 1695, 1706, 1711,
863 1716, 1744, 1764, 1769, 1272, 1285, 662, 1284, 1780, 1789,
864
865 1793, 0, 1258, 1246, 1244, 0, 1241, 1225, 1237, 1227,
866 1466, 1472, 5228, 1701, 1511, 1220, 1221, 1632, 1202, 1206,
867 858, 1754, 1767, 1784, 1842, 0, 0, 1220, 919, 1899,
868 1817, 1822, 1852, 0, 5228, 1869, 1872, 1192, 1833, 1186,
869 1917, 1920, 1936, 1185, 1188, 0, 1177, 1776, 1798, 5228,
870 1828, 1858, 1152, 1892, 1146, 1989, 1884, 1160, 1157, 755,
871 2015, 0, 2073, 0, 1942, 1948, 1132, 2062, 1952, 1121,
872 1955, 1958, 1939, 1981, 1984, 2122, 0, 1114, 108, 842,
873 1106, 1979, 2176, 0, 2094, 246, 1110, 2102, 2001, 2111,
874 2234, 2012, 2024, 2028, 2034, 1088, 2037, 1085, 2099, 1086,
875
876 880, 1071, 1071, 910, 1070, 765, 1067, 1065, 5228, 0,
877 0, 1059, 1048, 790, 2237, 2133, 0, 1061, 2241, 2244,
878 2149, 0, 1049, 1032, 1030, 1006, 990, 976, 767, 950,
879 936, 796, 924, 899, 892, 893, 890, 855, 936, 833,
880 832, 2261, 841, 2282, 2299, 2302, 822, 2318, 866, 895,
881 966, 793, 790, 780, 2107, 2265, 767, 766, 745, 936,
882 741, 2129, 2322, 716, 689, 686, 2338, 2348, 2358, 2364,
883 5228, 2368, 2384, 2394, 2404, 2420, 2423, 2439, 2442, 2374,
884 5228, 2459, 2469, 2480, 2496, 660, 658, 640, 957, 641,
885 562, 2159, 2334, 5228, 2499, 2167, 557, 541, 2170, 2502,
886
887 2253, 481, 426, 2507, 2517, 2527, 2537, 2547, 2565, 2575,
888 2585, 2595, 2605, 2621, 2624, 2640, 2643, 2660, 0, 355,
889 2663, 2679, 2696, 2699, 2718, 2735, 2745, 2756, 2766, 2776,
890 2788, 2445, 2512, 307, 286, 2533, 2543, 2772, 5228, 2553,
891 2601, 283, 2611, 2627, 2798, 2804, 2808, 2820, 2824, 2836,
892 2869, 2881, 0, 2892, 2897, 2902, 2914, 2924, 2950, 2960,
893 2930, 5228, 2970, 2986, 2990, 3006, 3009, 3026, 0, 2646,
894 2689, 2724, 2728, 2782, 100, 2814, 2830, 2853, 3045, 3055,
895 3065, 3075, 3085, 3101, 3111, 3133, 3121, 3149, 3159, 3169,
896 3179, 3189, 3207, 3217, 3227, 3237, 3247, 3263, 3273, 3283,
897
898 3294, 2857, 2861, 3311, 3322, 3332, 3343, 3360, 3370, 3388,
899 3391, 3408, 3424, 0, 3427, 3446, 3457, 3482, 3485, 3504,
900 3515, 3531, 3549, 3553, 3572, 3576, 3598, 3608, 3625, 5228,
901 3679, 3701, 3723, 3745, 3767, 3789, 3811, 3833, 3855, 3877,
902 3899, 3921, 3943, 3960, 3978, 3992, 3999, 4015, 4036, 4058,
903 4080, 4097, 4117, 4138, 4160, 4182, 4204, 4226, 4247, 4269,
904 4291, 1035, 4312, 4330, 4349, 470, 4366, 4387, 4406, 4420,
905 4438, 4454, 544, 828, 995, 4468, 586, 4488, 4509, 4531,
906 4553, 998, 1002, 1023, 4575, 4597, 4619, 4641, 4663, 4680,
907 4701, 4723, 4745, 1024, 1086, 4767, 4789, 4811, 4833, 4855,
908
909 1103, 1115, 4876, 1120, 1147, 1191, 4897, 4919, 4941, 4963,
910 4985, 5007, 5029, 5051, 5073, 5095, 5117, 5139, 5161, 5183,
911 5205
912 } ;
913
914 static const flex_int16_t yy_def[922] =
915 { 0,
916 831, 831, 830, 3, 830, 5, 832, 832, 833, 833,
917 830, 11, 830, 13, 834, 834, 835, 835, 18, 18,
918 836, 836, 837, 837, 838, 838, 839, 839, 840, 840,
919 840, 840, 840, 840, 841, 841, 830, 37, 842, 842,
920 836, 836, 840, 840, 830, 830, 830, 830, 830, 830,
921 830, 843, 830, 830, 830, 830, 830, 830, 830, 830,
922 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
923 830, 844, 844, 830, 830, 830, 830, 830, 830, 830,
924 830, 845, 830, 843, 846, 845, 845, 830, 830, 845,
925 830, 845, 830, 847, 845, 845, 845, 848, 848, 848,
926
927 848, 848, 848, 849, 850, 830, 851, 830, 830, 830,
928 830, 852, 830, 853, 854, 830, 855, 855, 830, 830,
929 830, 830, 856, 830, 830, 830, 830, 857, 830, 858,
930 858, 830, 859, 860, 830, 830, 830, 860, 861, 861,
931 862, 830, 863, 830, 830, 830, 830, 830, 830, 830,
932 830, 843, 830, 830, 154, 830, 830, 830, 830, 830,
933 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
934 830, 830, 864, 865, 830, 830, 830, 830, 866, 830,
935 830, 830, 844, 844, 830, 830, 843, 845, 845, 154,
936 154, 830, 830, 830, 867, 868, 830, 830, 869, 830,
937
938 830, 830, 830, 830, 870, 845, 845, 845, 845, 848,
939 830, 830, 830, 830, 830, 849, 830, 850, 851, 830,
940 830, 852, 830, 853, 830, 854, 830, 830, 830, 855,
941 830, 830, 871, 830, 830, 872, 856, 830, 830, 857,
942 830, 830, 830, 858, 830, 830, 830, 830, 830, 830,
943 873, 874, 875, 860, 830, 830, 830, 830, 830, 830,
944 830, 861, 830, 876, 830, 863, 830, 830, 830, 830,
945 830, 830, 830, 830, 830, 830, 154, 830, 277, 277,
946 154, 277, 154, 154, 154, 277, 830, 830, 830, 830,
947 830, 830, 830, 830, 830, 864, 865, 830, 830, 830,
948
949 830, 866, 844, 277, 304, 867, 868, 868, 869, 830,
950 830, 830, 870, 830, 877, 878, 830, 830, 830, 830,
951 830, 830, 830, 879, 871, 872, 830, 830, 830, 880,
952 830, 830, 830, 881, 830, 882, 883, 884, 830, 830,
953 885, 830, 830, 886, 876, 830, 887, 830, 830, 830,
954 888, 830, 889, 277, 277, 277, 154, 154, 154, 154,
955 277, 277, 830, 830, 830, 830, 830, 830, 830, 830,
956 830, 830, 844, 889, 830, 830, 830, 890, 878, 878,
957 878, 878, 830, 830, 830, 830, 891, 879, 879, 879,
958 892, 880, 880, 880, 893, 881, 881, 881, 830, 894,
959
960 895, 830, 896, 885, 885, 885, 897, 886, 886, 886,
961 830, 887, 887, 887, 887, 830, 898, 888, 888, 888,
962 888, 830, 889, 899, 889, 277, 889, 154, 154, 154,
963 154, 277, 277, 830, 830, 830, 830, 830, 830, 830,
964 830, 830, 830, 830, 844, 374, 277, 830, 830, 830,
965 890, 900, 878, 830, 878, 891, 891, 891, 891, 879,
966 892, 892, 892, 892, 880, 893, 893, 893, 893, 881,
967 901, 902, 896, 896, 896, 896, 885, 897, 897, 897,
968 897, 886, 830, 830, 887, 887, 830, 898, 898, 898,
969 898, 898, 888, 888, 830, 899, 830, 277, 889, 889,
970
971 889, 154, 154, 154, 154, 277, 277, 830, 830, 830,
972 830, 830, 830, 830, 830, 830, 830, 830, 830, 844,
973 447, 830, 830, 830, 900, 525, 525, 525, 525, 903,
974 891, 892, 893, 904, 830, 896, 897, 830, 887, 830,
975 898, 898, 888, 830, 154, 277, 830, 830, 830, 830,
976 830, 830, 830, 830, 830, 844, 830, 830, 525, 525,
977 525, 525, 903, 905, 830, 887, 830, 898, 888, 830,
978 154, 830, 830, 830, 830, 830, 576, 844, 844, 844,
979 844, 830, 830, 906, 830, 830, 830, 887, 830, 898,
980 888, 830, 277, 830, 277, 277, 830, 830, 830, 830,
981
982 830, 830, 844, 844, 844, 844, 844, 844, 830, 583,
983 902, 830, 830, 830, 887, 830, 907, 830, 898, 888,
984 830, 908, 830, 277, 830, 830, 830, 830, 844, 844,
985 844, 844, 844, 844, 844, 844, 830, 830, 830, 830,
986 830, 887, 830, 909, 898, 888, 830, 910, 277, 830,
987 830, 830, 830, 844, 844, 844, 844, 844, 844, 844,
988 844, 830, 830, 830, 830, 830, 887, 830, 911, 887,
989 830, 909, 909, 912, 909, 898, 888, 830, 913, 888,
990 830, 910, 910, 914, 910, 277, 830, 830, 830, 830,
991 844, 830, 830, 830, 844, 844, 844, 844, 844, 830,
992
993 830, 830, 830, 887, 887, 830, 887, 887, 915, 909,
994 909, 830, 909, 909, 898, 830, 916, 898, 908, 830,
995 888, 888, 830, 888, 888, 917, 910, 910, 830, 910,
996 910, 277, 830, 830, 830, 830, 844, 830, 830, 830,
997 844, 844, 830, 830, 915, 887, 915, 915, 918, 915,
998 915, 912, 907, 898, 898, 830, 898, 898, 919, 919,
999 888, 830, 917, 917, 920, 917, 917, 914, 908, 277,
1000 830, 277, 830, 830, 830, 830, 830, 844, 915, 915,
1001 915, 830, 915, 915, 915, 915, 898, 919, 919, 921,
1002 919, 919, 919, 917, 917, 917, 830, 917, 917, 917,
1003
1004 917, 830, 830, 918, 915, 919, 919, 830, 919, 919,
1005 919, 919, 920, 908, 917, 915, 921, 919, 917, 915,
1006 919, 917, 915, 919, 917, 915, 919, 917, 919, 0,
1007 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1008 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1009 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1010 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1011 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1012 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1013 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1014
1015 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1016 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1017 830
1018 } ;
1019
1020 static const flex_int16_t yy_nxt[5288] =
1021 { 0,
1022 47, 48, 49, 48, 50, 51, 52, 53, 54, 55,
1023 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
1024 66, 66, 67, 68, 69, 70, 71, 47, 72, 72,
1025 72, 72, 73, 72, 72, 72, 72, 72, 72, 72,
1026 72, 72, 72, 72, 72, 72, 72, 74, 47, 75,
1027 47, 72, 72, 72, 72, 76, 77, 78, 72, 79,
1028 80, 81, 80, 82, 83, 84, 85, 86, 87, 88,
1029 89, 89, 86, 86, 89, 90, 91, 92, 93, 93,
1030 93, 94, 89, 95, 96, 97, 87, 98, 99, 98,
1031 98, 100, 98, 98, 98, 98, 98, 101, 98, 98,
1032
1033 98, 98, 98, 98, 102, 103, 89, 79, 89, 86,
1034 98, 98, 102, 103, 79, 87, 79, 98, 105, 290,
1035 166, 291, 105, 109, 109, 109, 109, 109, 109, 121,
1036 121, 167, 802, 140, 122, 122, 106, 107, 141, 106,
1037 106, 107, 140, 106, 604, 110, 605, 141, 110, 111,
1038 111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
1039 111, 111, 111, 111, 111, 111, 111, 111, 111, 111,
1040 111, 111, 111, 111, 111, 111, 111, 112, 112, 112,
1041 112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
1042 112, 112, 112, 112, 112, 112, 111, 111, 111, 111,
1043
1044 112, 112, 112, 112, 111, 111, 111, 112, 113, 113,
1045 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
1046 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
1047 113, 113, 113, 113, 113, 113, 114, 114, 114, 114,
1048 114, 114, 114, 114, 114, 114, 114, 114, 114, 114,
1049 114, 114, 114, 114, 114, 113, 113, 113, 113, 114,
1050 114, 114, 114, 113, 113, 113, 114, 118, 126, 118,
1051 137, 118, 118, 126, 137, 131, 119, 118, 184, 118,
1052 239, 120, 612, 132, 613, 131, 184, 118, 118, 118,
1053 118, 203, 155, 132, 204, 145, 146, 145, 151, 151,
1054
1055 151, 147, 163, 152, 145, 146, 145, 164, 138, 156,
1056 147, 127, 138, 118, 165, 778, 127, 775, 168, 118,
1057 118, 133, 118, 239, 118, 118, 148, 169, 170, 119,
1058 118, 133, 118, 231, 120, 148, 206, 207, 232, 774,
1059 118, 118, 118, 118, 151, 151, 151, 157, 158, 152,
1060 171, 159, 335, 335, 234, 173, 172, 172, 172, 235,
1061 174, 160, 269, 194, 194, 194, 118, 175, 159, 160,
1062 269, 760, 118, 142, 142, 142, 142, 142, 142, 142,
1063 142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
1064 142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
1065
1066 142, 143, 143, 143, 143, 143, 143, 143, 143, 143,
1067 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
1068 142, 142, 142, 142, 143, 143, 143, 143, 142, 142,
1069 142, 143, 176, 292, 177, 177, 177, 176, 293, 177,
1070 177, 177, 745, 186, 186, 186, 193, 178, 187, 186,
1071 186, 186, 178, 197, 187, 198, 198, 198, 194, 194,
1072 194, 179, 200, 283, 201, 201, 201, 284, 158, 179,
1073 190, 268, 190, 163, 190, 190, 317, 202, 164, 190,
1074 190, 318, 190, 302, 190, 220, 220, 220, 268, 302,
1075 190, 190, 190, 190, 155, 223, 223, 223, 227, 228,
1076
1077 228, 191, 250, 250, 241, 242, 242, 221, 265, 265,
1078 265, 156, 191, 229, 744, 231, 190, 225, 192, 243,
1079 232, 234, 190, 245, 246, 246, 235, 286, 251, 192,
1080 267, 287, 247, 255, 256, 256, 252, 253, 248, 258,
1081 259, 259, 247, 258, 259, 259, 399, 399, 257, 270,
1082 270, 270, 247, 238, 260, 314, 315, 336, 260, 273,
1083 274, 274, 357, 336, 271, 151, 151, 151, 247, 358,
1084 152, 283, 742, 286, 275, 284, 285, 287, 288, 172,
1085 172, 172, 299, 299, 299, 176, 316, 177, 177, 177,
1086 741, 426, 178, 272, 737, 178, 498, 198, 198, 198,
1087
1088 178, 272, 300, 276, 300, 378, 378, 301, 301, 301,
1089 202, 276, 277, 277, 278, 279, 277, 277, 277, 277,
1090 277, 277, 277, 277, 277, 277, 277, 277, 277, 277,
1091 280, 277, 277, 277, 277, 277, 277, 277, 277, 277,
1092 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
1093 281, 281, 281, 281, 281, 281, 281, 281, 281, 277,
1094 282, 277, 277, 277, 281, 281, 281, 277, 277, 277,
1095 277, 186, 186, 186, 736, 497, 187, 304, 734, 304,
1096 277, 304, 304, 310, 310, 310, 304, 304, 361, 304,
1097 200, 305, 311, 311, 311, 362, 202, 304, 304, 304,
1098
1099 304, 312, 733, 312, 732, 202, 301, 301, 301, 220,
1100 220, 220, 314, 315, 223, 223, 223, 369, 702, 223,
1101 223, 223, 701, 304, 370, 505, 265, 265, 265, 304,
1102 308, 221, 308, 505, 308, 308, 225, 314, 315, 308,
1103 308, 225, 308, 316, 308, 227, 228, 228, 267, 700,
1104 308, 308, 308, 308, 321, 321, 321, 241, 242, 242,
1105 229, 436, 509, 322, 327, 327, 327, 517, 316, 323,
1106 509, 528, 243, 328, 699, 517, 308, 697, 436, 329,
1107 439, 561, 308, 245, 246, 246, 331, 331, 331, 255,
1108 256, 256, 354, 355, 356, 332, 633, 439, 248, 696,
1109
1110 695, 333, 654, 634, 257, 339, 339, 339, 258, 259,
1111 259, 265, 265, 265, 332, 342, 342, 342, 691, 654,
1112 340, 640, 690, 260, 332, 270, 270, 270, 641, 689,
1113 343, 657, 681, 267, 273, 274, 274, 349, 349, 349,
1114 271, 337, 366, 299, 299, 299, 332, 337, 657, 275,
1115 367, 671, 350, 301, 301, 301, 178, 314, 315, 366,
1116 301, 301, 301, 666, 375, 665, 376, 376, 376, 272,
1117 200, 374, 377, 377, 377, 606, 305, 272, 276, 202,
1118 607, 276, 301, 301, 301, 202, 276, 663, 316, 276,
1119 277, 277, 277, 277, 277, 277, 277, 277, 277, 277,
1120
1121 277, 277, 277, 277, 277, 277, 277, 277, 277, 379,
1122 379, 379, 686, 614, 277, 277, 277, 304, 627, 304,
1123 686, 304, 304, 662, 381, 661, 304, 304, 660, 304,
1124 659, 305, 383, 383, 383, 560, 561, 304, 304, 304,
1125 304, 687, 385, 385, 385, 630, 321, 321, 321, 687,
1126 389, 228, 228, 631, 384, 322, 658, 382, 327, 327,
1127 327, 323, 630, 304, 386, 390, 562, 328, 656, 304,
1128 308, 664, 308, 329, 308, 308, 354, 355, 356, 308,
1129 308, 698, 308, 655, 308, 393, 242, 242, 664, 698,
1130 308, 308, 308, 308, 331, 331, 331, 397, 246, 246,
1131
1132 394, 688, 735, 332, 339, 339, 339, 653, 338, 333,
1133 735, 400, 398, 332, 338, 401, 308, 400, 688, 340,
1134 652, 401, 308, 405, 256, 256, 342, 342, 342, 409,
1135 259, 259, 413, 270, 270, 332, 402, 471, 406, 651,
1136 264, 343, 402, 471, 410, 424, 425, 414, 349, 349,
1137 349, 419, 274, 274, 264, 264, 426, 332, 354, 355,
1138 356, 280, 650, 350, 649, 648, 420, 354, 355, 356,
1139 444, 444, 444, 448, 448, 448, 415, 644, 375, 639,
1140 449, 449, 449, 450, 415, 377, 377, 377, 383, 383,
1141 383, 427, 276, 202, 637, 421, 636, 635, 202, 472,
1142
1143 276, 632, 638, 421, 629, 472, 379, 379, 379, 628,
1144 384, 637, 445, 424, 425, 446, 534, 446, 626, 446,
1145 446, 381, 534, 625, 447, 446, 624, 446, 535, 305,
1146 379, 379, 379, 564, 535, 446, 446, 446, 446, 564,
1147 379, 379, 379, 614, 608, 381, 603, 379, 379, 379,
1148 385, 385, 385, 592, 382, 452, 457, 321, 321, 427,
1149 584, 446, 453, 454, 589, 458, 584, 446, 389, 228,
1150 228, 459, 386, 528, 389, 228, 228, 522, 382, 389,
1151 228, 228, 576, 390, 575, 393, 242, 242, 382, 390,
1152 462, 327, 327, 455, 460, 382, 393, 242, 242, 463,
1153
1154 394, 393, 242, 242, 611, 464, 467, 331, 331, 572,
1155 611, 394, 397, 246, 246, 468, 465, 397, 246, 246,
1156 571, 469, 397, 246, 246, 570, 567, 398, 565, 474,
1157 339, 339, 398, 405, 256, 256, 528, 470, 475, 405,
1158 256, 256, 556, 555, 476, 405, 256, 256, 406, 479,
1159 342, 342, 553, 552, 406, 409, 259, 259, 480, 548,
1160 477, 409, 259, 259, 481, 409, 259, 259, 547, 546,
1161 410, 483, 483, 483, 506, 545, 410, 413, 270, 270,
1162 482, 413, 270, 270, 413, 270, 270, 413, 270, 270,
1163 502, 502, 414, 419, 274, 274, 414, 353, 497, 485,
1164
1165 544, 540, 414, 538, 520, 489, 349, 349, 420, 419,
1166 274, 274, 518, 484, 490, 419, 274, 274, 486, 516,
1167 491, 415, 515, 514, 420, 415, 510, 508, 415, 415,
1168 493, 415, 507, 415, 506, 504, 415, 421, 503, 415,
1169 419, 274, 274, 502, 497, 421, 495, 424, 425, 492,
1170 511, 511, 511, 421, 487, 420, 443, 492, 426, 421,
1171 442, 421, 441, 280, 424, 425, 440, 421, 512, 512,
1172 512, 494, 444, 444, 444, 426, 438, 499, 500, 501,
1173 280, 437, 435, 522, 421, 523, 523, 523, 434, 426,
1174 513, 433, 421, 427, 280, 432, 375, 431, 524, 524,
1175
1176 524, 430, 524, 524, 524, 429, 379, 379, 379, 428,
1177 427, 202, 422, 417, 519, 202, 416, 379, 379, 379,
1178 411, 452, 263, 407, 427, 304, 403, 304, 395, 304,
1179 304, 454, 381, 391, 447, 304, 387, 304, 315, 521,
1180 457, 321, 321, 193, 374, 304, 304, 304, 304, 458,
1181 373, 457, 321, 321, 382, 459, 298, 389, 228, 228,
1182 458, 457, 321, 321, 372, 382, 459, 511, 511, 511,
1183 458, 304, 460, 512, 512, 512, 459, 304, 525, 526,
1184 379, 379, 525, 525, 525, 371, 368, 525, 525, 457,
1185 321, 321, 365, 525, 528, 513, 364, 363, 458, 360,
1186
1187 525, 525, 525, 525, 531, 525, 462, 327, 327, 462,
1188 327, 327, 551, 551, 551, 463, 359, 353, 463, 352,
1189 351, 464, 348, 347, 464, 346, 525, 529, 525, 292,
1190 462, 327, 327, 525, 525, 525, 379, 379, 379, 463,
1191 263, 344, 380, 380, 341, 464, 380, 380, 380, 380,
1192 334, 381, 380, 380, 380, 380, 380, 330, 483, 483,
1193 483, 380, 324, 530, 530, 530, 530, 530, 530, 530,
1194 530, 530, 530, 530, 530, 530, 530, 530, 530, 530,
1195 530, 530, 380, 320, 382, 319, 530, 530, 530, 530,
1196 462, 327, 327, 530, 393, 242, 242, 217, 193, 463,
1197
1198 484, 467, 331, 331, 303, 532, 467, 331, 331, 465,
1199 468, 467, 331, 331, 298, 468, 469, 397, 246, 246,
1200 468, 469, 467, 331, 331, 295, 469, 474, 339, 339,
1201 294, 468, 470, 554, 554, 554, 475, 533, 474, 339,
1202 339, 289, 476, 474, 339, 339, 263, 475, 474, 339,
1203 339, 261, 475, 476, 405, 256, 256, 475, 476, 479,
1204 342, 342, 238, 536, 479, 342, 342, 236, 480, 477,
1205 409, 259, 259, 480, 481, 479, 342, 342, 233, 481,
1206 479, 342, 342, 217, 480, 482, 413, 270, 270, 480,
1207 481, 413, 270, 270, 215, 537, 489, 349, 349, 214,
1208
1209 213, 485, 549, 549, 549, 490, 414, 489, 349, 349,
1210 212, 491, 489, 349, 349, 211, 490, 489, 349, 349,
1211 209, 490, 491, 208, 550, 199, 490, 491, 196, 189,
1212 415, 185, 541, 539, 182, 415, 181, 180, 415, 162,
1213 492, 161, 153, 415, 830, 489, 349, 349, 492, 150,
1214 150, 492, 149, 149, 490, 136, 492, 136, 135, 492,
1215 491, 492, 135, 129, 492, 419, 274, 274, 129, 492,
1216 419, 274, 274, 557, 557, 557, 542, 573, 573, 573,
1217 493, 499, 500, 501, 522, 420, 558, 558, 558, 492,
1218 499, 500, 501, 426, 499, 500, 501, 492, 280, 549,
1219
1220 549, 549, 426, 524, 524, 524, 426, 280, 124, 421,
1221 124, 280, 543, 116, 421, 116, 202, 421, 457, 321,
1222 321, 550, 421, 462, 327, 327, 830, 458, 427, 551,
1223 551, 551, 463, 531, 413, 270, 270, 427, 532, 830,
1224 830, 427, 525, 526, 379, 379, 525, 525, 525, 414,
1225 830, 525, 525, 467, 331, 331, 830, 525, 559, 574,
1226 574, 574, 468, 566, 525, 525, 525, 525, 533, 525,
1227 474, 339, 339, 479, 342, 342, 830, 830, 415, 475,
1228 830, 830, 480, 830, 830, 536, 415, 830, 537, 830,
1229 525, 529, 525, 554, 554, 554, 830, 525, 525, 525,
1230
1231 379, 379, 379, 582, 582, 582, 830, 380, 830, 830,
1232 380, 380, 380, 380, 830, 453, 454, 380, 489, 349,
1233 349, 489, 349, 349, 830, 380, 830, 490, 830, 830,
1234 490, 830, 830, 541, 830, 830, 491, 419, 274, 274,
1235 573, 573, 573, 585, 585, 585, 455, 830, 382, 413,
1236 270, 270, 420, 419, 274, 274, 593, 594, 595, 597,
1237 597, 597, 492, 568, 414, 492, 569, 830, 420, 830,
1238 492, 830, 830, 492, 586, 830, 588, 587, 830, 830,
1239 591, 421, 574, 574, 574, 599, 599, 599, 830, 421,
1240 577, 577, 577, 415, 587, 830, 830, 421, 609, 609,
1241
1242 609, 415, 616, 616, 616, 421, 596, 830, 830, 598,
1243 830, 617, 830, 621, 621, 621, 830, 618, 830, 830,
1244 578, 579, 622, 830, 580, 593, 594, 595, 623, 597,
1245 597, 597, 830, 830, 581, 593, 594, 595, 597, 597,
1246 597, 580, 581, 583, 583, 583, 583, 583, 583, 583,
1247 583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1248 583, 583, 830, 489, 349, 349, 583, 583, 583, 583,
1249 830, 830, 490, 583, 379, 379, 379, 830, 491, 830,
1250 830, 380, 830, 830, 380, 380, 380, 380, 830, 453,
1251 454, 380, 590, 830, 830, 585, 585, 585, 830, 380,
1252
1253 599, 599, 599, 413, 270, 270, 830, 492, 692, 692,
1254 692, 830, 489, 349, 349, 492, 830, 830, 414, 830,
1255 455, 490, 382, 577, 577, 577, 586, 491, 830, 587,
1256 692, 692, 692, 830, 616, 616, 616, 830, 830, 619,
1257 830, 830, 615, 617, 830, 830, 587, 415, 830, 618,
1258 621, 621, 621, 600, 586, 415, 492, 601, 830, 622,
1259 692, 692, 692, 830, 492, 623, 830, 602, 740, 740,
1260 740, 743, 743, 743, 601, 602, 525, 526, 379, 379,
1261 525, 525, 525, 610, 527, 525, 525, 527, 527, 527,
1262 527, 525, 560, 561, 527, 610, 610, 610, 525, 525,
1263
1264 525, 525, 527, 525, 610, 610, 610, 610, 610, 610,
1265 610, 610, 610, 610, 610, 610, 610, 610, 610, 610,
1266 610, 610, 610, 562, 525, 529, 525, 610, 610, 610,
1267 610, 525, 525, 525, 610, 419, 274, 274, 413, 270,
1268 270, 830, 489, 349, 349, 419, 274, 274, 830, 830,
1269 420, 490, 830, 414, 740, 740, 740, 491, 830, 830,
1270 420, 830, 667, 668, 668, 830, 693, 693, 693, 642,
1271 830, 669, 830, 830, 620, 830, 646, 670, 830, 421,
1272 830, 645, 415, 673, 616, 616, 492, 421, 694, 421,
1273 415, 830, 674, 830, 492, 830, 830, 421, 675, 830,
1274
1275 489, 349, 349, 677, 678, 678, 415, 830, 830, 490,
1276 830, 830, 679, 830, 415, 491, 830, 830, 680, 683,
1277 621, 621, 830, 693, 693, 693, 830, 830, 684, 830,
1278 830, 676, 830, 830, 685, 693, 693, 693, 830, 667,
1279 668, 668, 830, 830, 492, 694, 830, 421, 669, 668,
1280 668, 668, 492, 830, 670, 421, 830, 694, 617, 705,
1281 706, 706, 830, 830, 703, 413, 270, 270, 412, 673,
1282 616, 616, 830, 830, 707, 419, 274, 274, 674, 830,
1283 709, 830, 830, 415, 675, 673, 616, 616, 830, 830,
1284 726, 415, 830, 272, 674, 711, 712, 712, 830, 830,
1285
1286 675, 272, 830, 708, 674, 673, 616, 616, 830, 415,
1287 713, 708, 830, 830, 674, 830, 830, 415, 830, 421,
1288 714, 715, 716, 716, 677, 678, 678, 421, 830, 830,
1289 717, 830, 830, 679, 830, 830, 718, 830, 830, 680,
1290 716, 716, 716, 722, 723, 723, 770, 771, 772, 719,
1291 830, 830, 418, 830, 830, 720, 830, 830, 724, 830,
1292 683, 621, 621, 830, 830, 492, 830, 830, 421, 684,
1293 683, 621, 621, 492, 830, 685, 421, 830, 830, 684,
1294 830, 728, 729, 729, 276, 685, 830, 725, 830, 830,
1295 684, 830, 276, 830, 830, 725, 730, 683, 621, 621,
1296
1297 738, 738, 738, 738, 738, 738, 684, 830, 413, 270,
1298 270, 830, 731, 773, 773, 773, 830, 746, 413, 270,
1299 270, 830, 739, 414, 830, 739, 830, 746, 270, 270,
1300 270, 830, 830, 414, 743, 743, 743, 671, 413, 270,
1301 270, 830, 830, 271, 776, 776, 776, 746, 413, 270,
1302 270, 830, 415, 485, 740, 740, 740, 746, 830, 830,
1303 415, 830, 415, 414, 830, 830, 748, 668, 668, 830,
1304 415, 830, 272, 830, 830, 749, 673, 616, 616, 486,
1305 272, 750, 415, 830, 830, 752, 673, 616, 616, 830,
1306 415, 675, 415, 830, 830, 752, 616, 616, 616, 830,
1307
1308 415, 675, 777, 777, 777, 753, 673, 616, 616, 830,
1309 751, 618, 743, 743, 743, 752, 830, 830, 751, 830,
1310 830, 714, 673, 616, 616, 715, 716, 716, 777, 777,
1311 777, 674, 830, 830, 717, 830, 830, 714, 830, 830,
1312 718, 716, 716, 716, 755, 756, 756, 770, 771, 772,
1313 719, 830, 830, 490, 830, 830, 720, 830, 830, 757,
1314 830, 489, 349, 349, 419, 274, 274, 830, 830, 492,
1315 490, 830, 830, 761, 830, 830, 759, 492, 830, 420,
1316 419, 274, 274, 830, 830, 276, 830, 830, 758, 761,
1317 773, 773, 773, 276, 830, 420, 758, 349, 349, 349,
1318
1319 419, 274, 274, 830, 830, 492, 762, 830, 421, 761,
1320 830, 830, 350, 492, 830, 493, 421, 830, 830, 419,
1321 274, 274, 830, 830, 421, 770, 771, 772, 761, 773,
1322 773, 773, 421, 830, 420, 830, 764, 678, 678, 830,
1323 830, 276, 830, 830, 421, 765, 683, 621, 621, 276,
1324 494, 766, 421, 830, 830, 768, 830, 683, 621, 621,
1325 830, 685, 830, 421, 830, 830, 768, 621, 621, 621,
1326 830, 421, 685, 738, 738, 738, 769, 683, 621, 621,
1327 767, 830, 623, 776, 776, 776, 768, 830, 767, 683,
1328 621, 621, 731, 830, 830, 739, 830, 830, 684, 748,
1329
1330 668, 668, 830, 830, 731, 413, 270, 270, 749, 748,
1331 668, 668, 830, 830, 779, 776, 776, 776, 749, 830,
1332 414, 748, 668, 668, 779, 781, 782, 782, 830, 830,
1333 749, 777, 777, 777, 749, 830, 779, 748, 668, 668,
1334 783, 830, 830, 751, 830, 830, 749, 830, 830, 415,
1335 830, 751, 785, 751, 803, 803, 803, 415, 803, 803,
1336 803, 751, 803, 803, 803, 751, 830, 830, 830, 784,
1337 748, 668, 668, 751, 830, 830, 830, 784, 830, 749,
1338 830, 751, 711, 712, 712, 779, 830, 830, 830, 751,
1339 830, 674, 830, 489, 349, 349, 830, 713, 489, 349,
1340
1341 349, 786, 787, 349, 349, 349, 830, 787, 491, 830,
1342 830, 830, 762, 491, 751, 489, 349, 349, 350, 830,
1343 830, 830, 751, 830, 787, 489, 349, 349, 830, 830,
1344 541, 419, 274, 274, 787, 830, 830, 492, 830, 830,
1345 491, 830, 492, 830, 830, 492, 420, 276, 830, 830,
1346 492, 789, 716, 716, 830, 276, 542, 830, 830, 492,
1347 790, 789, 716, 716, 830, 830, 791, 492, 830, 492,
1348 790, 764, 678, 678, 830, 421, 793, 492, 830, 830,
1349 765, 830, 830, 421, 830, 830, 794, 764, 678, 678,
1350 830, 796, 797, 797, 830, 792, 765, 830, 830, 830,
1351
1352 765, 830, 794, 792, 830, 792, 798, 764, 678, 678,
1353 764, 678, 678, 792, 830, 767, 765, 830, 830, 765,
1354 830, 830, 800, 767, 830, 794, 830, 728, 729, 729,
1355 830, 767, 830, 830, 830, 799, 684, 830, 830, 767,
1356 830, 801, 730, 799, 830, 830, 748, 668, 668, 830,
1357 830, 767, 830, 830, 767, 749, 748, 668, 668, 767,
1358 830, 785, 767, 830, 830, 804, 748, 668, 668, 830,
1359 830, 779, 830, 830, 830, 804, 668, 668, 668, 830,
1360 830, 779, 830, 830, 830, 753, 748, 668, 668, 830,
1361 751, 703, 830, 830, 830, 804, 830, 830, 751, 830,
1362
1363 751, 785, 748, 668, 668, 830, 830, 830, 751, 830,
1364 751, 804, 748, 668, 668, 830, 830, 779, 751, 830,
1365 272, 749, 489, 349, 349, 830, 830, 785, 272, 830,
1366 751, 490, 830, 786, 748, 668, 668, 491, 751, 830,
1367 830, 830, 830, 749, 830, 830, 751, 830, 830, 779,
1368 789, 716, 716, 830, 751, 830, 751, 830, 830, 790,
1369 789, 716, 716, 830, 751, 793, 492, 830, 830, 790,
1370 807, 808, 808, 830, 492, 793, 805, 830, 751, 790,
1371 789, 716, 716, 830, 830, 809, 751, 830, 830, 790,
1372 789, 716, 716, 830, 792, 811, 830, 830, 830, 790,
1373
1374 830, 830, 792, 830, 792, 793, 830, 830, 789, 716,
1375 716, 830, 792, 830, 810, 830, 830, 790, 764, 678,
1376 678, 812, 810, 811, 792, 830, 830, 765, 764, 678,
1377 678, 830, 792, 800, 792, 830, 830, 813, 764, 678,
1378 678, 830, 792, 794, 830, 830, 830, 813, 716, 716,
1379 716, 830, 792, 794, 830, 830, 830, 814, 830, 830,
1380 792, 830, 767, 720, 764, 678, 678, 830, 830, 830,
1381 767, 830, 767, 813, 764, 678, 678, 830, 830, 800,
1382 767, 830, 767, 813, 764, 678, 678, 830, 830, 794,
1383 767, 830, 276, 765, 830, 764, 678, 678, 830, 800,
1384
1385 276, 830, 830, 830, 765, 801, 830, 830, 767, 830,
1386 794, 830, 781, 782, 782, 830, 767, 830, 767, 830,
1387 830, 749, 830, 748, 668, 668, 767, 783, 767, 830,
1388 830, 830, 749, 789, 716, 716, 767, 815, 779, 767,
1389 830, 830, 817, 830, 789, 716, 716, 767, 793, 830,
1390 830, 830, 816, 817, 830, 830, 784, 830, 830, 793,
1391 830, 716, 716, 716, 784, 830, 830, 751, 830, 830,
1392 814, 789, 716, 716, 830, 751, 720, 792, 830, 830,
1393 817, 830, 830, 830, 830, 792, 811, 830, 792, 789,
1394 716, 716, 789, 716, 716, 830, 792, 830, 817, 830,
1395
1396 830, 790, 830, 830, 793, 276, 830, 811, 830, 789,
1397 716, 716, 830, 276, 830, 792, 830, 830, 790, 830,
1398 812, 830, 830, 792, 793, 796, 797, 797, 764, 678,
1399 678, 830, 830, 792, 765, 830, 792, 765, 830, 830,
1400 798, 792, 830, 794, 792, 830, 830, 748, 668, 668,
1401 830, 818, 830, 792, 830, 830, 749, 819, 807, 808,
1402 808, 792, 779, 830, 830, 830, 830, 790, 830, 799,
1403 830, 830, 767, 809, 820, 830, 830, 799, 830, 830,
1404 767, 830, 830, 789, 716, 716, 764, 678, 678, 830,
1405 830, 751, 790, 830, 830, 765, 830, 830, 793, 751,
1406
1407 830, 794, 810, 830, 830, 748, 668, 668, 830, 830,
1408 810, 830, 821, 822, 749, 830, 789, 716, 716, 830,
1409 779, 830, 830, 830, 830, 790, 830, 792, 830, 830,
1410 767, 793, 764, 678, 678, 792, 830, 830, 767, 830,
1411 830, 765, 830, 824, 823, 830, 830, 794, 830, 751,
1412 748, 668, 668, 830, 789, 716, 716, 751, 830, 749,
1413 792, 830, 830, 790, 830, 779, 830, 830, 792, 793,
1414 830, 825, 830, 764, 678, 678, 767, 748, 668, 668,
1415 830, 826, 765, 830, 767, 830, 749, 830, 794, 830,
1416 830, 830, 779, 827, 751, 830, 830, 830, 792, 789,
1417
1418 716, 716, 751, 830, 828, 830, 792, 830, 790, 764,
1419 678, 678, 830, 830, 793, 830, 830, 767, 765, 830,
1420 830, 751, 830, 830, 794, 767, 789, 716, 716, 751,
1421 829, 830, 830, 830, 830, 790, 830, 830, 830, 830,
1422 830, 793, 830, 792, 830, 830, 830, 830, 830, 830,
1423 830, 792, 830, 767, 830, 830, 830, 830, 830, 830,
1424 830, 767, 830, 830, 830, 830, 830, 830, 830, 830,
1425 792, 830, 830, 830, 830, 830, 830, 830, 792, 46,
1426 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1427 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1428
1429 46, 104, 104, 104, 104, 104, 104, 104, 104, 104,
1430 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
1431 104, 104, 104, 108, 108, 108, 108, 108, 108, 108,
1432 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
1433 108, 108, 108, 108, 108, 115, 115, 115, 115, 115,
1434 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
1435 115, 115, 115, 115, 115, 115, 115, 117, 117, 117,
1436 117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
1437 117, 117, 117, 117, 117, 117, 117, 117, 117, 123,
1438 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1439
1440 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
1441 123, 125, 125, 125, 125, 125, 125, 125, 125, 125,
1442 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
1443 125, 125, 125, 128, 128, 128, 128, 128, 128, 128,
1444 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1445 128, 128, 128, 128, 128, 130, 130, 130, 130, 130,
1446 130, 130, 130, 130, 130, 130, 130, 130, 130, 130,
1447 130, 130, 130, 130, 130, 130, 130, 134, 134, 134,
1448 134, 134, 134, 134, 134, 134, 134, 134, 134, 134,
1449 134, 134, 134, 134, 134, 134, 134, 134, 134, 139,
1450
1451 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
1452 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
1453 139, 144, 144, 144, 144, 144, 144, 144, 144, 144,
1454 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
1455 144, 144, 144, 154, 154, 154, 154, 154, 154, 154,
1456 154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1457 154, 154, 154, 154, 154, 183, 830, 830, 830, 830,
1458 830, 830, 830, 183, 830, 830, 830, 830, 830, 183,
1459 183, 188, 830, 830, 188, 830, 830, 188, 188, 830,
1460 188, 830, 830, 830, 188, 188, 188, 195, 830, 830,
1461
1462 830, 830, 830, 830, 830, 195, 830, 830, 830, 830,
1463 830, 195, 195, 205, 830, 830, 205, 830, 205, 205,
1464 210, 830, 830, 830, 830, 830, 830, 830, 210, 830,
1465 830, 830, 830, 830, 210, 210, 216, 216, 216, 216,
1466 830, 216, 216, 216, 216, 216, 216, 216, 216, 216,
1467 216, 216, 830, 216, 830, 216, 216, 216, 218, 218,
1468 218, 218, 830, 218, 218, 218, 218, 218, 218, 218,
1469 218, 218, 218, 218, 218, 218, 218, 218, 218, 218,
1470 219, 219, 219, 219, 219, 219, 219, 219, 219, 219,
1471 219, 219, 219, 219, 219, 219, 219, 219, 830, 219,
1472
1473 219, 219, 222, 830, 830, 830, 830, 830, 830, 830,
1474 222, 830, 830, 830, 830, 830, 222, 222, 224, 224,
1475 830, 830, 224, 830, 830, 830, 830, 830, 830, 830,
1476 224, 830, 224, 830, 830, 830, 224, 224, 226, 226,
1477 226, 226, 226, 226, 226, 830, 226, 226, 226, 226,
1478 226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
1479 230, 230, 230, 230, 230, 230, 230, 230, 230, 830,
1480 230, 230, 830, 230, 230, 230, 230, 230, 230, 230,
1481 230, 230, 237, 237, 237, 237, 830, 237, 237, 237,
1482 237, 237, 237, 237, 237, 237, 237, 237, 237, 237,
1483
1484 237, 237, 237, 237, 240, 240, 240, 240, 240, 240,
1485 240, 830, 240, 240, 240, 240, 240, 240, 240, 240,
1486 240, 240, 240, 240, 240, 240, 244, 244, 244, 244,
1487 244, 244, 244, 830, 244, 244, 244, 244, 244, 244,
1488 244, 244, 244, 244, 244, 244, 244, 249, 249, 249,
1489 249, 249, 249, 249, 249, 249, 249, 249, 249, 249,
1490 249, 249, 249, 249, 249, 249, 249, 249, 249, 254,
1491 254, 254, 254, 254, 254, 254, 830, 254, 254, 254,
1492 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
1493 254, 262, 262, 262, 262, 262, 830, 262, 262, 262,
1494
1495 262, 262, 262, 262, 262, 262, 262, 262, 262, 262,
1496 262, 262, 262, 266, 266, 830, 830, 266, 830, 830,
1497 830, 830, 830, 830, 830, 266, 830, 266, 830, 830,
1498 830, 266, 266, 296, 830, 830, 296, 830, 830, 296,
1499 296, 830, 296, 830, 830, 830, 296, 296, 296, 297,
1500 297, 297, 297, 297, 297, 297, 297, 297, 297, 297,
1501 297, 297, 297, 297, 297, 297, 297, 297, 297, 297,
1502 297, 306, 830, 830, 830, 830, 830, 830, 830, 306,
1503 830, 830, 830, 830, 830, 306, 306, 307, 307, 830,
1504 307, 307, 307, 307, 307, 307, 307, 307, 307, 307,
1505
1506 307, 307, 307, 307, 307, 307, 307, 307, 307, 309,
1507 830, 830, 309, 830, 830, 309, 309, 830, 309, 830,
1508 830, 830, 309, 309, 309, 313, 830, 830, 830, 830,
1509 313, 313, 830, 313, 830, 830, 830, 830, 830, 313,
1510 313, 325, 830, 830, 325, 830, 830, 325, 325, 830,
1511 325, 830, 830, 830, 325, 325, 325, 326, 830, 830,
1512 326, 830, 830, 326, 326, 830, 326, 830, 830, 830,
1513 326, 326, 326, 345, 830, 830, 830, 830, 830, 830,
1514 830, 345, 830, 830, 830, 830, 830, 345, 345, 380,
1515 380, 830, 830, 380, 380, 830, 380, 380, 380, 380,
1516
1517 380, 380, 830, 830, 830, 830, 380, 380, 380, 388,
1518 388, 388, 388, 388, 388, 388, 388, 388, 388, 388,
1519 388, 388, 388, 388, 388, 388, 388, 388, 388, 388,
1520 388, 392, 392, 392, 392, 392, 392, 392, 392, 392,
1521 392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
1522 392, 392, 392, 396, 396, 396, 396, 396, 396, 396,
1523 396, 396, 396, 396, 396, 396, 396, 396, 396, 396,
1524 396, 396, 396, 396, 396, 404, 404, 404, 404, 404,
1525 404, 404, 404, 404, 404, 404, 404, 404, 404, 404,
1526 404, 404, 404, 404, 404, 404, 404, 408, 408, 408,
1527
1528 408, 408, 408, 408, 408, 408, 408, 408, 408, 408,
1529 408, 408, 408, 408, 408, 408, 408, 408, 408, 412,
1530 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
1531 412, 412, 412, 412, 412, 412, 412, 412, 412, 412,
1532 412, 418, 418, 418, 418, 418, 418, 418, 418, 418,
1533 418, 418, 418, 418, 418, 418, 418, 418, 418, 418,
1534 418, 418, 418, 423, 423, 423, 423, 423, 423, 423,
1535 423, 423, 423, 423, 423, 423, 423, 423, 423, 423,
1536 423, 423, 423, 423, 423, 451, 830, 830, 830, 830,
1537 451, 451, 830, 451, 830, 830, 830, 830, 830, 451,
1538
1539 451, 456, 456, 456, 456, 456, 456, 456, 456, 456,
1540 456, 456, 456, 456, 456, 456, 456, 456, 456, 456,
1541 456, 456, 456, 461, 461, 461, 461, 461, 461, 461,
1542 461, 461, 461, 461, 461, 461, 461, 461, 461, 461,
1543 461, 461, 461, 461, 461, 466, 466, 466, 466, 466,
1544 466, 466, 466, 466, 466, 466, 466, 466, 466, 466,
1545 466, 466, 466, 466, 466, 466, 466, 473, 473, 473,
1546 473, 473, 473, 473, 473, 473, 473, 473, 473, 473,
1547 473, 473, 473, 473, 473, 473, 473, 473, 473, 478,
1548 478, 478, 478, 478, 478, 478, 478, 478, 478, 478,
1549
1550 478, 478, 478, 478, 478, 478, 478, 478, 478, 478,
1551 478, 488, 488, 488, 488, 488, 488, 488, 488, 488,
1552 488, 488, 488, 488, 488, 488, 488, 488, 488, 488,
1553 488, 488, 488, 496, 496, 496, 496, 496, 496, 496,
1554 496, 496, 496, 496, 496, 830, 496, 496, 496, 496,
1555 496, 496, 496, 496, 496, 527, 527, 527, 527, 527,
1556 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
1557 527, 527, 527, 527, 527, 527, 527, 563, 563, 830,
1558 830, 563, 563, 830, 563, 563, 563, 563, 563, 563,
1559 830, 830, 830, 830, 563, 563, 563, 643, 643, 643,
1560
1561 643, 643, 643, 643, 830, 643, 643, 643, 643, 643,
1562 643, 643, 643, 643, 643, 643, 643, 643, 643, 647,
1563 647, 647, 647, 647, 647, 647, 830, 647, 647, 647,
1564 647, 647, 647, 647, 647, 647, 647, 647, 647, 647,
1565 647, 672, 672, 672, 672, 672, 672, 672, 672, 672,
1566 672, 672, 672, 672, 672, 672, 672, 672, 672, 672,
1567 672, 672, 672, 682, 682, 682, 682, 682, 682, 682,
1568 682, 682, 682, 682, 682, 682, 682, 682, 682, 682,
1569 682, 682, 682, 682, 682, 704, 704, 704, 704, 704,
1570 704, 704, 704, 704, 704, 704, 704, 704, 704, 704,
1571
1572 704, 704, 704, 704, 704, 704, 704, 710, 710, 710,
1573 710, 710, 710, 710, 710, 710, 710, 710, 710, 710,
1574 710, 710, 710, 710, 710, 710, 710, 710, 710, 721,
1575 721, 721, 721, 721, 721, 721, 721, 721, 721, 721,
1576 721, 721, 721, 721, 721, 721, 721, 721, 721, 721,
1577 721, 727, 727, 727, 727, 727, 727, 727, 727, 727,
1578 727, 727, 727, 727, 727, 727, 727, 727, 727, 727,
1579 727, 727, 727, 747, 747, 747, 747, 747, 747, 747,
1580 747, 747, 747, 747, 747, 747, 747, 747, 747, 747,
1581 747, 747, 747, 747, 747, 754, 754, 754, 754, 754,
1582
1583 754, 754, 754, 754, 754, 754, 754, 754, 754, 754,
1584 754, 754, 754, 754, 754, 754, 754, 763, 763, 763,
1585 763, 763, 763, 763, 763, 763, 763, 763, 763, 763,
1586 763, 763, 763, 763, 763, 763, 763, 763, 763, 780,
1587 780, 780, 780, 780, 780, 780, 780, 780, 780, 780,
1588 780, 780, 780, 780, 780, 780, 780, 780, 780, 780,
1589 780, 788, 788, 788, 788, 788, 788, 788, 788, 788,
1590 788, 788, 788, 788, 788, 788, 788, 788, 788, 788,
1591 788, 788, 788, 795, 795, 795, 795, 795, 795, 795,
1592 795, 795, 795, 795, 795, 795, 795, 795, 795, 795,
1593
1594 795, 795, 795, 795, 795, 806, 806, 806, 806, 806,
1595 806, 806, 806, 806, 806, 806, 806, 806, 806, 806,
1596 806, 806, 806, 806, 806, 806, 806, 45, 830, 830,
1597 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1598 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1599 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1600 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1601 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
1602 830, 830, 830, 830, 830, 830, 830
1603 } ;
1604
1605 static const flex_int16_t yy_chk[5288] =
1606 { 0,
1607 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1608 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1609 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1610 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1611 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1612 3, 3, 3, 3, 3, 3, 3, 3, 3, 5,
1613 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1614 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1615 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1616 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1617
1618 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1619 5, 5, 5, 5, 5, 5, 5, 5, 7, 158,
1620 60, 158, 8, 9, 9, 9, 10, 10, 10, 19,
1621 20, 60, 775, 35, 19, 20, 7, 7, 35, 7,
1622 8, 8, 36, 8, 579, 9, 579, 36, 10, 11,
1623 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1624 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1625 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1626 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1627 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
1628
1629 11, 11, 11, 11, 11, 11, 11, 11, 13, 13,
1630 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1631 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1632 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1633 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1634 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1635 13, 13, 13, 13, 13, 13, 13, 17, 23, 17,
1636 33, 17, 17, 24, 34, 27, 17, 17, 73, 17,
1637 127, 17, 586, 27, 586, 28, 73, 17, 17, 17,
1638 17, 94, 52, 28, 94, 39, 39, 39, 48, 48,
1639
1640 48, 39, 59, 48, 40, 40, 40, 59, 33, 52,
1641 40, 23, 34, 17, 59, 742, 24, 735, 62, 17,
1642 18, 27, 18, 127, 18, 18, 39, 62, 62, 18,
1643 18, 28, 18, 119, 18, 40, 95, 95, 119, 734,
1644 18, 18, 18, 18, 49, 49, 49, 53, 53, 49,
1645 63, 53, 250, 250, 121, 64, 63, 63, 63, 121,
1646 64, 53, 148, 194, 194, 194, 18, 64, 53, 53,
1647 148, 720, 18, 37, 37, 37, 37, 37, 37, 37,
1648 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1649 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1650
1651 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1652 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1653 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
1654 37, 37, 65, 159, 65, 65, 65, 66, 159, 66,
1655 66, 66, 703, 80, 80, 80, 85, 65, 80, 81,
1656 81, 81, 66, 91, 81, 91, 91, 91, 85, 85,
1657 85, 65, 93, 191, 93, 93, 93, 191, 147, 65,
1658 84, 147, 84, 163, 84, 84, 214, 93, 163, 84,
1659 84, 214, 84, 866, 84, 109, 109, 109, 147, 866,
1660 84, 84, 84, 84, 152, 114, 114, 114, 116, 116,
1661
1662 116, 84, 133, 133, 129, 129, 129, 109, 143, 143,
1663 143, 152, 187, 116, 702, 231, 84, 114, 84, 129,
1664 231, 234, 84, 132, 132, 132, 234, 192, 133, 187,
1665 143, 192, 132, 135, 135, 135, 133, 133, 132, 137,
1666 137, 137, 135, 136, 136, 136, 335, 335, 135, 149,
1667 149, 149, 136, 149, 137, 205, 205, 873, 136, 150,
1668 150, 150, 283, 873, 149, 151, 151, 151, 150, 283,
1669 151, 155, 698, 156, 150, 155, 155, 156, 156, 172,
1670 172, 172, 176, 176, 176, 177, 205, 177, 177, 177,
1671 697, 426, 172, 149, 691, 176, 426, 198, 198, 198,
1672
1673 177, 149, 178, 150, 178, 877, 877, 178, 178, 178,
1674 198, 150, 154, 154, 154, 154, 154, 154, 154, 154,
1675 154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1676 154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1677 154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1678 154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1679 154, 154, 154, 154, 154, 154, 154, 154, 154, 154,
1680 154, 186, 186, 186, 690, 497, 186, 190, 688, 190,
1681 497, 190, 190, 200, 200, 200, 190, 190, 286, 190,
1682 201, 190, 201, 201, 201, 286, 200, 190, 190, 190,
1683
1684 190, 202, 687, 202, 686, 201, 202, 202, 202, 220,
1685 220, 220, 313, 313, 223, 223, 223, 292, 666, 224,
1686 224, 224, 665, 190, 292, 431, 265, 265, 265, 190,
1687 196, 220, 196, 431, 196, 196, 223, 378, 378, 196,
1688 196, 224, 196, 313, 196, 227, 227, 227, 265, 664,
1689 196, 196, 196, 196, 228, 228, 228, 241, 241, 241,
1690 227, 365, 435, 228, 242, 242, 242, 442, 378, 228,
1691 435, 560, 241, 242, 661, 442, 196, 659, 365, 242,
1692 368, 560, 196, 245, 245, 245, 246, 246, 246, 255,
1693 255, 255, 282, 282, 282, 246, 606, 368, 245, 658,
1694
1695 657, 246, 629, 606, 255, 256, 256, 256, 258, 258,
1696 258, 266, 266, 266, 256, 259, 259, 259, 654, 629,
1697 256, 614, 653, 258, 259, 270, 270, 270, 614, 652,
1698 259, 632, 647, 266, 273, 273, 273, 274, 274, 274,
1699 270, 874, 290, 299, 299, 299, 274, 874, 632, 273,
1700 290, 643, 274, 300, 300, 300, 299, 451, 451, 290,
1701 301, 301, 301, 641, 310, 640, 310, 310, 310, 270,
1702 311, 521, 311, 311, 311, 580, 521, 270, 273, 310,
1703 580, 274, 312, 312, 312, 311, 273, 638, 451, 274,
1704 277, 277, 277, 277, 277, 277, 277, 277, 277, 277,
1705
1706 277, 277, 277, 277, 277, 277, 277, 277, 277, 316,
1707 316, 316, 649, 601, 277, 277, 277, 304, 601, 304,
1708 649, 304, 304, 637, 316, 636, 304, 304, 635, 304,
1709 634, 304, 319, 319, 319, 529, 529, 304, 304, 304,
1710 304, 650, 320, 320, 320, 604, 321, 321, 321, 650,
1711 324, 324, 324, 604, 319, 321, 633, 316, 327, 327,
1712 327, 321, 604, 304, 320, 324, 529, 327, 631, 304,
1713 308, 639, 308, 327, 308, 308, 354, 354, 354, 308,
1714 308, 660, 308, 630, 308, 330, 330, 330, 639, 660,
1715 308, 308, 308, 308, 331, 331, 331, 334, 334, 334,
1716
1717 330, 651, 689, 331, 339, 339, 339, 628, 875, 331,
1718 689, 882, 334, 339, 875, 883, 308, 882, 651, 339,
1719 627, 883, 308, 341, 341, 341, 342, 342, 342, 344,
1720 344, 344, 347, 347, 347, 342, 884, 894, 341, 626,
1721 862, 342, 884, 894, 344, 353, 353, 347, 349, 349,
1722 349, 351, 351, 351, 862, 862, 353, 349, 355, 355,
1723 355, 353, 625, 349, 624, 623, 351, 356, 356, 356,
1724 373, 373, 373, 375, 375, 375, 347, 618, 376, 613,
1725 376, 376, 376, 377, 347, 377, 377, 377, 383, 383,
1726 383, 353, 349, 376, 612, 351, 608, 607, 377, 895,
1727
1728 349, 605, 612, 351, 603, 895, 379, 379, 379, 602,
1729 383, 612, 373, 374, 374, 374, 901, 374, 600, 374,
1730 374, 379, 901, 598, 374, 374, 596, 374, 902, 374,
1731 380, 380, 380, 904, 902, 374, 374, 374, 374, 904,
1732 381, 381, 381, 587, 581, 380, 578, 382, 382, 382,
1733 385, 385, 385, 570, 379, 381, 387, 387, 387, 374,
1734 905, 374, 382, 382, 567, 387, 905, 374, 388, 388,
1735 388, 387, 385, 559, 389, 389, 389, 558, 380, 390,
1736 390, 390, 555, 388, 553, 392, 392, 392, 381, 389,
1737 391, 391, 391, 382, 390, 382, 393, 393, 393, 391,
1738
1739 392, 394, 394, 394, 906, 391, 395, 395, 395, 547,
1740 906, 393, 396, 396, 396, 395, 394, 397, 397, 397,
1741 545, 395, 398, 398, 398, 544, 540, 396, 538, 403,
1742 403, 403, 397, 404, 404, 404, 528, 398, 403, 405,
1743 405, 405, 520, 519, 403, 406, 406, 406, 404, 407,
1744 407, 407, 517, 516, 405, 408, 408, 408, 407, 510,
1745 406, 409, 409, 409, 407, 410, 410, 410, 509, 508,
1746 408, 411, 411, 411, 507, 505, 409, 412, 412, 412,
1747 410, 413, 413, 413, 414, 414, 414, 415, 415, 415,
1748 504, 503, 412, 418, 418, 418, 413, 498, 496, 414,
1749
1750 495, 487, 415, 484, 445, 417, 417, 417, 418, 419,
1751 419, 419, 443, 411, 417, 420, 420, 420, 415, 441,
1752 417, 412, 440, 439, 419, 413, 436, 434, 414, 412,
1753 420, 415, 433, 413, 432, 430, 414, 418, 429, 415,
1754 421, 421, 421, 428, 424, 418, 422, 423, 423, 417,
1755 437, 437, 437, 419, 416, 421, 372, 417, 423, 420,
1756 371, 419, 370, 423, 425, 425, 369, 420, 438, 438,
1757 438, 421, 444, 444, 444, 425, 367, 427, 427, 427,
1758 425, 366, 364, 448, 421, 448, 448, 448, 363, 427,
1759 438, 362, 421, 423, 427, 361, 449, 360, 449, 449,
1760
1761 449, 359, 450, 450, 450, 358, 453, 453, 453, 357,
1762 425, 449, 352, 350, 444, 450, 348, 455, 455, 455,
1763 346, 453, 345, 343, 427, 447, 340, 447, 333, 447,
1764 447, 453, 455, 329, 447, 447, 323, 447, 314, 447,
1765 456, 456, 456, 306, 305, 447, 447, 447, 447, 456,
1766 303, 457, 457, 457, 453, 456, 297, 460, 460, 460,
1767 457, 458, 458, 458, 294, 455, 457, 511, 511, 511,
1768 458, 447, 460, 512, 512, 512, 458, 447, 452, 452,
1769 452, 452, 452, 452, 452, 293, 291, 452, 452, 459,
1770 459, 459, 289, 452, 452, 512, 288, 287, 459, 285,
1771
1772 452, 452, 452, 452, 459, 452, 461, 461, 461, 462,
1773 462, 462, 515, 515, 515, 461, 284, 280, 462, 276,
1774 275, 461, 272, 271, 462, 269, 452, 452, 452, 268,
1775 463, 463, 463, 452, 452, 452, 454, 454, 454, 463,
1776 264, 260, 454, 454, 257, 463, 454, 454, 454, 454,
1777 248, 454, 454, 454, 454, 454, 454, 243, 483, 483,
1778 483, 454, 229, 454, 454, 454, 454, 454, 454, 454,
1779 454, 454, 454, 454, 454, 454, 454, 454, 454, 454,
1780 454, 454, 454, 219, 454, 218, 454, 454, 454, 454,
1781 464, 464, 464, 454, 465, 465, 465, 216, 195, 464,
1782
1783 483, 466, 466, 466, 184, 464, 467, 467, 467, 465,
1784 466, 468, 468, 468, 174, 467, 466, 470, 470, 470,
1785 468, 467, 469, 469, 469, 170, 468, 473, 473, 473,
1786 160, 469, 470, 518, 518, 518, 473, 469, 474, 474,
1787 474, 157, 473, 475, 475, 475, 141, 474, 476, 476,
1788 476, 138, 475, 474, 477, 477, 477, 476, 475, 478,
1789 478, 478, 124, 476, 479, 479, 479, 122, 478, 477,
1790 482, 482, 482, 479, 478, 480, 480, 480, 120, 479,
1791 481, 481, 481, 104, 480, 482, 485, 485, 485, 481,
1792 480, 486, 486, 486, 103, 481, 488, 488, 488, 102,
1793
1794 101, 485, 514, 514, 514, 488, 486, 489, 489, 489,
1795 100, 488, 490, 490, 490, 99, 489, 491, 491, 491,
1796 97, 490, 489, 96, 514, 92, 491, 490, 90, 82,
1797 485, 77, 491, 486, 71, 486, 70, 69, 485, 55,
1798 488, 54, 50, 486, 45, 492, 492, 492, 488, 44,
1799 43, 489, 42, 41, 492, 32, 490, 31, 30, 489,
1800 492, 491, 29, 26, 490, 493, 493, 493, 25, 491,
1801 494, 494, 494, 522, 522, 522, 492, 548, 548, 548,
1802 493, 499, 499, 499, 523, 494, 523, 523, 523, 492,
1803 500, 500, 500, 499, 501, 501, 501, 492, 499, 549,
1804
1805 549, 549, 500, 524, 524, 524, 501, 500, 22, 493,
1806 21, 501, 494, 16, 494, 15, 524, 493, 531, 531,
1807 531, 549, 494, 532, 532, 532, 0, 531, 499, 551,
1808 551, 551, 532, 531, 539, 539, 539, 500, 532, 0,
1809 0, 501, 525, 525, 525, 525, 525, 525, 525, 539,
1810 0, 525, 525, 533, 533, 533, 0, 525, 525, 552,
1811 552, 552, 533, 539, 525, 525, 525, 525, 533, 525,
1812 536, 536, 536, 537, 537, 537, 0, 0, 539, 536,
1813 0, 0, 537, 0, 0, 536, 539, 0, 537, 0,
1814 525, 525, 525, 554, 554, 554, 0, 525, 525, 525,
1815
1816 530, 530, 530, 557, 557, 557, 0, 530, 0, 0,
1817 530, 530, 530, 530, 0, 530, 530, 530, 541, 541,
1818 541, 542, 542, 542, 0, 530, 0, 541, 0, 0,
1819 542, 0, 0, 541, 0, 0, 542, 543, 543, 543,
1820 573, 573, 573, 565, 565, 565, 530, 0, 530, 566,
1821 566, 566, 543, 569, 569, 569, 571, 571, 571, 572,
1822 572, 572, 541, 542, 566, 542, 543, 0, 569, 0,
1823 541, 0, 0, 542, 565, 0, 566, 565, 0, 0,
1824 569, 543, 574, 574, 574, 575, 575, 575, 0, 543,
1825 556, 556, 556, 566, 565, 0, 0, 569, 582, 582,
1826
1827 582, 566, 589, 589, 589, 569, 571, 0, 0, 572,
1828 0, 589, 0, 592, 592, 592, 0, 589, 0, 0,
1829 556, 556, 592, 0, 556, 593, 593, 593, 592, 594,
1830 594, 594, 0, 0, 556, 595, 595, 595, 597, 597,
1831 597, 556, 556, 561, 561, 561, 561, 561, 561, 561,
1832 561, 561, 561, 561, 561, 561, 561, 561, 561, 561,
1833 561, 561, 0, 568, 568, 568, 561, 561, 561, 561,
1834 0, 0, 568, 561, 563, 563, 563, 0, 568, 0,
1835 0, 563, 0, 0, 563, 563, 563, 563, 0, 563,
1836 563, 563, 568, 0, 0, 585, 585, 585, 0, 563,
1837
1838 599, 599, 599, 588, 588, 588, 0, 568, 655, 655,
1839 655, 0, 590, 590, 590, 568, 0, 0, 588, 0,
1840 563, 590, 563, 576, 576, 576, 585, 590, 0, 585,
1841 662, 662, 662, 0, 616, 616, 616, 0, 0, 590,
1842 0, 0, 588, 616, 0, 0, 585, 588, 0, 616,
1843 621, 621, 621, 576, 576, 588, 590, 576, 0, 621,
1844 692, 692, 692, 0, 590, 621, 0, 576, 696, 696,
1845 696, 699, 699, 699, 576, 576, 583, 583, 583, 583,
1846 583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1847 583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1848
1849 583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1850 583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1851 583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
1852 583, 583, 583, 583, 583, 591, 591, 591, 615, 615,
1853 615, 0, 619, 619, 619, 620, 620, 620, 0, 0,
1854 591, 619, 0, 615, 701, 701, 701, 619, 0, 0,
1855 620, 0, 642, 642, 642, 0, 656, 656, 656, 615,
1856 0, 642, 0, 0, 591, 0, 620, 642, 0, 591,
1857 0, 619, 615, 644, 644, 644, 619, 591, 656, 620,
1858 615, 0, 644, 0, 619, 0, 0, 620, 644, 0,
1859
1860 645, 645, 645, 646, 646, 646, 642, 0, 0, 645,
1861 0, 0, 646, 0, 642, 645, 0, 0, 646, 648,
1862 648, 648, 0, 663, 663, 663, 0, 0, 648, 0,
1863 0, 645, 0, 0, 648, 693, 693, 693, 0, 667,
1864 667, 667, 0, 0, 645, 663, 0, 646, 667, 668,
1865 668, 668, 645, 0, 667, 646, 0, 693, 668, 669,
1866 669, 669, 0, 0, 668, 670, 670, 670, 669, 672,
1867 672, 672, 0, 0, 669, 680, 680, 680, 672, 0,
1868 670, 0, 0, 667, 672, 673, 673, 673, 0, 0,
1869 680, 667, 0, 668, 673, 674, 674, 674, 0, 0,
1870
1871 673, 668, 0, 669, 674, 675, 675, 675, 0, 670,
1872 674, 669, 0, 0, 675, 0, 0, 670, 0, 680,
1873 675, 676, 676, 676, 677, 677, 677, 680, 0, 0,
1874 676, 0, 0, 677, 0, 0, 676, 0, 0, 677,
1875 678, 678, 678, 679, 679, 679, 732, 732, 732, 678,
1876 0, 0, 679, 0, 0, 678, 0, 0, 679, 0,
1877 682, 682, 682, 0, 0, 676, 0, 0, 677, 682,
1878 683, 683, 683, 676, 0, 682, 677, 0, 0, 683,
1879 0, 684, 684, 684, 678, 683, 0, 679, 0, 0,
1880 684, 0, 678, 0, 0, 679, 684, 685, 685, 685,
1881
1882 695, 695, 695, 700, 700, 700, 685, 0, 704, 704,
1883 704, 0, 685, 733, 733, 733, 0, 704, 705, 705,
1884 705, 0, 695, 704, 0, 700, 0, 705, 706, 706,
1885 706, 0, 0, 705, 736, 736, 736, 706, 707, 707,
1886 707, 0, 0, 706, 737, 737, 737, 707, 708, 708,
1887 708, 0, 704, 707, 740, 740, 740, 708, 0, 0,
1888 704, 0, 705, 708, 0, 0, 709, 709, 709, 0,
1889 705, 0, 706, 0, 0, 709, 710, 710, 710, 708,
1890 706, 709, 707, 0, 0, 710, 711, 711, 711, 0,
1891 707, 710, 708, 0, 0, 711, 712, 712, 712, 0,
1892
1893 708, 711, 741, 741, 741, 712, 713, 713, 713, 0,
1894 709, 712, 743, 743, 743, 713, 0, 0, 709, 0,
1895 0, 713, 714, 714, 714, 715, 715, 715, 744, 744,
1896 744, 714, 0, 0, 715, 0, 0, 714, 0, 0,
1897 715, 716, 716, 716, 717, 717, 717, 770, 770, 770,
1898 716, 0, 0, 717, 0, 0, 716, 0, 0, 717,
1899 0, 718, 718, 718, 721, 721, 721, 0, 0, 715,
1900 718, 0, 0, 721, 0, 0, 718, 715, 0, 721,
1901 722, 722, 722, 0, 0, 716, 0, 0, 717, 722,
1902 771, 771, 771, 716, 0, 722, 717, 723, 723, 723,
1903
1904 724, 724, 724, 0, 0, 718, 723, 0, 721, 724,
1905 0, 0, 723, 718, 0, 724, 721, 0, 0, 725,
1906 725, 725, 0, 0, 722, 772, 772, 772, 725, 773,
1907 773, 773, 722, 0, 725, 0, 726, 726, 726, 0,
1908 0, 723, 0, 0, 724, 726, 727, 727, 727, 723,
1909 725, 726, 724, 0, 0, 727, 0, 728, 728, 728,
1910 0, 727, 0, 725, 0, 0, 728, 729, 729, 729,
1911 0, 725, 728, 738, 738, 738, 729, 730, 730, 730,
1912 726, 0, 729, 774, 774, 774, 730, 0, 726, 731,
1913 731, 731, 730, 0, 0, 738, 0, 0, 731, 745,
1914
1915 745, 745, 0, 0, 731, 746, 746, 746, 745, 747,
1916 747, 747, 0, 0, 745, 776, 776, 776, 747, 0,
1917 746, 748, 748, 748, 747, 749, 749, 749, 0, 0,
1918 748, 777, 777, 777, 749, 0, 748, 750, 750, 750,
1919 749, 0, 0, 745, 0, 0, 750, 0, 0, 746,
1920 0, 745, 750, 747, 778, 778, 778, 746, 802, 802,
1921 802, 747, 803, 803, 803, 748, 0, 0, 0, 749,
1922 751, 751, 751, 748, 0, 0, 0, 749, 0, 751,
1923 0, 750, 752, 752, 752, 751, 0, 0, 0, 750,
1924 0, 752, 0, 754, 754, 754, 0, 752, 755, 755,
1925
1926 755, 751, 754, 756, 756, 756, 0, 755, 754, 0,
1927 0, 0, 756, 755, 751, 757, 757, 757, 756, 0,
1928 0, 0, 751, 0, 757, 758, 758, 758, 0, 0,
1929 757, 761, 761, 761, 758, 0, 0, 754, 0, 0,
1930 758, 0, 755, 0, 0, 754, 761, 756, 0, 0,
1931 755, 759, 759, 759, 0, 756, 758, 0, 0, 757,
1932 759, 760, 760, 760, 0, 0, 759, 757, 0, 758,
1933 760, 763, 763, 763, 0, 761, 760, 758, 0, 0,
1934 763, 0, 0, 761, 0, 0, 763, 764, 764, 764,
1935 0, 765, 765, 765, 0, 759, 764, 0, 0, 0,
1936
1937 765, 0, 764, 759, 0, 760, 765, 766, 766, 766,
1938 767, 767, 767, 760, 0, 763, 766, 0, 0, 767,
1939 0, 0, 766, 763, 0, 767, 0, 768, 768, 768,
1940 0, 764, 0, 0, 0, 765, 768, 0, 0, 764,
1941 0, 767, 768, 765, 0, 0, 779, 779, 779, 0,
1942 0, 766, 0, 0, 767, 779, 780, 780, 780, 766,
1943 0, 779, 767, 0, 0, 780, 781, 781, 781, 0,
1944 0, 780, 0, 0, 0, 781, 782, 782, 782, 0,
1945 0, 781, 0, 0, 0, 782, 783, 783, 783, 0,
1946 779, 782, 0, 0, 0, 783, 0, 0, 779, 0,
1947
1948 780, 783, 784, 784, 784, 0, 0, 0, 780, 0,
1949 781, 784, 785, 785, 785, 0, 0, 784, 781, 0,
1950 782, 785, 787, 787, 787, 0, 0, 785, 782, 0,
1951 783, 787, 0, 784, 786, 786, 786, 787, 783, 0,
1952 0, 0, 0, 786, 0, 0, 784, 0, 0, 786,
1953 788, 788, 788, 0, 784, 0, 785, 0, 0, 788,
1954 789, 789, 789, 0, 785, 788, 787, 0, 0, 789,
1955 790, 790, 790, 0, 787, 789, 786, 0, 786, 790,
1956 791, 791, 791, 0, 0, 790, 786, 0, 0, 791,
1957 792, 792, 792, 0, 788, 791, 0, 0, 0, 792,
1958
1959 0, 0, 788, 0, 789, 792, 0, 0, 793, 793,
1960 793, 0, 789, 0, 790, 0, 0, 793, 794, 794,
1961 794, 792, 790, 793, 791, 0, 0, 794, 795, 795,
1962 795, 0, 791, 794, 792, 0, 0, 795, 796, 796,
1963 796, 0, 792, 795, 0, 0, 0, 796, 797, 797,
1964 797, 0, 793, 796, 0, 0, 0, 797, 0, 0,
1965 793, 0, 794, 797, 798, 798, 798, 0, 0, 0,
1966 794, 0, 795, 798, 799, 799, 799, 0, 0, 798,
1967 795, 0, 796, 799, 800, 800, 800, 0, 0, 799,
1968 796, 0, 797, 800, 0, 801, 801, 801, 0, 800,
1969
1970 797, 0, 0, 0, 801, 799, 0, 0, 798, 0,
1971 801, 0, 804, 804, 804, 0, 798, 0, 799, 0,
1972 0, 804, 0, 805, 805, 805, 799, 804, 800, 0,
1973 0, 0, 805, 806, 806, 806, 800, 801, 805, 801,
1974 0, 0, 806, 0, 807, 807, 807, 801, 806, 0,
1975 0, 0, 805, 807, 0, 0, 804, 0, 0, 807,
1976 0, 808, 808, 808, 804, 0, 0, 805, 0, 0,
1977 808, 809, 809, 809, 0, 805, 808, 806, 0, 0,
1978 809, 0, 0, 0, 0, 806, 809, 0, 807, 810,
1979 810, 810, 811, 811, 811, 0, 807, 0, 810, 0,
1980
1981 0, 811, 0, 0, 810, 808, 0, 811, 0, 812,
1982 812, 812, 0, 808, 0, 809, 0, 0, 812, 0,
1983 810, 0, 0, 809, 812, 813, 813, 813, 815, 815,
1984 815, 0, 0, 810, 813, 0, 811, 815, 0, 0,
1985 813, 810, 0, 815, 811, 0, 0, 816, 816, 816,
1986 0, 812, 0, 812, 0, 0, 816, 815, 817, 817,
1987 817, 812, 816, 0, 0, 0, 0, 817, 0, 813,
1988 0, 0, 815, 817, 816, 0, 0, 813, 0, 0,
1989 815, 0, 0, 818, 818, 818, 819, 819, 819, 0,
1990 0, 816, 818, 0, 0, 819, 0, 0, 818, 816,
1991
1992 0, 819, 817, 0, 0, 820, 820, 820, 0, 0,
1993 817, 0, 818, 819, 820, 0, 821, 821, 821, 0,
1994 820, 0, 0, 0, 0, 821, 0, 818, 0, 0,
1995 819, 821, 822, 822, 822, 818, 0, 0, 819, 0,
1996 0, 822, 0, 821, 820, 0, 0, 822, 0, 820,
1997 823, 823, 823, 0, 824, 824, 824, 820, 0, 823,
1998 821, 0, 0, 824, 0, 823, 0, 0, 821, 824,
1999 0, 822, 0, 825, 825, 825, 822, 826, 826, 826,
2000 0, 823, 825, 0, 822, 0, 826, 0, 825, 0,
2001 0, 0, 826, 824, 823, 0, 0, 0, 824, 827,
2002
2003 827, 827, 823, 0, 825, 0, 824, 0, 827, 828,
2004 828, 828, 0, 0, 827, 0, 0, 825, 828, 0,
2005 0, 826, 0, 0, 828, 825, 829, 829, 829, 826,
2006 827, 0, 0, 0, 0, 829, 0, 0, 0, 0,
2007 0, 829, 0, 827, 0, 0, 0, 0, 0, 0,
2008 0, 827, 0, 828, 0, 0, 0, 0, 0, 0,
2009 0, 828, 0, 0, 0, 0, 0, 0, 0, 0,
2010 829, 0, 0, 0, 0, 0, 0, 0, 829, 831,
2011 831, 831, 831, 831, 831, 831, 831, 831, 831, 831,
2012 831, 831, 831, 831, 831, 831, 831, 831, 831, 831,
2013
2014 831, 832, 832, 832, 832, 832, 832, 832, 832, 832,
2015 832, 832, 832, 832, 832, 832, 832, 832, 832, 832,
2016 832, 832, 832, 833, 833, 833, 833, 833, 833, 833,
2017 833, 833, 833, 833, 833, 833, 833, 833, 833, 833,
2018 833, 833, 833, 833, 833, 834, 834, 834, 834, 834,
2019 834, 834, 834, 834, 834, 834, 834, 834, 834, 834,
2020 834, 834, 834, 834, 834, 834, 834, 835, 835, 835,
2021 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
2022 835, 835, 835, 835, 835, 835, 835, 835, 835, 836,
2023 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
2024
2025 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
2026 836, 837, 837, 837, 837, 837, 837, 837, 837, 837,
2027 837, 837, 837, 837, 837, 837, 837, 837, 837, 837,
2028 837, 837, 837, 838, 838, 838, 838, 838, 838, 838,
2029 838, 838, 838, 838, 838, 838, 838, 838, 838, 838,
2030 838, 838, 838, 838, 838, 839, 839, 839, 839, 839,
2031 839, 839, 839, 839, 839, 839, 839, 839, 839, 839,
2032 839, 839, 839, 839, 839, 839, 839, 840, 840, 840,
2033 840, 840, 840, 840, 840, 840, 840, 840, 840, 840,
2034 840, 840, 840, 840, 840, 840, 840, 840, 840, 841,
2035
2036 841, 841, 841, 841, 841, 841, 841, 841, 841, 841,
2037 841, 841, 841, 841, 841, 841, 841, 841, 841, 841,
2038 841, 842, 842, 842, 842, 842, 842, 842, 842, 842,
2039 842, 842, 842, 842, 842, 842, 842, 842, 842, 842,
2040 842, 842, 842, 843, 843, 843, 843, 843, 843, 843,
2041 843, 843, 843, 843, 843, 843, 843, 843, 843, 843,
2042 843, 843, 843, 843, 843, 844, 0, 0, 0, 0,
2043 0, 0, 0, 844, 0, 0, 0, 0, 0, 844,
2044 844, 845, 0, 0, 845, 0, 0, 845, 845, 0,
2045 845, 0, 0, 0, 845, 845, 845, 846, 0, 0,
2046
2047 0, 0, 0, 0, 0, 846, 0, 0, 0, 0,
2048 0, 846, 846, 847, 0, 0, 847, 0, 847, 847,
2049 848, 0, 0, 0, 0, 0, 0, 0, 848, 0,
2050 0, 0, 0, 0, 848, 848, 849, 849, 849, 849,
2051 0, 849, 849, 849, 849, 849, 849, 849, 849, 849,
2052 849, 849, 0, 849, 0, 849, 849, 849, 850, 850,
2053 850, 850, 0, 850, 850, 850, 850, 850, 850, 850,
2054 850, 850, 850, 850, 850, 850, 850, 850, 850, 850,
2055 851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
2056 851, 851, 851, 851, 851, 851, 851, 851, 0, 851,
2057
2058 851, 851, 852, 0, 0, 0, 0, 0, 0, 0,
2059 852, 0, 0, 0, 0, 0, 852, 852, 853, 853,
2060 0, 0, 853, 0, 0, 0, 0, 0, 0, 0,
2061 853, 0, 853, 0, 0, 0, 853, 853, 854, 854,
2062 854, 854, 854, 854, 854, 0, 854, 854, 854, 854,
2063 854, 854, 854, 854, 854, 854, 854, 854, 854, 854,
2064 855, 855, 855, 855, 855, 855, 855, 855, 855, 0,
2065 855, 855, 0, 855, 855, 855, 855, 855, 855, 855,
2066 855, 855, 856, 856, 856, 856, 0, 856, 856, 856,
2067 856, 856, 856, 856, 856, 856, 856, 856, 856, 856,
2068
2069 856, 856, 856, 856, 857, 857, 857, 857, 857, 857,
2070 857, 0, 857, 857, 857, 857, 857, 857, 857, 857,
2071 857, 857, 857, 857, 857, 857, 858, 858, 858, 858,
2072 858, 858, 858, 0, 858, 858, 858, 858, 858, 858,
2073 858, 858, 858, 858, 858, 858, 858, 859, 859, 859,
2074 859, 859, 859, 859, 859, 859, 859, 859, 859, 859,
2075 859, 859, 859, 859, 859, 859, 859, 859, 859, 860,
2076 860, 860, 860, 860, 860, 860, 0, 860, 860, 860,
2077 860, 860, 860, 860, 860, 860, 860, 860, 860, 860,
2078 860, 861, 861, 861, 861, 861, 0, 861, 861, 861,
2079
2080 861, 861, 861, 861, 861, 861, 861, 861, 861, 861,
2081 861, 861, 861, 863, 863, 0, 0, 863, 0, 0,
2082 0, 0, 0, 0, 0, 863, 0, 863, 0, 0,
2083 0, 863, 863, 864, 0, 0, 864, 0, 0, 864,
2084 864, 0, 864, 0, 0, 0, 864, 864, 864, 865,
2085 865, 865, 865, 865, 865, 865, 865, 865, 865, 865,
2086 865, 865, 865, 865, 865, 865, 865, 865, 865, 865,
2087 865, 867, 0, 0, 0, 0, 0, 0, 0, 867,
2088 0, 0, 0, 0, 0, 867, 867, 868, 868, 0,
2089 868, 868, 868, 868, 868, 868, 868, 868, 868, 868,
2090
2091 868, 868, 868, 868, 868, 868, 868, 868, 868, 869,
2092 0, 0, 869, 0, 0, 869, 869, 0, 869, 0,
2093 0, 0, 869, 869, 869, 870, 0, 0, 0, 0,
2094 870, 870, 0, 870, 0, 0, 0, 0, 0, 870,
2095 870, 871, 0, 0, 871, 0, 0, 871, 871, 0,
2096 871, 0, 0, 0, 871, 871, 871, 872, 0, 0,
2097 872, 0, 0, 872, 872, 0, 872, 0, 0, 0,
2098 872, 872, 872, 876, 0, 0, 0, 0, 0, 0,
2099 0, 876, 0, 0, 0, 0, 0, 876, 876, 878,
2100 878, 0, 0, 878, 878, 0, 878, 878, 878, 878,
2101
2102 878, 878, 0, 0, 0, 0, 878, 878, 878, 879,
2103 879, 879, 879, 879, 879, 879, 879, 879, 879, 879,
2104 879, 879, 879, 879, 879, 879, 879, 879, 879, 879,
2105 879, 880, 880, 880, 880, 880, 880, 880, 880, 880,
2106 880, 880, 880, 880, 880, 880, 880, 880, 880, 880,
2107 880, 880, 880, 881, 881, 881, 881, 881, 881, 881,
2108 881, 881, 881, 881, 881, 881, 881, 881, 881, 881,
2109 881, 881, 881, 881, 881, 885, 885, 885, 885, 885,
2110 885, 885, 885, 885, 885, 885, 885, 885, 885, 885,
2111 885, 885, 885, 885, 885, 885, 885, 886, 886, 886,
2112
2113 886, 886, 886, 886, 886, 886, 886, 886, 886, 886,
2114 886, 886, 886, 886, 886, 886, 886, 886, 886, 887,
2115 887, 887, 887, 887, 887, 887, 887, 887, 887, 887,
2116 887, 887, 887, 887, 887, 887, 887, 887, 887, 887,
2117 887, 888, 888, 888, 888, 888, 888, 888, 888, 888,
2118 888, 888, 888, 888, 888, 888, 888, 888, 888, 888,
2119 888, 888, 888, 889, 889, 889, 889, 889, 889, 889,
2120 889, 889, 889, 889, 889, 889, 889, 889, 889, 889,
2121 889, 889, 889, 889, 889, 890, 0, 0, 0, 0,
2122 890, 890, 0, 890, 0, 0, 0, 0, 0, 890,
2123
2124 890, 891, 891, 891, 891, 891, 891, 891, 891, 891,
2125 891, 891, 891, 891, 891, 891, 891, 891, 891, 891,
2126 891, 891, 891, 892, 892, 892, 892, 892, 892, 892,
2127 892, 892, 892, 892, 892, 892, 892, 892, 892, 892,
2128 892, 892, 892, 892, 892, 893, 893, 893, 893, 893,
2129 893, 893, 893, 893, 893, 893, 893, 893, 893, 893,
2130 893, 893, 893, 893, 893, 893, 893, 896, 896, 896,
2131 896, 896, 896, 896, 896, 896, 896, 896, 896, 896,
2132 896, 896, 896, 896, 896, 896, 896, 896, 896, 897,
2133 897, 897, 897, 897, 897, 897, 897, 897, 897, 897,
2134
2135 897, 897, 897, 897, 897, 897, 897, 897, 897, 897,
2136 897, 898, 898, 898, 898, 898, 898, 898, 898, 898,
2137 898, 898, 898, 898, 898, 898, 898, 898, 898, 898,
2138 898, 898, 898, 899, 899, 899, 899, 899, 899, 899,
2139 899, 899, 899, 899, 899, 0, 899, 899, 899, 899,
2140 899, 899, 899, 899, 899, 900, 900, 900, 900, 900,
2141 900, 900, 900, 900, 900, 900, 900, 900, 900, 900,
2142 900, 900, 900, 900, 900, 900, 900, 903, 903, 0,
2143 0, 903, 903, 0, 903, 903, 903, 903, 903, 903,
2144 0, 0, 0, 0, 903, 903, 903, 907, 907, 907,
2145
2146 907, 907, 907, 907, 0, 907, 907, 907, 907, 907,
2147 907, 907, 907, 907, 907, 907, 907, 907, 907, 908,
2148 908, 908, 908, 908, 908, 908, 0, 908, 908, 908,
2149 908, 908, 908, 908, 908, 908, 908, 908, 908, 908,
2150 908, 909, 909, 909, 909, 909, 909, 909, 909, 909,
2151 909, 909, 909, 909, 909, 909, 909, 909, 909, 909,
2152 909, 909, 909, 910, 910, 910, 910, 910, 910, 910,
2153 910, 910, 910, 910, 910, 910, 910, 910, 910, 910,
2154 910, 910, 910, 910, 910, 911, 911, 911, 911, 911,
2155 911, 911, 911, 911, 911, 911, 911, 911, 911, 911,
2156
2157 911, 911, 911, 911, 911, 911, 911, 912, 912, 912,
2158 912, 912, 912, 912, 912, 912, 912, 912, 912, 912,
2159 912, 912, 912, 912, 912, 912, 912, 912, 912, 913,
2160 913, 913, 913, 913, 913, 913, 913, 913, 913, 913,
2161 913, 913, 913, 913, 913, 913, 913, 913, 913, 913,
2162 913, 914, 914, 914, 914, 914, 914, 914, 914, 914,
2163 914, 914, 914, 914, 914, 914, 914, 914, 914, 914,
2164 914, 914, 914, 915, 915, 915, 915, 915, 915, 915,
2165 915, 915, 915, 915, 915, 915, 915, 915, 915, 915,
2166 915, 915, 915, 915, 915, 916, 916, 916, 916, 916,
2167
2168 916, 916, 916, 916, 916, 916, 916, 916, 916, 916,
2169 916, 916, 916, 916, 916, 916, 916, 917, 917, 917,
2170 917, 917, 917, 917, 917, 917, 917, 917, 917, 917,
2171 917, 917, 917, 917, 917, 917, 917, 917, 917, 918,
2172 918, 918, 918, 918, 918, 918, 918, 918, 918, 918,
2173 918, 918, 918, 918, 918, 918, 918, 918, 918, 918,
2174 918, 919, 919, 919, 919, 919, 919, 919, 919, 919,
2175 919, 919, 919, 919, 919, 919, 919, 919, 919, 919,
2176 919, 919, 919, 920, 920, 920, 920, 920, 920, 920,
2177 920, 920, 920, 920, 920, 920, 920, 920, 920, 920,
2178
2179 920, 920, 920, 920, 920, 921, 921, 921, 921, 921,
2180 921, 921, 921, 921, 921, 921, 921, 921, 921, 921,
2181 921, 921, 921, 921, 921, 921, 921, 830, 830, 830,
2182 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2183 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2184 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2185 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2186 830, 830, 830, 830, 830, 830, 830, 830, 830, 830,
2187 830, 830, 830, 830, 830, 830, 830
2188 } ;
2189
2190 /* Table of booleans, true if rule could match eol. */
2191 static const flex_int32_t yy_rule_can_match_eol[152] =
2192 { 0,
2193 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1,
2194 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0,
2195 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0,
2196 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1,
2197 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
2198 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2199 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
2200 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, };
2201
2202 static yy_state_type yy_last_accepting_state;
2203 static char *yy_last_accepting_cpos;
2204
2205 extern int yy_flex_debug;
2206 int yy_flex_debug = 0;
2207
2208 /* The intent behind this definition is that it'll catch
2209 * any uses of REJECT which flex missed.
2210 */
2211 #define REJECT reject_used_but_not_detected
2212 #define yymore() yymore_used_but_not_detected
2213 #define YY_MORE_ADJ 0
2214 #define YY_RESTORE_YY_MORE_OFFSET
2215 char *yytext;
2216 #line 1 "pgc.l"
2217
2218 #line 31 "pgc.l"
2219 extern YYSTYPE base_yylval;
2220
2221 static int xcdepth = 0; /* depth of nesting in slash-star comments */
2222 static char *dolqstart = NULL; /* current $foo$ quote start string */
2223 static YY_BUFFER_STATE scanbufhandle;
2224 static char *scanbuf;
2225
2226 /*
2227 * literalbuf is used to accumulate literal values when multiple rules
2228 * are needed to parse a single literal. Call startlit to reset buffer
2229 * to empty, addlit to add text. Note that the buffer is permanently
2230 * malloc'd to the largest size needed so far in the current run.
2231 */
2232 static char *literalbuf = NULL; /* expandable buffer */
2233 static int literallen; /* actual current length */
2234 static int literalalloc; /* current allocated buffer size */
2235
2236 /* Used for detecting global state together with braces_open */
2237 static int parenths_open;
2238
2239 /* Used to tell parse_include() whether the command was #include or #include_next */
2240 static bool include_next;
2241
2242 #define startlit() (literalbuf[0] = '\0', literallen = 0)
2243 static void addlit(char *ytext, int yleng);
2244 static void addlitchar (unsigned char);
2245 static void parse_include (void);
2246 static bool ecpg_isspace(char ch);
2247 static bool isdefine(void);
2248 static bool isinformixdefine(void);
2249
2250 char *token_start;
2251 static int state_before;
2252
2253 struct _yy_buffer
2254 {
2255 YY_BUFFER_STATE buffer;
2256 long lineno;
2257 char *filename;
2258 struct _yy_buffer *next;
2259 } *yy_buffer = NULL;
2260
2261 static char *old;
2262
2263 #define MAX_NESTED_IF 128
2264 static short preproc_tos;
2265 static short ifcond;
2266 static struct _if_value
2267 {
2268 short condition;
2269 short else_branch;
2270 } stacked_if_value[MAX_NESTED_IF];
2271
2272 /* LCOV_EXCL_START */
2273
2274 #line 2275 "pgc.c"
2275 #define YY_NO_INPUT 1
2276
2277 /*
2278 * OK, here is a short description of lex/flex rules behavior.
2279 * The longest pattern which matches an input string is always chosen.
2280 * For equal-length patterns, the first occurring in the rules list is chosen.
2281 * INITIAL is the starting state, to which all non-conditional rules apply.
2282 * Exclusive states change parsing rules while the state is active. When in
2283 * an exclusive state, only those rules defined for that state apply.
2284 *
2285 * We use exclusive states for quoted strings, extended comments,
2286 * and to eliminate parsing troubles for numeric strings.
2287 * Exclusive states:
2288 * <xb> bit string literal
2289 * <xcc> extended C-style comments in C
2290 * <xcsql> extended C-style comments in SQL
2291 * <xd> delimited identifiers (double-quoted identifiers) - thomas 1997-10-27
2292 * <xh> hexadecimal numeric string - thomas 1997-11-16
2293 * <xq> standard quoted strings - thomas 1997-07-30
2294 * <xqc> standard quoted strings in C - michael
2295 * <xe> extended quoted strings (support backslash escape sequences)
2296 * <xn> national character quoted strings
2297 * <xdolq> $foo$ quoted strings
2298 * <xui> quoted identifier with Unicode escapes
2299 * <xus> quoted string with Unicode escapes
2300 */
2301
2302 /* Bit string
2303 */
2304 /* Hexadecimal number */
2305 /* National character */
2306 /* Quoted string that allows backslash escapes */
2307 /* C version of hex number */
2308 /* Extended quote
2309 * xqdouble implements embedded quote, ''''
2310 */
2311 /* $foo$ style quotes ("dollar quoting")
2312 * The quoted string starts with $foo$ where "foo" is an optional string
2313 * in the form of an identifier, except that it may not contain "$",
2314 * and extends to the first occurrence of an identical string.
2315 * There is *no* processing of the quoted text.
2316 *
2317 * {dolqfailed} is an error rule to avoid scanner backup when {dolqdelim}
2318 * fails to match its trailing "$".
2319 */
2320 /* Double quote
2321 * Allows embedded spaces and other special characters into identifiers.
2322 */
2323 /* Unicode escapes */
2324 /* (The ecpg scanner is not backup-free, so the fail rules in scan.l are not needed here, but could be added if desired.) */
2325 /* Quoted identifier with Unicode escapes */
2326 /* Quoted string with Unicode escapes */
2327 /* special stuff for C strings */
2328 /* C-style comments
2329 *
2330 * The "extended comment" syntax closely resembles allowable operator syntax.
2331 * The tricky part here is to get lex to recognize a string starting with
2332 * slash-star as a comment, when interpreting it as an operator would produce
2333 * a longer match --- remember lex will prefer a longer match! Also, if we
2334 * have something like plus-slash-star, lex will think this is a 3-character
2335 * operator whereas we want to see it as a + operator and a comment start.
2336 * The solution is two-fold:
2337 * 1. append {op_chars}* to xcstart so that it matches as much text as
2338 * {operator} would. Then the tie-breaker (first matching rule of same
2339 * length) ensures xcstart wins. We put back the extra stuff with yyless()
2340 * in case it contains a star-slash that should terminate the comment.
2341 * 2. In the operator rule, check for slash-star within the operator, and
2342 * if found throw it back with yyless(). This handles the plus-slash-star
2343 * problem.
2344 * Dash-dash comments have similar interactions with the operator rule.
2345 */
2346 /* Assorted special-case operators and operator-like tokens */
2347 /*
2348 * These operator-like tokens (unlike the above ones) also match the {operator}
2349 * rule, which means that they might be overridden by a longer match if they
2350 * are followed by a comment start or a + or - character. Accordingly, if you
2351 * add to this list, you must also add corresponding code to the {operator}
2352 * block to return the correct token in such cases. (This is not needed in
2353 * psqlscan.l since the token value is ignored there.)
2354 */
2355 /*
2356 * "self" is the set of chars that should be returned as single-character
2357 * tokens. "op_chars" is the set of chars that can make up "Op" tokens,
2358 * which can be one or more characters long (but if a single-char token
2359 * appears in the "self" set, it is not to be returned as an Op). Note
2360 * that the sets overlap, but each has some chars that are not in the other.
2361 *
2362 * If you change either set, adjust the character lists appearing in the
2363 * rule for "operator"!
2364 */
2365 /* we no longer allow unary minus in numbers.
2366 * instead we pass it separately to parser. there it gets
2367 * coerced via doNegate() -- Leon aug 20 1999
2368 *
2369 * {realfail1} and {realfail2} are added to prevent the need for scanner
2370 * backup when the {real} rule fails to match completely.
2371 */
2372 /*
2373 * In order to make the world safe for Windows and Mac clients as well as
2374 * Unix ones, we accept either \n or \r as a newline. A DOS-style \r\n
2375 * sequence will be seen as two successive newlines, but that doesn't cause
2376 * any problems. SQL-style comments, which start with -- and extend to the
2377 * next newline, are treated as equivalent to a single whitespace character.
2378 *
2379 * NOTE a fine point: if there is no newline following --, we will absorb
2380 * everything to the end of the input as a comment. This is correct. Older
2381 * versions of Postgres failed to recognize -- as a comment if the input
2382 * did not end with a newline.
2383 *
2384 * XXX perhaps \f (formfeed) should be treated as a newline as well?
2385 *
2386 * XXX if you change the set of whitespace characters, fix ecpg_isspace()
2387 * to agree.
2388 */
2389 /*
2390 * SQL requires at least one newline in the whitespace separating
2391 * string literals that are to be concatenated. Silly, but who are we
2392 * to argue? Note that {whitespace_with_newline} should not have * after
2393 * it, whereas {whitespace} should generally have a * after it...
2394 */
2395 /* special characters for other dbms */
2396 /* we have to react differently in compat mode */
2397 /* some stuff needed for ecpg */
2398 /* we might want to parse all cpp include files */
2399 /* take care of cpp lines, they may also be continuated */
2400 /* first a general line for all commands not starting with "i" */
2401 /* and then the other commands starting with "i", we have to add these
2402 * separately because the cppline production would match on "include" too */
2403 /*
2404 * Dollar quoted strings are totally opaque, and no escaping is done on them.
2405 * Other quoted strings must allow some special characters such as single-quote
2406 * and newline.
2407 * Embedded single-quotes are implemented both in the SQL standard
2408 * style of two adjacent single quotes "''" and in the Postgres/Java style
2409 * of escaped-quote "\'".
2410 * Other embedded escaped characters are matched explicitly and the leading
2411 * backslash is dropped from the string. - thomas 1997-09-24
2412 * Note that xcstart must appear before operator, as explained above!
2413 * Also whitespace (comment) must appear before operator.
2414 */
2415 #line 2416 "pgc.c"
2416
2417 #define INITIAL 0
2418 #define C 1
2419 #define SQL 2
2420 #define incl 3
2421 #define def 4
2422 #define def_ident 5
2423 #define undef 6
2424 #define xb 7
2425 #define xcc 8
2426 #define xcsql 9
2427 #define xd 10
2428 #define xdc 11
2429 #define xh 12
2430 #define xe 13
2431 #define xn 14
2432 #define xq 15
2433 #define xqc 16
2434 #define xdolq 17
2435 #define xcond 18
2436 #define xskip 19
2437 #define xui 20
2438 #define xus 21
2439
2440 #ifndef YY_NO_UNISTD_H
2441 /* Special case for "unistd.h", since it is non-ANSI. We include it way
2442 * down here because we want the user's section 1 to have been scanned first.
2443 * The user has a chance to override it with an option.
2444 */
2445 #include <unistd.h>
2446 #endif
2447
2448 #ifndef YY_EXTRA_TYPE
2449 #define YY_EXTRA_TYPE void *
2450 #endif
2451
2452 static int yy_init_globals ( void );
2453
2454 /* Accessor methods to globals.
2455 These are made visible to non-reentrant scanners for convenience. */
2456
2457 int yylex_destroy ( void );
2458
2459 int yyget_debug ( void );
2460
2461 void yyset_debug ( int debug_flag );
2462
2463 YY_EXTRA_TYPE yyget_extra ( void );
2464
2465 void yyset_extra ( YY_EXTRA_TYPE user_defined );
2466
2467 FILE *yyget_in ( void );
2468
2469 void yyset_in ( FILE * _in_str );
2470
2471 FILE *yyget_out ( void );
2472
2473 void yyset_out ( FILE * _out_str );
2474
2475 int yyget_leng ( void );
2476
2477 char *yyget_text ( void );
2478
2479 int yyget_lineno ( void );
2480
2481 void yyset_lineno ( int _line_number );
2482
2483 /* Macros after this point can all be overridden by user definitions in
2484 * section 1.
2485 */
2486
2487 #ifndef YY_SKIP_YYWRAP
2488 #ifdef __cplusplus
2489 extern "C" int yywrap ( void );
2490 #else
2491 extern int yywrap ( void );
2492 #endif
2493 #endif
2494
2495 #ifndef YY_NO_UNPUT
2496
2497 static void yyunput ( int c, char *buf_ptr );
2498
2499 #endif
2500
2501 #ifndef yytext_ptr
2502 static void yy_flex_strncpy ( char *, const char *, int );
2503 #endif
2504
2505 #ifdef YY_NEED_STRLEN
2506 static int yy_flex_strlen ( const char * );
2507 #endif
2508
2509 #ifndef YY_NO_INPUT
2510 #ifdef __cplusplus
2511 static int yyinput ( void );
2512 #else
2513 static int input ( void );
2514 #endif
2515
2516 #endif
2517
2518 /* Amount of stuff to slurp up with each read. */
2519 #ifndef YY_READ_BUF_SIZE
2520 #ifdef __ia64__
2521 /* On IA-64, the buffer size is 16k, not 8k */
2522 #define YY_READ_BUF_SIZE 16384
2523 #else
2524 #define YY_READ_BUF_SIZE 8192
2525 #endif /* __ia64__ */
2526 #endif
2527
2528 /* Copy whatever the last rule matched to the standard output. */
2529 #ifndef ECHO
2530 /* This used to be an fputs(), but since the string might contain NUL's,
2531 * we now use fwrite().
2532 */
2533 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
2534 #endif
2535
2536 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
2537 * is returned in "result".
2538 */
2539 #ifndef YY_INPUT
2540 #define YY_INPUT(buf,result,max_size) \
2541 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
2542 { \
2543 int c = '*'; \
2544 int n; \
2545 for ( n = 0; n < max_size && \
2546 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
2547 buf[n] = (char) c; \
2548 if ( c == '\n' ) \
2549 buf[n++] = (char) c; \
2550 if ( c == EOF && ferror( yyin ) ) \
2551 YY_FATAL_ERROR( "input in flex scanner failed" ); \
2552 result = n; \
2553 } \
2554 else \
2555 { \
2556 errno=0; \
2557 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
2558 { \
2559 if( errno != EINTR) \
2560 { \
2561 YY_FATAL_ERROR( "input in flex scanner failed" ); \
2562 break; \
2563 } \
2564 errno=0; \
2565 clearerr(yyin); \
2566 } \
2567 }\
2568 \
2569
2570 #endif
2571
2572 /* No semi-colon after return; correct usage is to write "yyterminate();" -
2573 * we don't want an extra ';' after the "return" because that will cause
2574 * some compilers to complain about unreachable statements.
2575 */
2576 #ifndef yyterminate
2577 #define yyterminate() return YY_NULL
2578 #endif
2579
2580 /* Number of entries by which start-condition stack grows. */
2581 #ifndef YY_START_STACK_INCR
2582 #define YY_START_STACK_INCR 25
2583 #endif
2584
2585 /* Report a fatal error. */
2586 #ifndef YY_FATAL_ERROR
2587 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
2588 #endif
2589
2590 /* end tables serialization structures and prototypes */
2591
2592 /* Default declaration of generated scanner - a define so the user can
2593 * easily add parameters.
2594 */
2595 #ifndef YY_DECL
2596 #define YY_DECL_IS_OURS 1
2597
2598 extern int yylex (void);
2599
2600 #define YY_DECL int yylex (void)
2601 #endif /* !YY_DECL */
2602
2603 /* Code executed at the beginning of each rule, after yytext and yyleng
2604 * have been set up.
2605 */
2606 #ifndef YY_USER_ACTION
2607 #define YY_USER_ACTION
2608 #endif
2609
2610 /* Code executed at the end of each rule. */
2611 #ifndef YY_BREAK
2612 #define YY_BREAK /*LINTED*/break;
2613 #endif
2614
2615 #define YY_RULE_SETUP \
2616 YY_USER_ACTION
2617
2618 /** The main scanner function which does all the work.
2619 */
2620 YY_DECL
2621 {
2622 yy_state_type yy_current_state;
2623 char *yy_cp, *yy_bp;
2624 int yy_act;
2625
2626 if ( !(yy_init) )
2627 {
2628 (yy_init) = 1;
2629
2630 #ifdef YY_USER_INIT
2631 YY_USER_INIT;
2632 #endif
2633
2634 if ( ! (yy_start) )
2635 (yy_start) = 1; /* first start state */
2636
2637 if ( ! yyin )
2638 yyin = stdin;
2639
2640 if ( ! yyout )
2641 yyout = stdout;
2642
2643 if ( ! YY_CURRENT_BUFFER ) {
2644 yyensure_buffer_stack ();
2645 YY_CURRENT_BUFFER_LVALUE =
2646 yy_create_buffer( yyin, YY_BUF_SIZE );
2647 }
2648
2649 yy_load_buffer_state( );
2650 }
2651
2652 {
2653 #line 388 "pgc.l"
2654
2655
2656
2657 #line 392 "pgc.l"
2658 /* code to execute during start of each call of yylex() */
2659 token_start = NULL;
2660
2661
2662 #line 2663 "pgc.c"
2663
2664 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
2665 {
2666 yy_cp = (yy_c_buf_p);
2667
2668 /* Support of yytext. */
2669 *yy_cp = (yy_hold_char);
2670
2671 /* yy_bp points to the position in yy_ch_buf of the start of
2672 * the current run.
2673 */
2674 yy_bp = yy_cp;
2675
2676 yy_current_state = (yy_start);
2677 yy_match:
2678 do
2679 {
2680 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
2681 if ( yy_accept[yy_current_state] )
2682 {
2683 (yy_last_accepting_state) = yy_current_state;
2684 (yy_last_accepting_cpos) = yy_cp;
2685 }
2686 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2687 {
2688 yy_current_state = (int) yy_def[yy_current_state];
2689 if ( yy_current_state >= 831 )
2690 yy_c = yy_meta[yy_c];
2691 }
2692 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
2693 ++yy_cp;
2694 }
2695 while ( yy_current_state != 830 );
2696 yy_cp = (yy_last_accepting_cpos);
2697 yy_current_state = (yy_last_accepting_state);
2698
2699 yy_find_action:
2700 yy_act = yy_accept[yy_current_state];
2701
2702 YY_DO_BEFORE_ACTION;
2703
2704 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
2705 {
2706 int yyl;
2707 for ( yyl = 0; yyl < yyleng; ++yyl )
2708 if ( yytext[yyl] == '\n' )
2709
2710 yylineno++;
2711 ;
2712 }
2713
2714 do_action: /* This label is used only to access EOF actions. */
2715
2716 switch ( yy_act )
2717 { /* beginning of action switch */
2718 case 0: /* must back up */
2719 /* undo the effects of YY_DO_BEFORE_ACTION */
2720 *yy_cp = (yy_hold_char);
2721 yy_cp = (yy_last_accepting_cpos);
2722 yy_current_state = (yy_last_accepting_state);
2723 goto yy_find_action;
2724
2725 case 1:
2726 /* rule 1 can match eol */
2727 YY_RULE_SETUP
2728 #line 396 "pgc.l"
2729 { /* ignore */ }
2730 YY_BREAK
2731 case 2:
2732 YY_RULE_SETUP
2733 #line 398 "pgc.l"
2734 {
2735 token_start = yytext;
2736 state_before = YYSTATE;
2737 xcdepth = 0;
2738 BEGIN(xcc);
2739 /* Put back any characters past slash-star; see above */
2740 yyless(2);
2741 fputs("/*", yyout);
2742 }
2743 YY_BREAK
2744 case 3:
2745 YY_RULE_SETUP
2746 #line 407 "pgc.l"
2747 {
2748 token_start = yytext;
2749 state_before = YYSTATE;
2750 xcdepth = 0;
2751 BEGIN(xcsql);
2752 /* Put back any characters past slash-star; see above */
2753 yyless(2);
2754 fputs("/*", yyout);
2755 }
2756 YY_BREAK
2757 case 4:
2758 YY_RULE_SETUP
2759 #line 416 "pgc.l"
2760 { ECHO; }
2761 YY_BREAK
2762 case 5:
2763 YY_RULE_SETUP
2764 #line 417 "pgc.l"
2765 {
2766 xcdepth++;
2767 /* Put back any characters past slash-star; see above */
2768 yyless(2);
2769 fputs("/_*", yyout);
2770 }
2771 YY_BREAK
2772 case 6:
2773 YY_RULE_SETUP
2774 #line 423 "pgc.l"
2775 {
2776 if (xcdepth <= 0)
2777 {
2778 ECHO;
2779 BEGIN(state_before);
2780 token_start = NULL;
2781 }
2782 else
2783 {
2784 xcdepth--;
2785 fputs("*_/", yyout);
2786 }
2787 }
2788 YY_BREAK
2789 case 7:
2790 YY_RULE_SETUP
2791 #line 436 "pgc.l"
2792 {
2793 ECHO;
2794 BEGIN(state_before);
2795 token_start = NULL;
2796 }
2797 YY_BREAK
2798 case 8:
2799 /* rule 8 can match eol */
2800 YY_RULE_SETUP
2801 #line 441 "pgc.l"
2802 { ECHO; }
2803 YY_BREAK
2804 case 9:
2805 YY_RULE_SETUP
2806 #line 442 "pgc.l"
2807 { ECHO; }
2808 YY_BREAK
2809 case 10:
2810 YY_RULE_SETUP
2811 #line 443 "pgc.l"
2812 { ECHO; }
2813 YY_BREAK
2814 case YY_STATE_EOF(xcc):
2815 case YY_STATE_EOF(xcsql):
2816 #line 445 "pgc.l"
2817 { mmfatal(PARSE_ERROR, "unterminated /* comment"); }
2818 YY_BREAK
2819 case 11:
2820 YY_RULE_SETUP
2821 #line 447 "pgc.l"
2822 {
2823 token_start = yytext;
2824 BEGIN(xb);
2825 startlit();
2826 addlitchar('b');
2827 }
2828 YY_BREAK
2829 case 12:
2830 /* rule 12 can match eol */
2831 #line 454 "pgc.l"
2832 case 13:
2833 /* rule 13 can match eol */
2834 YY_RULE_SETUP
2835 #line 454 "pgc.l"
2836 {
2837 yyless(1);
2838 BEGIN(SQL);
2839 if (literalbuf[strspn(literalbuf, "01") + 1] != '\0')
2840 mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string literal");
2841 base_yylval.str = mm_strdup(literalbuf);
2842 return BCONST;
2843 }
2844 YY_BREAK
2845 case 14:
2846 /* rule 14 can match eol */
2847 #line 464 "pgc.l"
2848 case 15:
2849 /* rule 15 can match eol */
2850 YY_RULE_SETUP
2851 #line 464 "pgc.l"
2852 { addlit(yytext, yyleng); }
2853 YY_BREAK
2854 case 16:
2855 /* rule 16 can match eol */
2856 #line 466 "pgc.l"
2857 case 17:
2858 /* rule 17 can match eol */
2859 YY_RULE_SETUP
2860 #line 466 "pgc.l"
2861 { /* ignore */ }
2862 YY_BREAK
2863 case YY_STATE_EOF(xb):
2864 #line 467 "pgc.l"
2865 { mmfatal(PARSE_ERROR, "unterminated bit string literal"); }
2866 YY_BREAK
2867 case 18:
2868 YY_RULE_SETUP
2869 #line 469 "pgc.l"
2870 {
2871 token_start = yytext;
2872 BEGIN(xh);
2873 startlit();
2874 addlitchar('x');
2875 }
2876 YY_BREAK
2877 case 19:
2878 /* rule 19 can match eol */
2879 #line 476 "pgc.l"
2880 case 20:
2881 /* rule 20 can match eol */
2882 YY_RULE_SETUP
2883 #line 476 "pgc.l"
2884 {
2885 yyless(1);
2886 BEGIN(SQL);
2887 base_yylval.str = mm_strdup(literalbuf);
2888 return XCONST;
2889 }
2890 YY_BREAK
2891 case YY_STATE_EOF(xh):
2892 #line 483 "pgc.l"
2893 { mmfatal(PARSE_ERROR, "unterminated hexadecimal string literal"); }
2894 YY_BREAK
2895 case 21:
2896 YY_RULE_SETUP
2897 #line 484 "pgc.l"
2898 {
2899 /* National character.
2900 * Transfer it as-is to the backend.
2901 */
2902 token_start = yytext;
2903 state_before = YYSTATE;
2904 BEGIN(xn);
2905 startlit();
2906 }
2907 YY_BREAK
2908 case 22:
2909 YY_RULE_SETUP
2910 #line 493 "pgc.l"
2911 {
2912 token_start = yytext;
2913 state_before = YYSTATE;
2914 BEGIN(xqc);
2915 startlit();
2916 }
2917 YY_BREAK
2918 case 23:
2919 YY_RULE_SETUP
2920 #line 499 "pgc.l"
2921 {
2922 token_start = yytext;
2923 state_before = YYSTATE;
2924 BEGIN(xq);
2925 startlit();
2926 }
2927 YY_BREAK
2928 case 24:
2929 YY_RULE_SETUP
2930 #line 505 "pgc.l"
2931 {
2932 token_start = yytext;
2933 state_before = YYSTATE;
2934 BEGIN(xe);
2935 startlit();
2936 }
2937 YY_BREAK
2938 case 25:
2939 YY_RULE_SETUP
2940 #line 511 "pgc.l"
2941 {
2942 token_start = yytext;
2943 state_before = YYSTATE;
2944 BEGIN(xus);
2945 startlit();
2946 addlit(yytext, yyleng);
2947 }
2948 YY_BREAK
2949 case 26:
2950 /* rule 26 can match eol */
2951 #line 519 "pgc.l"
2952 case 27:
2953 /* rule 27 can match eol */
2954 YY_RULE_SETUP
2955 #line 519 "pgc.l"
2956 {
2957 yyless(1);
2958 BEGIN(state_before);
2959 base_yylval.str = mm_strdup(literalbuf);
2960 return SCONST;
2961 }
2962 YY_BREAK
2963 case 28:
2964 /* rule 28 can match eol */
2965 #line 526 "pgc.l"
2966 case 29:
2967 /* rule 29 can match eol */
2968 YY_RULE_SETUP
2969 #line 526 "pgc.l"
2970 {
2971 yyless(1);
2972 BEGIN(state_before);
2973 base_yylval.str = mm_strdup(literalbuf);
2974 return ECONST;
2975 }
2976 YY_BREAK
2977 case 30:
2978 /* rule 30 can match eol */
2979 #line 533 "pgc.l"
2980 case 31:
2981 /* rule 31 can match eol */
2982 YY_RULE_SETUP
2983 #line 533 "pgc.l"
2984 {
2985 yyless(1);
2986 BEGIN(state_before);
2987 base_yylval.str = mm_strdup(literalbuf);
2988 return NCONST;
2989 }
2990 YY_BREAK
2991 case 32:
2992 /* rule 32 can match eol */
2993 YY_RULE_SETUP
2994 #line 539 "pgc.l"
2995 {
2996 addlit(yytext, yyleng);
2997 BEGIN(state_before);
2998 base_yylval.str = mm_strdup(literalbuf);
2999 return UCONST;
3000 }
3001 YY_BREAK
3002 case 33:
3003 YY_RULE_SETUP
3004 #line 545 "pgc.l"
3005 { addlitchar('\''); }
3006 YY_BREAK
3007 case 34:
3008 YY_RULE_SETUP
3009 #line 546 "pgc.l"
3010 {
3011 addlitchar('\\');
3012 addlitchar('\'');
3013 }
3014 YY_BREAK
3015 case 35:
3016 /* rule 35 can match eol */
3017 YY_RULE_SETUP
3018 #line 550 "pgc.l"
3019 { addlit(yytext, yyleng); }
3020 YY_BREAK
3021 case 36:
3022 /* rule 36 can match eol */
3023 YY_RULE_SETUP
3024 #line 551 "pgc.l"
3025 { addlit(yytext, yyleng); }
3026 YY_BREAK
3027 case 37:
3028 YY_RULE_SETUP
3029 #line 552 "pgc.l"
3030 { addlit(yytext, yyleng); }
3031 YY_BREAK
3032 case 38:
3033 /* rule 38 can match eol */
3034 YY_RULE_SETUP
3035 #line 553 "pgc.l"
3036 { addlit(yytext, yyleng); }
3037 YY_BREAK
3038 case 39:
3039 YY_RULE_SETUP
3040 #line 554 "pgc.l"
3041 { addlit(yytext, yyleng); }
3042 YY_BREAK
3043 case 40:
3044 YY_RULE_SETUP
3045 #line 555 "pgc.l"
3046 { addlit(yytext, yyleng); }
3047 YY_BREAK
3048 case 41:
3049 /* rule 41 can match eol */
3050 YY_RULE_SETUP
3051 #line 556 "pgc.l"
3052 { /* ignore */ }
3053 YY_BREAK
3054 case 42:
3055 YY_RULE_SETUP
3056 #line 557 "pgc.l"
3057 {
3058 /* This is only needed for \ just before EOF */
3059 addlitchar(yytext[0]);
3060 }
3061 YY_BREAK
3062 case YY_STATE_EOF(xq):
3063 case YY_STATE_EOF(xqc):
3064 case YY_STATE_EOF(xe):
3065 case YY_STATE_EOF(xn):
3066 case YY_STATE_EOF(xus):
3067 #line 561 "pgc.l"
3068 { mmfatal(PARSE_ERROR, "unterminated quoted string"); }
3069 YY_BREAK
3070 case 43:
3071 YY_RULE_SETUP
3072 #line 562 "pgc.l"
3073 {
3074 /* throw back all but the initial "$" */
3075 yyless(1);
3076 /* and treat it as {other} */
3077 return yytext[0];
3078 }
3079 YY_BREAK
3080 case 44:
3081 YY_RULE_SETUP
3082 #line 568 "pgc.l"
3083 {
3084 token_start = yytext;
3085 if (dolqstart)
3086 free(dolqstart);
3087 dolqstart = mm_strdup(yytext);
3088 BEGIN(xdolq);
3089 startlit();
3090 addlit(yytext, yyleng);
3091 }
3092 YY_BREAK
3093 case 45:
3094 YY_RULE_SETUP
3095 #line 577 "pgc.l"
3096 {
3097 if (strcmp(yytext, dolqstart) == 0)
3098 {
3099 addlit(yytext, yyleng);
3100 free(dolqstart);
3101 dolqstart = NULL;
3102 BEGIN(SQL);
3103 base_yylval.str = mm_strdup(literalbuf);
3104 return DOLCONST;
3105 }
3106 else
3107 {
3108 /*
3109 * When we fail to match $...$ to dolqstart, transfer
3110 * the $... part to the output, but put back the final
3111 * $ for rescanning. Consider $delim$...$junk$delim$
3112 */
3113 addlit(yytext, yyleng-1);
3114 yyless(yyleng-1);
3115 }
3116 }
3117 YY_BREAK
3118 case 46:
3119 /* rule 46 can match eol */
3120 YY_RULE_SETUP
3121 #line 598 "pgc.l"
3122 { addlit(yytext, yyleng); }
3123 YY_BREAK
3124 case 47:
3125 YY_RULE_SETUP
3126 #line 599 "pgc.l"
3127 { addlit(yytext, yyleng); }
3128 YY_BREAK
3129 case 48:
3130 YY_RULE_SETUP
3131 #line 600 "pgc.l"
3132 {
3133 /* single quote or dollar sign */
3134 addlitchar(yytext[0]);
3135 }
3136 YY_BREAK
3137 case YY_STATE_EOF(xdolq):
3138 #line 604 "pgc.l"
3139 { base_yyerror("unterminated dollar-quoted string"); }
3140 YY_BREAK
3141 case 49:
3142 YY_RULE_SETUP
3143 #line 605 "pgc.l"
3144 {
3145 state_before = YYSTATE;
3146 BEGIN(xd);
3147 startlit();
3148 }
3149 YY_BREAK
3150 case 50:
3151 YY_RULE_SETUP
3152 #line 610 "pgc.l"
3153 {
3154 state_before = YYSTATE;
3155 BEGIN(xui);
3156 startlit();
3157 addlit(yytext, yyleng);
3158 }
3159 YY_BREAK
3160 case 51:
3161 YY_RULE_SETUP
3162 #line 616 "pgc.l"
3163 {
3164 BEGIN(state_before);
3165 if (literallen == 0)
3166 mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
3167 /* The backend will truncate the identifier here. We do not as it does not change the result. */
3168 base_yylval.str = mm_strdup(literalbuf);
3169 return CSTRING;
3170 }
3171 YY_BREAK
3172 case 52:
3173 YY_RULE_SETUP
3174 #line 624 "pgc.l"
3175 {
3176 BEGIN(state_before);
3177 base_yylval.str = mm_strdup(literalbuf);
3178 return CSTRING;
3179 }
3180 YY_BREAK
3181 case 53:
3182 /* rule 53 can match eol */
3183 YY_RULE_SETUP
3184 #line 629 "pgc.l"
3185 {
3186 BEGIN(state_before);
3187 if (literallen == 2) /* "U&" */
3188 mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
3189 /* The backend will truncate the identifier here. We do not as it does not change the result. */
3190 addlit(yytext, yyleng);
3191 base_yylval.str = mm_strdup(literalbuf);
3192 return UIDENT;
3193 }
3194 YY_BREAK
3195 case 54:
3196 YY_RULE_SETUP
3197 #line 638 "pgc.l"
3198 { addlitchar('"'); }
3199 YY_BREAK
3200 case 55:
3201 /* rule 55 can match eol */
3202 YY_RULE_SETUP
3203 #line 639 "pgc.l"
3204 { addlit(yytext, yyleng); }
3205 YY_BREAK
3206 case YY_STATE_EOF(xd):
3207 case YY_STATE_EOF(xdc):
3208 case YY_STATE_EOF(xui):
3209 #line 640 "pgc.l"
3210 { mmfatal(PARSE_ERROR, "unterminated quoted identifier"); }
3211 YY_BREAK
3212 case 56:
3213 YY_RULE_SETUP
3214 #line 641 "pgc.l"
3215 {
3216 state_before = YYSTATE;
3217 BEGIN(xdc);
3218 startlit();
3219 }
3220 YY_BREAK
3221 case 57:
3222 /* rule 57 can match eol */
3223 YY_RULE_SETUP
3224 #line 646 "pgc.l"
3225 { addlit(yytext, yyleng); }
3226 YY_BREAK
3227 case 58:
3228 YY_RULE_SETUP
3229 #line 647 "pgc.l"
3230 { return TYPECAST; }
3231 YY_BREAK
3232 case 59:
3233 YY_RULE_SETUP
3234 #line 648 "pgc.l"
3235 { return DOT_DOT; }
3236 YY_BREAK
3237 case 60:
3238 YY_RULE_SETUP
3239 #line 649 "pgc.l"
3240 { return COLON_EQUALS; }
3241 YY_BREAK
3242 case 61:
3243 YY_RULE_SETUP
3244 #line 650 "pgc.l"
3245 { return EQUALS_GREATER; }
3246 YY_BREAK
3247 case 62:
3248 YY_RULE_SETUP
3249 #line 651 "pgc.l"
3250 { return LESS_EQUALS; }
3251 YY_BREAK
3252 case 63:
3253 YY_RULE_SETUP
3254 #line 652 "pgc.l"
3255 { return GREATER_EQUALS; }
3256 YY_BREAK
3257 case 64:
3258 YY_RULE_SETUP
3259 #line 653 "pgc.l"
3260 { return NOT_EQUALS; }
3261 YY_BREAK
3262 case 65:
3263 YY_RULE_SETUP
3264 #line 654 "pgc.l"
3265 { return NOT_EQUALS; }
3266 YY_BREAK
3267 case 66:
3268 YY_RULE_SETUP
3269 #line 655 "pgc.l"
3270 {
3271 /* are we simulating Informix? */
3272 if (INFORMIX_MODE)
3273 {
3274 unput(':');
3275 }
3276 else
3277 return yytext[0];
3278 }
3279 YY_BREAK
3280 case 67:
3281 YY_RULE_SETUP
3282 #line 664 "pgc.l"
3283 { /*
3284 * We may find a ';' inside a structure
3285 * definition in a TYPE or VAR statement.
3286 * This is not an EOL marker.
3287 */
3288 if (yytext[0] == ';' && struct_level == 0)
3289 BEGIN(C);
3290 return yytext[0];
3291 }
3292 YY_BREAK
3293 case 68:
3294 YY_RULE_SETUP
3295 #line 673 "pgc.l"
3296 {
3297 /*
3298 * Check for embedded slash-star or dash-dash; those
3299 * are comment starts, so operator must stop there.
3300 * Note that slash-star or dash-dash at the first
3301 * character will match a prior rule, not this one.
3302 */
3303 int nchars = yyleng;
3304 char *slashstar = strstr(yytext, "/*");
3305 char *dashdash = strstr(yytext, "--");
3306
3307 if (slashstar && dashdash)
3308 {
3309 /* if both appear, take the first one */
3310 if (slashstar > dashdash)
3311 slashstar = dashdash;
3312 }
3313 else if (!slashstar)
3314 slashstar = dashdash;
3315 if (slashstar)
3316 nchars = slashstar - yytext;
3317
3318 /*
3319 * For SQL compatibility, '+' and '-' cannot be the
3320 * last char of a multi-char operator unless the operator
3321 * contains chars that are not in SQL operators.
3322 * The idea is to lex '=-' as two operators, but not
3323 * to forbid operator names like '?-' that could not be
3324 * sequences of SQL operators.
3325 */
3326 if (nchars > 1 &&
3327 (yytext[nchars - 1] == '+' ||
3328 yytext[nchars - 1] == '-'))
3329 {
3330 int ic;
3331
3332 for (ic = nchars - 2; ic >= 0; ic--)
3333 {
3334 char c = yytext[ic];
3335 if (c == '~' || c == '!' || c == '@' ||
3336 c == '#' || c == '^' || c == '&' ||
3337 c == '|' || c == '`' || c == '?' ||
3338 c == '%')
3339 break;
3340 }
3341 if (ic < 0)
3342 {
3343 /*
3344 * didn't find a qualifying character, so remove
3345 * all trailing [+-]
3346 */
3347 do {
3348 nchars--;
3349 } while (nchars > 1 &&
3350 (yytext[nchars - 1] == '+' ||
3351 yytext[nchars - 1] == '-'));
3352 }
3353 }
3354
3355 if (nchars < yyleng)
3356 {
3357 /* Strip the unwanted chars from the token */
3358 yyless(nchars);
3359 /*
3360 * If what we have left is only one char, and it's
3361 * one of the characters matching "self", then
3362 * return it as a character token the same way
3363 * that the "self" rule would have.
3364 */
3365 if (nchars == 1 &&
3366 strchr(",()[].;:+-*/%^<>=", yytext[0]))
3367 return yytext[0];
3368 /*
3369 * Likewise, if what we have left is two chars, and
3370 * those match the tokens ">=", "<=", "=>", "<>" or
3371 * "!=", then we must return the appropriate token
3372 * rather than the generic Op.
3373 */
3374 if (nchars == 2)
3375 {
3376 if (yytext[0] == '=' && yytext[1] == '>')
3377 return EQUALS_GREATER;
3378 if (yytext[0] == '>' && yytext[1] == '=')
3379 return GREATER_EQUALS;
3380 if (yytext[0] == '<' && yytext[1] == '=')
3381 return LESS_EQUALS;
3382 if (yytext[0] == '<' && yytext[1] == '>')
3383 return NOT_EQUALS;
3384 if (yytext[0] == '!' && yytext[1] == '=')
3385 return NOT_EQUALS;
3386 }
3387 }
3388
3389 base_yylval.str = mm_strdup(yytext);
3390 return Op;
3391 }
3392 YY_BREAK
3393 case 69:
3394 YY_RULE_SETUP
3395 #line 769 "pgc.l"
3396 {
3397 base_yylval.ival = atol(yytext+1);
3398 return PARAM;
3399 }
3400 YY_BREAK
3401 case 70:
3402 YY_RULE_SETUP
3403 #line 773 "pgc.l"
3404 {
3405 int val;
3406 char* endptr;
3407
3408 errno = 0;
3409 val = strtoint(yytext, &endptr, 10);
3410 if (*endptr != '\0' || errno == ERANGE)
3411 {
3412 errno = 0;
3413 base_yylval.str = mm_strdup(yytext);
3414 return FCONST;
3415 }
3416 base_yylval.ival = val;
3417 return ICONST;
3418 }
3419 YY_BREAK
3420 case 71:
3421 YY_RULE_SETUP
3422 #line 788 "pgc.l"
3423 {
3424 base_yylval.str = mm_strdup(yytext);
3425 return IP;
3426 }
3427 YY_BREAK
3428 case 72:
3429 YY_RULE_SETUP
3430 #line 792 "pgc.l"
3431 {
3432 base_yylval.str = mm_strdup(yytext);
3433 return FCONST;
3434 }
3435 YY_BREAK
3436 case 73:
3437 YY_RULE_SETUP
3438 #line 796 "pgc.l"
3439 {
3440 base_yylval.str = mm_strdup(yytext);
3441 return FCONST;
3442 }
3443 YY_BREAK
3444 case 74:
3445 YY_RULE_SETUP
3446 #line 800 "pgc.l"
3447 {
3448 yyless(yyleng-1);
3449 base_yylval.str = mm_strdup(yytext);
3450 return FCONST;
3451 }
3452 YY_BREAK
3453 case 75:
3454 YY_RULE_SETUP
3455 #line 805 "pgc.l"
3456 {
3457 yyless(yyleng-2);
3458 base_yylval.str = mm_strdup(yytext);
3459 return FCONST;
3460 }
3461 YY_BREAK
3462 case 76:
3463 /* rule 76 can match eol */
3464 YY_RULE_SETUP
3465 #line 810 "pgc.l"
3466 {
3467 base_yylval.str = mm_strdup(yytext+1);
3468 return CVARIABLE;
3469 }
3470 YY_BREAK
3471 case 77:
3472 YY_RULE_SETUP
3473 #line 814 "pgc.l"
3474 {
3475 const ScanKeyword *keyword;
3476
3477 if (!isdefine())
3478 {
3479 /* Is it an SQL/ECPG keyword? */
3480 keyword = ScanECPGKeywordLookup(yytext);
3481 if (keyword != NULL)
3482 return keyword->value;
3483
3484 /* Is it a C keyword? */
3485 keyword = ScanCKeywordLookup(yytext);
3486 if (keyword != NULL)
3487 return keyword->value;
3488
3489 /*
3490 * None of the above. Return it as an identifier.
3491 *
3492 * The backend will attempt to truncate and case-fold
3493 * the identifier, but I see no good reason for ecpg
3494 * to do so; that's just another way that ecpg could get
3495 * out of step with the backend.
3496 */
3497 base_yylval.str = mm_strdup(yytext);
3498 return IDENT;
3499 }
3500 }
3501 YY_BREAK
3502 case 78:
3503 YY_RULE_SETUP
3504 #line 841 "pgc.l"
3505 { return yytext[0]; }
3506 YY_BREAK
3507 case 79:
3508 /* rule 79 can match eol */
3509 YY_RULE_SETUP
3510 #line 842 "pgc.l"
3511 { BEGIN(SQL); return SQL_START; }
3512 YY_BREAK
3513 case 80:
3514 YY_RULE_SETUP
3515 #line 843 "pgc.l"
3516 {
3517 /* are we simulating Informix? */
3518 if (INFORMIX_MODE)
3519 {
3520 BEGIN(SQL);
3521 return SQL_START;
3522 }
3523 else
3524 return S_ANYTHING;
3525 }
3526 YY_BREAK
3527 case 81:
3528 /* rule 81 can match eol */
3529 YY_RULE_SETUP
3530 #line 853 "pgc.l"
3531 { ECHO; }
3532 YY_BREAK
3533 case 82:
3534 YY_RULE_SETUP
3535 #line 854 "pgc.l"
3536 {
3537 char* endptr;
3538
3539 errno = 0;
3540 base_yylval.ival = strtoul((char *)yytext,&endptr,16);
3541 if (*endptr != '\0' || errno == ERANGE)
3542 {
3543 errno = 0;
3544 base_yylval.str = mm_strdup(yytext);
3545 return SCONST;
3546 }
3547 return ICONST;
3548 }
3549 YY_BREAK
3550 case 83:
3551 /* rule 83 can match eol */
3552 YY_RULE_SETUP
3553 #line 867 "pgc.l"
3554 {
3555 if (system_includes)
3556 {
3557 include_next = false;
3558 BEGIN(incl);
3559 }
3560 else
3561 {
3562 base_yylval.str = mm_strdup(yytext);
3563 return CPP_LINE;
3564 }
3565 }
3566 YY_BREAK
3567 case 84:
3568 /* rule 84 can match eol */
3569 YY_RULE_SETUP
3570 #line 879 "pgc.l"
3571 {
3572 if (system_includes)
3573 {
3574 include_next = true;
3575 BEGIN(incl);
3576 }
3577 else
3578 {
3579 base_yylval.str = mm_strdup(yytext);
3580 return CPP_LINE;
3581 }
3582 }
3583 YY_BREAK
3584 case 85:
3585 /* rule 85 can match eol */
3586 YY_RULE_SETUP
3587 #line 891 "pgc.l"
3588 {
3589 base_yylval.str = mm_strdup(yytext);
3590 return CPP_LINE;
3591 }
3592 YY_BREAK
3593 case 86:
3594 YY_RULE_SETUP
3595 #line 895 "pgc.l"
3596 {
3597 const ScanKeyword *keyword;
3598
3599 /*
3600 * Try to detect a function name:
3601 * look for identifiers at the global scope
3602 * keep the last identifier before the first '(' and '{' */
3603 if (braces_open == 0 && parenths_open == 0)
3604 {
3605 if (current_function)
3606 free(current_function);
3607 current_function = mm_strdup(yytext);
3608 }
3609 /* Informix uses SQL defines only in SQL space */
3610 /* however, some defines have to be taken care of for compatibility */
3611 if ((!INFORMIX_MODE || !isinformixdefine()) && !isdefine())
3612 {
3613 keyword = ScanCKeywordLookup(yytext);
3614 if (keyword != NULL)
3615 return keyword->value;
3616 else
3617 {
3618 base_yylval.str = mm_strdup(yytext);
3619 return IDENT;
3620 }
3621 }
3622 }
3623 YY_BREAK
3624 case 87:
3625 YY_RULE_SETUP
3626 #line 922 "pgc.l"
3627 { mmerror(PARSE_ERROR, ET_ERROR, "nested /* ... */ comments"); }
3628 YY_BREAK
3629 case 88:
3630 YY_RULE_SETUP
3631 #line 923 "pgc.l"
3632 { return ':'; }
3633 YY_BREAK
3634 case 89:
3635 YY_RULE_SETUP
3636 #line 924 "pgc.l"
3637 { return ';'; }
3638 YY_BREAK
3639 case 90:
3640 YY_RULE_SETUP
3641 #line 925 "pgc.l"
3642 { return ','; }
3643 YY_BREAK
3644 case 91:
3645 YY_RULE_SETUP
3646 #line 926 "pgc.l"
3647 { return '*'; }
3648 YY_BREAK
3649 case 92:
3650 YY_RULE_SETUP
3651 #line 927 "pgc.l"
3652 { return '%'; }
3653 YY_BREAK
3654 case 93:
3655 YY_RULE_SETUP
3656 #line 928 "pgc.l"
3657 { return '/'; }
3658 YY_BREAK
3659 case 94:
3660 YY_RULE_SETUP
3661 #line 929 "pgc.l"
3662 { return '+'; }
3663 YY_BREAK
3664 case 95:
3665 YY_RULE_SETUP
3666 #line 930 "pgc.l"
3667 { return '-'; }
3668 YY_BREAK
3669 case 96:
3670 YY_RULE_SETUP
3671 #line 931 "pgc.l"
3672 { parenths_open++; return '('; }
3673 YY_BREAK
3674 case 97:
3675 YY_RULE_SETUP
3676 #line 932 "pgc.l"
3677 { parenths_open--; return ')'; }
3678 YY_BREAK
3679 case 98:
3680 /* rule 98 can match eol */
3681 YY_RULE_SETUP
3682 #line 933 "pgc.l"
3683 { ECHO; }
3684 YY_BREAK
3685 case 99:
3686 YY_RULE_SETUP
3687 #line 934 "pgc.l"
3688 { return '{'; }
3689 YY_BREAK
3690 case 100:
3691 YY_RULE_SETUP
3692 #line 935 "pgc.l"
3693 { return '}'; }
3694 YY_BREAK
3695 case 101:
3696 YY_RULE_SETUP
3697 #line 936 "pgc.l"
3698 { return '['; }
3699 YY_BREAK
3700 case 102:
3701 YY_RULE_SETUP
3702 #line 937 "pgc.l"
3703 { return ']'; }
3704 YY_BREAK
3705 case 103:
3706 YY_RULE_SETUP
3707 #line 938 "pgc.l"
3708 { return '='; }
3709 YY_BREAK
3710 case 104:
3711 YY_RULE_SETUP
3712 #line 939 "pgc.l"
3713 { return S_MEMBER; }
3714 YY_BREAK
3715 case 105:
3716 YY_RULE_SETUP
3717 #line 940 "pgc.l"
3718 { return S_RSHIFT; }
3719 YY_BREAK
3720 case 106:
3721 YY_RULE_SETUP
3722 #line 941 "pgc.l"
3723 { return S_LSHIFT; }
3724 YY_BREAK
3725 case 107:
3726 YY_RULE_SETUP
3727 #line 942 "pgc.l"
3728 { return S_OR; }
3729 YY_BREAK
3730 case 108:
3731 YY_RULE_SETUP
3732 #line 943 "pgc.l"
3733 { return S_AND; }
3734 YY_BREAK
3735 case 109:
3736 YY_RULE_SETUP
3737 #line 944 "pgc.l"
3738 { return S_INC; }
3739 YY_BREAK
3740 case 110:
3741 YY_RULE_SETUP
3742 #line 945 "pgc.l"
3743 { return S_DEC; }
3744 YY_BREAK
3745 case 111:
3746 YY_RULE_SETUP
3747 #line 946 "pgc.l"
3748 { return S_EQUAL; }
3749 YY_BREAK
3750 case 112:
3751 YY_RULE_SETUP
3752 #line 947 "pgc.l"
3753 { return S_NEQUAL; }
3754 YY_BREAK
3755 case 113:
3756 YY_RULE_SETUP
3757 #line 948 "pgc.l"
3758 { return S_ADD; }
3759 YY_BREAK
3760 case 114:
3761 YY_RULE_SETUP
3762 #line 949 "pgc.l"
3763 { return S_SUB; }
3764 YY_BREAK
3765 case 115:
3766 YY_RULE_SETUP
3767 #line 950 "pgc.l"
3768 { return S_MUL; }
3769 YY_BREAK
3770 case 116:
3771 YY_RULE_SETUP
3772 #line 951 "pgc.l"
3773 { return S_DIV; }
3774 YY_BREAK
3775 case 117:
3776 YY_RULE_SETUP
3777 #line 952 "pgc.l"
3778 { return S_MOD; }
3779 YY_BREAK
3780 case 118:
3781 YY_RULE_SETUP
3782 #line 953 "pgc.l"
3783 { return S_MEMPOINT; }
3784 YY_BREAK
3785 case 119:
3786 YY_RULE_SETUP
3787 #line 954 "pgc.l"
3788 { return S_DOTPOINT; }
3789 YY_BREAK
3790 case 120:
3791 YY_RULE_SETUP
3792 #line 955 "pgc.l"
3793 { return S_ANYTHING; }
3794 YY_BREAK
3795 case 121:
3796 /* rule 121 can match eol */
3797 YY_RULE_SETUP
3798 #line 956 "pgc.l"
3799 { BEGIN(def_ident); }
3800 YY_BREAK
3801 case 122:
3802 /* rule 122 can match eol */
3803 YY_RULE_SETUP
3804 #line 957 "pgc.l"
3805 {
3806 /* are we simulating Informix? */
3807 if (INFORMIX_MODE)
3808 {
3809 BEGIN(def_ident);
3810 }
3811 else
3812 {
3813 yyless(1);
3814 return S_ANYTHING;
3815 }
3816 }
3817 YY_BREAK
3818 case 123:
3819 /* rule 123 can match eol */
3820 YY_RULE_SETUP
3821 #line 969 "pgc.l"
3822 { BEGIN(undef); }
3823 YY_BREAK
3824 case 124:
3825 /* rule 124 can match eol */
3826 YY_RULE_SETUP
3827 #line 970 "pgc.l"
3828 {
3829 /* are we simulating Informix? */
3830 if (INFORMIX_MODE)
3831 {
3832 BEGIN(undef);
3833 }
3834 else
3835 {
3836 yyless(1);
3837 return S_ANYTHING;
3838 }
3839 }
3840 YY_BREAK
3841 case 125:
3842 /* rule 125 can match eol */
3843 YY_RULE_SETUP
3844 #line 982 "pgc.l"
3845 {
3846 struct _defines *ptr, *ptr2 = NULL;
3847 int i;
3848
3849 /*
3850 * Skip the ";" and trailing whitespace. Note that yytext
3851 * contains at least one non-space character plus the ";"
3852 */
3853 for (i = strlen(yytext)-2;
3854 i > 0 && ecpg_isspace(yytext[i]);
3855 i-- )
3856 ;
3857 yytext[i+1] = '\0';
3858
3859
3860 for (ptr = defines; ptr != NULL; ptr2 = ptr, ptr = ptr->next)
3861 {
3862 if (strcmp(yytext, ptr->old) == 0)
3863 {
3864 if (ptr2 == NULL)
3865 defines = ptr->next;
3866 else
3867 ptr2->next = ptr->next;
3868 free(ptr->new);
3869 free(ptr->old);
3870 free(ptr);
3871 break;
3872 }
3873 }
3874
3875 BEGIN(C);
3876 }
3877 YY_BREAK
3878 case 126:
3879 /* rule 126 can match eol */
3880 YY_RULE_SETUP
3881 #line 1014 "pgc.l"
3882 {
3883 mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL UNDEF command");
3884 yyterminate();
3885 }
3886 YY_BREAK
3887 case 127:
3888 /* rule 127 can match eol */
3889 YY_RULE_SETUP
3890 #line 1018 "pgc.l"
3891 { BEGIN(incl); }
3892 YY_BREAK
3893 case 128:
3894 /* rule 128 can match eol */
3895 YY_RULE_SETUP
3896 #line 1019 "pgc.l"
3897 {
3898 /* are we simulating Informix? */
3899 if (INFORMIX_MODE)
3900 {
3901 BEGIN(incl);
3902 }
3903 else
3904 {
3905 yyless(1);
3906 return S_ANYTHING;
3907 }
3908 }
3909 YY_BREAK
3910 case 129:
3911 /* rule 129 can match eol */
3912 YY_RULE_SETUP
3913 #line 1031 "pgc.l"
3914 { ifcond = true; BEGIN(xcond); }
3915 YY_BREAK
3916 case 130:
3917 /* rule 130 can match eol */
3918 YY_RULE_SETUP
3919 #line 1032 "pgc.l"
3920 {
3921 /* are we simulating Informix? */
3922 if (INFORMIX_MODE)
3923 {
3924 ifcond = true;
3925 BEGIN(xcond);
3926 }
3927 else
3928 {
3929 yyless(1);
3930 return S_ANYTHING;
3931 }
3932 }
3933 YY_BREAK
3934 case 131:
3935 /* rule 131 can match eol */
3936 YY_RULE_SETUP
3937 #line 1045 "pgc.l"
3938 { ifcond = false; BEGIN(xcond); }
3939 YY_BREAK
3940 case 132:
3941 /* rule 132 can match eol */
3942 YY_RULE_SETUP
3943 #line 1046 "pgc.l"
3944 {
3945 /* are we simulating Informix? */
3946 if (INFORMIX_MODE)
3947 {
3948 ifcond = false;
3949 BEGIN(xcond);
3950 }
3951 else
3952 {
3953 yyless(1);
3954 return S_ANYTHING;
3955 }
3956 }
3957 YY_BREAK
3958 case 133:
3959 /* rule 133 can match eol */
3960 YY_RULE_SETUP
3961 #line 1059 "pgc.l"
3962 { /* pop stack */
3963 if ( preproc_tos == 0 ) {
3964 mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
3965 }
3966 else if ( stacked_if_value[preproc_tos].else_branch )
3967 mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
3968 else
3969 preproc_tos--;
3970
3971 ifcond = true; BEGIN(xcond);
3972 }
3973 YY_BREAK
3974 case 134:
3975 /* rule 134 can match eol */
3976 YY_RULE_SETUP
3977 #line 1070 "pgc.l"
3978 {
3979 /* are we simulating Informix? */
3980 if (INFORMIX_MODE)
3981 {
3982 if (preproc_tos == 0)
3983 mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
3984 else if (stacked_if_value[preproc_tos].else_branch)
3985 mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
3986 else
3987 preproc_tos--;
3988
3989 ifcond = true;
3990 BEGIN(xcond);
3991 }
3992 else
3993 {
3994 yyless(1);
3995 return S_ANYTHING;
3996 }
3997 }
3998 YY_BREAK
3999 case 135:
4000 /* rule 135 can match eol */
4001 YY_RULE_SETUP
4002 #line 1091 "pgc.l"
4003 { /* only exec sql endif pops the stack, so take care of duplicated 'else' */
4004 if (stacked_if_value[preproc_tos].else_branch)
4005 mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
4006 else
4007 {
4008 stacked_if_value[preproc_tos].else_branch = true;
4009 stacked_if_value[preproc_tos].condition =
4010 (stacked_if_value[preproc_tos-1].condition &&
4011 !stacked_if_value[preproc_tos].condition);
4012
4013 if (stacked_if_value[preproc_tos].condition)
4014 BEGIN(C);
4015 else
4016 BEGIN(xskip);
4017 }
4018 }
4019 YY_BREAK
4020 case 136:
4021 /* rule 136 can match eol */
4022 YY_RULE_SETUP
4023 #line 1107 "pgc.l"
4024 {
4025 /* are we simulating Informix? */
4026 if (INFORMIX_MODE)
4027 {
4028 if (stacked_if_value[preproc_tos].else_branch)
4029 mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
4030 else
4031 {
4032 stacked_if_value[preproc_tos].else_branch = true;
4033 stacked_if_value[preproc_tos].condition =
4034 (stacked_if_value[preproc_tos-1].condition &&
4035 !stacked_if_value[preproc_tos].condition);
4036
4037 if (stacked_if_value[preproc_tos].condition)
4038 BEGIN(C);
4039 else
4040 BEGIN(xskip);
4041 }
4042 }
4043 else
4044 {
4045 yyless(1);
4046 return S_ANYTHING;
4047 }
4048 }
4049 YY_BREAK
4050 case 137:
4051 /* rule 137 can match eol */
4052 YY_RULE_SETUP
4053 #line 1132 "pgc.l"
4054 {
4055 if (preproc_tos == 0)
4056 mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
4057 else
4058 preproc_tos--;
4059
4060 if (stacked_if_value[preproc_tos].condition)
4061 BEGIN(C);
4062 else
4063 BEGIN(xskip);
4064 }
4065 YY_BREAK
4066 case 138:
4067 /* rule 138 can match eol */
4068 YY_RULE_SETUP
4069 #line 1143 "pgc.l"
4070 {
4071 /* are we simulating Informix? */
4072 if (INFORMIX_MODE)
4073 {
4074 if (preproc_tos == 0)
4075 mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
4076 else
4077 preproc_tos--;
4078
4079 if (stacked_if_value[preproc_tos].condition)
4080 BEGIN(C);
4081 else
4082 BEGIN(xskip);
4083 }
4084 else
4085 {
4086 yyless(1);
4087 return S_ANYTHING;
4088 }
4089 }
4090 YY_BREAK
4091 case 139:
4092 YY_RULE_SETUP
4093 #line 1164 "pgc.l"
4094 { /* ignore */ }
4095 YY_BREAK
4096 case 140:
4097 /* rule 140 can match eol */
4098 YY_RULE_SETUP
4099 #line 1166 "pgc.l"
4100 {
4101 if (preproc_tos >= MAX_NESTED_IF-1)
4102 mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
4103 else
4104 {
4105 struct _defines *defptr;
4106 unsigned int i;
4107
4108 /*
4109 * Skip the ";" and trailing whitespace. Note that yytext
4110 * contains at least one non-space character plus the ";"
4111 */
4112 for (i = strlen(yytext)-2;
4113 i > 0 && ecpg_isspace(yytext[i]);
4114 i-- )
4115 ;
4116 yytext[i+1] = '\0';
4117
4118 for (defptr = defines;
4119 defptr != NULL && strcmp(yytext, defptr->old) != 0;
4120 defptr = defptr->next);
4121
4122 preproc_tos++;
4123 stacked_if_value[preproc_tos].else_branch = false;
4124 stacked_if_value[preproc_tos].condition =
4125 (defptr ? ifcond : !ifcond) && stacked_if_value[preproc_tos-1].condition;
4126 }
4127
4128 if (stacked_if_value[preproc_tos].condition)
4129 BEGIN(C);
4130 else
4131 BEGIN(xskip);
4132 }
4133 YY_BREAK
4134 case 141:
4135 /* rule 141 can match eol */
4136 YY_RULE_SETUP
4137 #line 1200 "pgc.l"
4138 {
4139 mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL IFDEF command");
4140 yyterminate();
4141 }
4142 YY_BREAK
4143 case 142:
4144 YY_RULE_SETUP
4145 #line 1204 "pgc.l"
4146 {
4147 old = mm_strdup(yytext);
4148 BEGIN(def);
4149 startlit();
4150 }
4151 YY_BREAK
4152 case 143:
4153 /* rule 143 can match eol */
4154 YY_RULE_SETUP
4155 #line 1209 "pgc.l"
4156 {
4157 mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL DEFINE command");
4158 yyterminate();
4159 }
4160 YY_BREAK
4161 case 144:
4162 /* rule 144 can match eol */
4163 YY_RULE_SETUP
4164 #line 1213 "pgc.l"
4165 {
4166 struct _defines *ptr, *this;
4167
4168 for (ptr = defines; ptr != NULL; ptr = ptr->next)
4169 {
4170 if (strcmp(old, ptr->old) == 0)
4171 {
4172 free(ptr->new);
4173 ptr->new = mm_strdup(literalbuf);
4174 }
4175 }
4176 if (ptr == NULL)
4177 {
4178 this = (struct _defines *) mm_alloc(sizeof(struct _defines));
4179
4180 /* initial definition */
4181 this->old = old;
4182 this->new = mm_strdup(literalbuf);
4183 this->next = defines;
4184 this->used = NULL;
4185 defines = this;
4186 }
4187
4188 BEGIN(C);
4189 }
4190 YY_BREAK
4191 case 145:
4192 /* rule 145 can match eol */
4193 YY_RULE_SETUP
4194 #line 1238 "pgc.l"
4195 { addlit(yytext, yyleng); }
4196 YY_BREAK
4197 case 146:
4198 /* rule 146 can match eol */
4199 YY_RULE_SETUP
4200 #line 1239 "pgc.l"
4201 { parse_include(); }
4202 YY_BREAK
4203 case 147:
4204 /* rule 147 can match eol */
4205 YY_RULE_SETUP
4206 #line 1240 "pgc.l"
4207 { parse_include(); }
4208 YY_BREAK
4209 case 148:
4210 /* rule 148 can match eol */
4211 YY_RULE_SETUP
4212 #line 1241 "pgc.l"
4213 { parse_include(); }
4214 YY_BREAK
4215 case 149:
4216 /* rule 149 can match eol */
4217 YY_RULE_SETUP
4218 #line 1242 "pgc.l"
4219 {
4220 mmfatal(PARSE_ERROR, "syntax error in EXEC SQL INCLUDE command");
4221 yyterminate();
4222 }
4223 YY_BREAK
4224 case YY_STATE_EOF(INITIAL):
4225 case YY_STATE_EOF(C):
4226 case YY_STATE_EOF(SQL):
4227 case YY_STATE_EOF(incl):
4228 case YY_STATE_EOF(def):
4229 case YY_STATE_EOF(def_ident):
4230 case YY_STATE_EOF(undef):
4231 case YY_STATE_EOF(xcond):
4232 case YY_STATE_EOF(xskip):
4233 #line 1247 "pgc.l"
4234 {
4235 if (yy_buffer == NULL)
4236 {
4237 if ( preproc_tos > 0 )
4238 {
4239 preproc_tos = 0;
4240 mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
4241 }
4242 yyterminate();
4243 }
4244 else
4245 {
4246 struct _yy_buffer *yb = yy_buffer;
4247 int i;
4248 struct _defines *ptr;
4249
4250 for (ptr = defines; ptr; ptr = ptr->next)
4251 if (ptr->used == yy_buffer)
4252 {
4253 ptr->used = NULL;
4254 break;
4255 }
4256
4257 if (yyin != NULL)
4258 fclose(yyin);
4259
4260 yy_delete_buffer( YY_CURRENT_BUFFER );
4261 yy_switch_to_buffer(yy_buffer->buffer);
4262
4263 yylineno = yy_buffer->lineno;
4264
4265 /* We have to output the filename only if we change files here */
4266 i = strcmp(input_filename, yy_buffer->filename);
4267
4268 free(input_filename);
4269 input_filename = yy_buffer->filename;
4270
4271 yy_buffer = yy_buffer->next;
4272 free(yb);
4273
4274 if (i != 0)
4275 output_line_number();
4276
4277 }
4278 }
4279 YY_BREAK
4280 case 150:
4281 /* rule 150 can match eol */
4282 YY_RULE_SETUP
4283 #line 1292 "pgc.l"
4284 { mmfatal(PARSE_ERROR, "internal error: unreachable state; please report this to <pgsql-bugs@postgresql.org>"); }
4285 YY_BREAK
4286 case 151:
4287 YY_RULE_SETUP
4288 #line 1294 "pgc.l"
4289 YY_FATAL_ERROR( "flex scanner jammed" );
4290 YY_BREAK
4291 #line 4292 "pgc.c"
4292
4293 case YY_END_OF_BUFFER:
4294 {
4295 /* Amount of text matched not including the EOB char. */
4296 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
4297
4298 /* Undo the effects of YY_DO_BEFORE_ACTION. */
4299 *yy_cp = (yy_hold_char);
4300 YY_RESTORE_YY_MORE_OFFSET
4301
4302 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
4303 {
4304 /* We're scanning a new file or input source. It's
4305 * possible that this happened because the user
4306 * just pointed yyin at a new source and called
4307 * yylex(). If so, then we have to assure
4308 * consistency between YY_CURRENT_BUFFER and our
4309 * globals. Here is the right place to do so, because
4310 * this is the first action (other than possibly a
4311 * back-up) that will match for the new input source.
4312 */
4313 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
4314 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
4315 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
4316 }
4317
4318 /* Note that here we test for yy_c_buf_p "<=" to the position
4319 * of the first EOB in the buffer, since yy_c_buf_p will
4320 * already have been incremented past the NUL character
4321 * (since all states make transitions on EOB to the
4322 * end-of-buffer state). Contrast this with the test
4323 * in input().
4324 */
4325 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
4326 { /* This was really a NUL. */
4327 yy_state_type yy_next_state;
4328
4329 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
4330
4331 yy_current_state = yy_get_previous_state( );
4332
4333 /* Okay, we're now positioned to make the NUL
4334 * transition. We couldn't have
4335 * yy_get_previous_state() go ahead and do it
4336 * for us because it doesn't know how to deal
4337 * with the possibility of jamming (and we don't
4338 * want to build jamming into it because then it
4339 * will run more slowly).
4340 */
4341
4342 yy_next_state = yy_try_NUL_trans( yy_current_state );
4343
4344 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
4345
4346 if ( yy_next_state )
4347 {
4348 /* Consume the NUL. */
4349 yy_cp = ++(yy_c_buf_p);
4350 yy_current_state = yy_next_state;
4351 goto yy_match;
4352 }
4353
4354 else
4355 {
4356 yy_cp = (yy_last_accepting_cpos);
4357 yy_current_state = (yy_last_accepting_state);
4358 goto yy_find_action;
4359 }
4360 }
4361
4362 else switch ( yy_get_next_buffer( ) )
4363 {
4364 case EOB_ACT_END_OF_FILE:
4365 {
4366 (yy_did_buffer_switch_on_eof) = 0;
4367
4368 if ( yywrap( ) )
4369 {
4370 /* Note: because we've taken care in
4371 * yy_get_next_buffer() to have set up
4372 * yytext, we can now set up
4373 * yy_c_buf_p so that if some total
4374 * hoser (like flex itself) wants to
4375 * call the scanner after we return the
4376 * YY_NULL, it'll still work - another
4377 * YY_NULL will get returned.
4378 */
4379 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
4380
4381 yy_act = YY_STATE_EOF(YY_START);
4382 goto do_action;
4383 }
4384
4385 else
4386 {
4387 if ( ! (yy_did_buffer_switch_on_eof) )
4388 YY_NEW_FILE;
4389 }
4390 break;
4391 }
4392
4393 case EOB_ACT_CONTINUE_SCAN:
4394 (yy_c_buf_p) =
4395 (yytext_ptr) + yy_amount_of_matched_text;
4396
4397 yy_current_state = yy_get_previous_state( );
4398
4399 yy_cp = (yy_c_buf_p);
4400 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
4401 goto yy_match;
4402
4403 case EOB_ACT_LAST_MATCH:
4404 (yy_c_buf_p) =
4405 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
4406
4407 yy_current_state = yy_get_previous_state( );
4408
4409 yy_cp = (yy_c_buf_p);
4410 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
4411 goto yy_find_action;
4412 }
4413 break;
4414 }
4415
4416 default:
4417 YY_FATAL_ERROR(
4418 "fatal flex scanner internal error--no action found" );
4419 } /* end of action switch */
4420 } /* end of scanning one token */
4421 } /* end of user's declarations */
4422 } /* end of yylex */
4423
4424 /* yy_get_next_buffer - try to read in a new buffer
4425 *
4426 * Returns a code representing an action:
4427 * EOB_ACT_LAST_MATCH -
4428 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
4429 * EOB_ACT_END_OF_FILE - end of file
4430 */
yy_get_next_buffer(void)4431 static int yy_get_next_buffer (void)
4432 {
4433 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
4434 char *source = (yytext_ptr);
4435 int number_to_move, i;
4436 int ret_val;
4437
4438 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
4439 YY_FATAL_ERROR(
4440 "fatal flex scanner internal error--end of buffer missed" );
4441
4442 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
4443 { /* Don't try to fill the buffer, so this is an EOF. */
4444 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
4445 {
4446 /* We matched a single character, the EOB, so
4447 * treat this as a final EOF.
4448 */
4449 return EOB_ACT_END_OF_FILE;
4450 }
4451
4452 else
4453 {
4454 /* We matched some text prior to the EOB, first
4455 * process it.
4456 */
4457 return EOB_ACT_LAST_MATCH;
4458 }
4459 }
4460
4461 /* Try to read more data. */
4462
4463 /* First move last chars to start of buffer. */
4464 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
4465
4466 for ( i = 0; i < number_to_move; ++i )
4467 *(dest++) = *(source++);
4468
4469 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
4470 /* don't do the read, it's not guaranteed to return an EOF,
4471 * just force an EOF
4472 */
4473 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
4474
4475 else
4476 {
4477 int num_to_read =
4478 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
4479
4480 while ( num_to_read <= 0 )
4481 { /* Not enough room in the buffer - grow it. */
4482
4483 /* just a shorter name for the current buffer */
4484 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
4485
4486 int yy_c_buf_p_offset =
4487 (int) ((yy_c_buf_p) - b->yy_ch_buf);
4488
4489 if ( b->yy_is_our_buffer )
4490 {
4491 int new_size = b->yy_buf_size * 2;
4492
4493 if ( new_size <= 0 )
4494 b->yy_buf_size += b->yy_buf_size / 8;
4495 else
4496 b->yy_buf_size *= 2;
4497
4498 b->yy_ch_buf = (char *)
4499 /* Include room in for 2 EOB chars. */
4500 yyrealloc( (void *) b->yy_ch_buf,
4501 (yy_size_t) (b->yy_buf_size + 2) );
4502 }
4503 else
4504 /* Can't grow it, we don't own it. */
4505 b->yy_ch_buf = NULL;
4506
4507 if ( ! b->yy_ch_buf )
4508 YY_FATAL_ERROR(
4509 "fatal error - scanner input buffer overflow" );
4510
4511 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
4512
4513 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
4514 number_to_move - 1;
4515
4516 }
4517
4518 if ( num_to_read > YY_READ_BUF_SIZE )
4519 num_to_read = YY_READ_BUF_SIZE;
4520
4521 /* Read in more data. */
4522 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
4523 (yy_n_chars), num_to_read );
4524
4525 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4526 }
4527
4528 if ( (yy_n_chars) == 0 )
4529 {
4530 if ( number_to_move == YY_MORE_ADJ )
4531 {
4532 ret_val = EOB_ACT_END_OF_FILE;
4533 yyrestart( yyin );
4534 }
4535
4536 else
4537 {
4538 ret_val = EOB_ACT_LAST_MATCH;
4539 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
4540 YY_BUFFER_EOF_PENDING;
4541 }
4542 }
4543
4544 else
4545 ret_val = EOB_ACT_CONTINUE_SCAN;
4546
4547 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
4548 /* Extend the array by 50%, plus the number we really need. */
4549 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
4550 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
4551 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
4552 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
4553 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
4554 /* "- 2" to take care of EOB's */
4555 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
4556 }
4557
4558 (yy_n_chars) += number_to_move;
4559 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
4560 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
4561
4562 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
4563
4564 return ret_val;
4565 }
4566
4567 /* yy_get_previous_state - get the state just before the EOB char was reached */
4568
yy_get_previous_state(void)4569 static yy_state_type yy_get_previous_state (void)
4570 {
4571 yy_state_type yy_current_state;
4572 char *yy_cp;
4573
4574 yy_current_state = (yy_start);
4575
4576 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
4577 {
4578 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
4579 if ( yy_accept[yy_current_state] )
4580 {
4581 (yy_last_accepting_state) = yy_current_state;
4582 (yy_last_accepting_cpos) = yy_cp;
4583 }
4584 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4585 {
4586 yy_current_state = (int) yy_def[yy_current_state];
4587 if ( yy_current_state >= 831 )
4588 yy_c = yy_meta[yy_c];
4589 }
4590 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
4591 }
4592
4593 return yy_current_state;
4594 }
4595
4596 /* yy_try_NUL_trans - try to make a transition on the NUL character
4597 *
4598 * synopsis
4599 * next_state = yy_try_NUL_trans( current_state );
4600 */
yy_try_NUL_trans(yy_state_type yy_current_state)4601 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
4602 {
4603 int yy_is_jam;
4604 char *yy_cp = (yy_c_buf_p);
4605
4606 YY_CHAR yy_c = 1;
4607 if ( yy_accept[yy_current_state] )
4608 {
4609 (yy_last_accepting_state) = yy_current_state;
4610 (yy_last_accepting_cpos) = yy_cp;
4611 }
4612 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4613 {
4614 yy_current_state = (int) yy_def[yy_current_state];
4615 if ( yy_current_state >= 831 )
4616 yy_c = yy_meta[yy_c];
4617 }
4618 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
4619 yy_is_jam = (yy_current_state == 830);
4620
4621 return yy_is_jam ? 0 : yy_current_state;
4622 }
4623
4624 #ifndef YY_NO_UNPUT
4625
yyunput(int c,char * yy_bp)4626 static void yyunput (int c, char * yy_bp )
4627 {
4628 char *yy_cp;
4629
4630 yy_cp = (yy_c_buf_p);
4631
4632 /* undo effects of setting up yytext */
4633 *yy_cp = (yy_hold_char);
4634
4635 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4636 { /* need to shift things up to make room */
4637 /* +2 for EOB chars. */
4638 int number_to_move = (yy_n_chars) + 2;
4639 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
4640 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
4641 char *source =
4642 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
4643
4644 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
4645 *--dest = *--source;
4646
4647 yy_cp += (int) (dest - source);
4648 yy_bp += (int) (dest - source);
4649 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
4650 (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
4651
4652 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4653 YY_FATAL_ERROR( "flex scanner push-back overflow" );
4654 }
4655
4656 *--yy_cp = (char) c;
4657
4658 if ( c == '\n' ){
4659 --yylineno;
4660 }
4661
4662 (yytext_ptr) = yy_bp;
4663 (yy_hold_char) = *yy_cp;
4664 (yy_c_buf_p) = yy_cp;
4665 }
4666
4667 #endif
4668
4669 #ifndef YY_NO_INPUT
4670 #ifdef __cplusplus
yyinput(void)4671 static int yyinput (void)
4672 #else
4673 static int input (void)
4674 #endif
4675
4676 {
4677 int c;
4678
4679 *(yy_c_buf_p) = (yy_hold_char);
4680
4681 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
4682 {
4683 /* yy_c_buf_p now points to the character we want to return.
4684 * If this occurs *before* the EOB characters, then it's a
4685 * valid NUL; if not, then we've hit the end of the buffer.
4686 */
4687 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
4688 /* This was really a NUL. */
4689 *(yy_c_buf_p) = '\0';
4690
4691 else
4692 { /* need more input */
4693 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
4694 ++(yy_c_buf_p);
4695
4696 switch ( yy_get_next_buffer( ) )
4697 {
4698 case EOB_ACT_LAST_MATCH:
4699 /* This happens because yy_g_n_b()
4700 * sees that we've accumulated a
4701 * token and flags that we need to
4702 * try matching the token before
4703 * proceeding. But for input(),
4704 * there's no matching to consider.
4705 * So convert the EOB_ACT_LAST_MATCH
4706 * to EOB_ACT_END_OF_FILE.
4707 */
4708
4709 /* Reset buffer status. */
4710 yyrestart( yyin );
4711
4712 /*FALLTHROUGH*/
4713
4714 case EOB_ACT_END_OF_FILE:
4715 {
4716 if ( yywrap( ) )
4717 return 0;
4718
4719 if ( ! (yy_did_buffer_switch_on_eof) )
4720 YY_NEW_FILE;
4721 #ifdef __cplusplus
4722 return yyinput();
4723 #else
4724 return input();
4725 #endif
4726 }
4727
4728 case EOB_ACT_CONTINUE_SCAN:
4729 (yy_c_buf_p) = (yytext_ptr) + offset;
4730 break;
4731 }
4732 }
4733 }
4734
4735 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
4736 *(yy_c_buf_p) = '\0'; /* preserve yytext */
4737 (yy_hold_char) = *++(yy_c_buf_p);
4738
4739 if ( c == '\n' )
4740
4741 yylineno++;
4742 ;
4743
4744 return c;
4745 }
4746 #endif /* ifndef YY_NO_INPUT */
4747
4748 /** Immediately switch to a different input stream.
4749 * @param input_file A readable stream.
4750 *
4751 * @note This function does not reset the start condition to @c INITIAL .
4752 */
yyrestart(FILE * input_file)4753 void yyrestart (FILE * input_file )
4754 {
4755
4756 if ( ! YY_CURRENT_BUFFER ){
4757 yyensure_buffer_stack ();
4758 YY_CURRENT_BUFFER_LVALUE =
4759 yy_create_buffer( yyin, YY_BUF_SIZE );
4760 }
4761
4762 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
4763 yy_load_buffer_state( );
4764 }
4765
4766 /** Switch to a different input buffer.
4767 * @param new_buffer The new input buffer.
4768 *
4769 */
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)4770 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
4771 {
4772
4773 /* TODO. We should be able to replace this entire function body
4774 * with
4775 * yypop_buffer_state();
4776 * yypush_buffer_state(new_buffer);
4777 */
4778 yyensure_buffer_stack ();
4779 if ( YY_CURRENT_BUFFER == new_buffer )
4780 return;
4781
4782 if ( YY_CURRENT_BUFFER )
4783 {
4784 /* Flush out information for old buffer. */
4785 *(yy_c_buf_p) = (yy_hold_char);
4786 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4787 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4788 }
4789
4790 YY_CURRENT_BUFFER_LVALUE = new_buffer;
4791 yy_load_buffer_state( );
4792
4793 /* We don't actually know whether we did this switch during
4794 * EOF (yywrap()) processing, but the only time this flag
4795 * is looked at is after yywrap() is called, so it's safe
4796 * to go ahead and always set it.
4797 */
4798 (yy_did_buffer_switch_on_eof) = 1;
4799 }
4800
yy_load_buffer_state(void)4801 static void yy_load_buffer_state (void)
4802 {
4803 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
4804 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
4805 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
4806 (yy_hold_char) = *(yy_c_buf_p);
4807 }
4808
4809 /** Allocate and initialize an input buffer state.
4810 * @param file A readable stream.
4811 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
4812 *
4813 * @return the allocated buffer state.
4814 */
yy_create_buffer(FILE * file,int size)4815 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
4816 {
4817 YY_BUFFER_STATE b;
4818
4819 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
4820 if ( ! b )
4821 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
4822
4823 b->yy_buf_size = size;
4824
4825 /* yy_ch_buf has to be 2 characters longer than the size given because
4826 * we need to put in 2 end-of-buffer characters.
4827 */
4828 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
4829 if ( ! b->yy_ch_buf )
4830 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
4831
4832 b->yy_is_our_buffer = 1;
4833
4834 yy_init_buffer( b, file );
4835
4836 return b;
4837 }
4838
4839 /** Destroy the buffer.
4840 * @param b a buffer created with yy_create_buffer()
4841 *
4842 */
yy_delete_buffer(YY_BUFFER_STATE b)4843 void yy_delete_buffer (YY_BUFFER_STATE b )
4844 {
4845
4846 if ( ! b )
4847 return;
4848
4849 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
4850 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
4851
4852 if ( b->yy_is_our_buffer )
4853 yyfree( (void *) b->yy_ch_buf );
4854
4855 yyfree( (void *) b );
4856 }
4857
4858 /* Initializes or reinitializes a buffer.
4859 * This function is sometimes called more than once on the same buffer,
4860 * such as during a yyrestart() or at EOF.
4861 */
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)4862 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
4863
4864 {
4865 int oerrno = errno;
4866
4867 yy_flush_buffer( b );
4868
4869 b->yy_input_file = file;
4870 b->yy_fill_buffer = 1;
4871
4872 /* If b is the current buffer, then yy_init_buffer was _probably_
4873 * called from yyrestart() or through yy_get_next_buffer.
4874 * In that case, we don't want to reset the lineno or column.
4875 */
4876 if (b != YY_CURRENT_BUFFER){
4877 b->yy_bs_lineno = 1;
4878 b->yy_bs_column = 0;
4879 }
4880
4881 b->yy_is_interactive = 0;
4882
4883 errno = oerrno;
4884 }
4885
4886 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
4887 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
4888 *
4889 */
yy_flush_buffer(YY_BUFFER_STATE b)4890 void yy_flush_buffer (YY_BUFFER_STATE b )
4891 {
4892 if ( ! b )
4893 return;
4894
4895 b->yy_n_chars = 0;
4896
4897 /* We always need two end-of-buffer characters. The first causes
4898 * a transition to the end-of-buffer state. The second causes
4899 * a jam in that state.
4900 */
4901 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
4902 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
4903
4904 b->yy_buf_pos = &b->yy_ch_buf[0];
4905
4906 b->yy_at_bol = 1;
4907 b->yy_buffer_status = YY_BUFFER_NEW;
4908
4909 if ( b == YY_CURRENT_BUFFER )
4910 yy_load_buffer_state( );
4911 }
4912
4913 /** Pushes the new state onto the stack. The new state becomes
4914 * the current state. This function will allocate the stack
4915 * if necessary.
4916 * @param new_buffer The new state.
4917 *
4918 */
yypush_buffer_state(YY_BUFFER_STATE new_buffer)4919 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
4920 {
4921 if (new_buffer == NULL)
4922 return;
4923
4924 yyensure_buffer_stack();
4925
4926 /* This block is copied from yy_switch_to_buffer. */
4927 if ( YY_CURRENT_BUFFER )
4928 {
4929 /* Flush out information for old buffer. */
4930 *(yy_c_buf_p) = (yy_hold_char);
4931 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4932 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4933 }
4934
4935 /* Only push if top exists. Otherwise, replace top. */
4936 if (YY_CURRENT_BUFFER)
4937 (yy_buffer_stack_top)++;
4938 YY_CURRENT_BUFFER_LVALUE = new_buffer;
4939
4940 /* copied from yy_switch_to_buffer. */
4941 yy_load_buffer_state( );
4942 (yy_did_buffer_switch_on_eof) = 1;
4943 }
4944
4945 /** Removes and deletes the top of the stack, if present.
4946 * The next element becomes the new top.
4947 *
4948 */
yypop_buffer_state(void)4949 void yypop_buffer_state (void)
4950 {
4951 if (!YY_CURRENT_BUFFER)
4952 return;
4953
4954 yy_delete_buffer(YY_CURRENT_BUFFER );
4955 YY_CURRENT_BUFFER_LVALUE = NULL;
4956 if ((yy_buffer_stack_top) > 0)
4957 --(yy_buffer_stack_top);
4958
4959 if (YY_CURRENT_BUFFER) {
4960 yy_load_buffer_state( );
4961 (yy_did_buffer_switch_on_eof) = 1;
4962 }
4963 }
4964
4965 /* Allocates the stack if it does not exist.
4966 * Guarantees space for at least one push.
4967 */
yyensure_buffer_stack(void)4968 static void yyensure_buffer_stack (void)
4969 {
4970 yy_size_t num_to_alloc;
4971
4972 if (!(yy_buffer_stack)) {
4973
4974 /* First allocation is just for 2 elements, since we don't know if this
4975 * scanner will even need a stack. We use 2 instead of 1 to avoid an
4976 * immediate realloc on the next call.
4977 */
4978 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
4979 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
4980 (num_to_alloc * sizeof(struct yy_buffer_state*)
4981 );
4982 if ( ! (yy_buffer_stack) )
4983 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
4984
4985 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
4986
4987 (yy_buffer_stack_max) = num_to_alloc;
4988 (yy_buffer_stack_top) = 0;
4989 return;
4990 }
4991
4992 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
4993
4994 /* Increase the buffer to prepare for a possible push. */
4995 yy_size_t grow_size = 8 /* arbitrary grow size */;
4996
4997 num_to_alloc = (yy_buffer_stack_max) + grow_size;
4998 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
4999 ((yy_buffer_stack),
5000 num_to_alloc * sizeof(struct yy_buffer_state*)
5001 );
5002 if ( ! (yy_buffer_stack) )
5003 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
5004
5005 /* zero only the new slots.*/
5006 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
5007 (yy_buffer_stack_max) = num_to_alloc;
5008 }
5009 }
5010
5011 /** Setup the input buffer state to scan directly from a user-specified character buffer.
5012 * @param base the character buffer
5013 * @param size the size in bytes of the character buffer
5014 *
5015 * @return the newly allocated buffer state object.
5016 */
yy_scan_buffer(char * base,yy_size_t size)5017 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
5018 {
5019 YY_BUFFER_STATE b;
5020
5021 if ( size < 2 ||
5022 base[size-2] != YY_END_OF_BUFFER_CHAR ||
5023 base[size-1] != YY_END_OF_BUFFER_CHAR )
5024 /* They forgot to leave room for the EOB's. */
5025 return NULL;
5026
5027 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
5028 if ( ! b )
5029 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
5030
5031 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
5032 b->yy_buf_pos = b->yy_ch_buf = base;
5033 b->yy_is_our_buffer = 0;
5034 b->yy_input_file = NULL;
5035 b->yy_n_chars = b->yy_buf_size;
5036 b->yy_is_interactive = 0;
5037 b->yy_at_bol = 1;
5038 b->yy_fill_buffer = 0;
5039 b->yy_buffer_status = YY_BUFFER_NEW;
5040
5041 yy_switch_to_buffer( b );
5042
5043 return b;
5044 }
5045
5046 /** Setup the input buffer state to scan a string. The next call to yylex() will
5047 * scan from a @e copy of @a str.
5048 * @param yystr a NUL-terminated string to scan
5049 *
5050 * @return the newly allocated buffer state object.
5051 * @note If you want to scan bytes that may contain NUL values, then use
5052 * yy_scan_bytes() instead.
5053 */
yy_scan_string(const char * yystr)5054 YY_BUFFER_STATE yy_scan_string (const char * yystr )
5055 {
5056
5057 return yy_scan_bytes( yystr, (int) strlen(yystr) );
5058 }
5059
5060 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
5061 * scan from a @e copy of @a bytes.
5062 * @param yybytes the byte buffer to scan
5063 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
5064 *
5065 * @return the newly allocated buffer state object.
5066 */
yy_scan_bytes(const char * yybytes,int _yybytes_len)5067 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
5068 {
5069 YY_BUFFER_STATE b;
5070 char *buf;
5071 yy_size_t n;
5072 int i;
5073
5074 /* Get memory for full buffer, including space for trailing EOB's. */
5075 n = (yy_size_t) (_yybytes_len + 2);
5076 buf = (char *) yyalloc( n );
5077 if ( ! buf )
5078 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
5079
5080 for ( i = 0; i < _yybytes_len; ++i )
5081 buf[i] = yybytes[i];
5082
5083 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
5084
5085 b = yy_scan_buffer( buf, n );
5086 if ( ! b )
5087 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
5088
5089 /* It's okay to grow etc. this buffer, and we should throw it
5090 * away when we're done.
5091 */
5092 b->yy_is_our_buffer = 1;
5093
5094 return b;
5095 }
5096
5097 #ifndef YY_EXIT_FAILURE
5098 #define YY_EXIT_FAILURE 2
5099 #endif
5100
yy_fatal_error(const char * msg)5101 static void yynoreturn yy_fatal_error (const char* msg )
5102 {
5103 fprintf( stderr, "%s\n", msg );
5104 exit( YY_EXIT_FAILURE );
5105 }
5106
5107 /* Redefine yyless() so it works in section 3 code. */
5108
5109 #undef yyless
5110 #define yyless(n) \
5111 do \
5112 { \
5113 /* Undo effects of setting up yytext. */ \
5114 int yyless_macro_arg = (n); \
5115 YY_LESS_LINENO(yyless_macro_arg);\
5116 yytext[yyleng] = (yy_hold_char); \
5117 (yy_c_buf_p) = yytext + yyless_macro_arg; \
5118 (yy_hold_char) = *(yy_c_buf_p); \
5119 *(yy_c_buf_p) = '\0'; \
5120 yyleng = yyless_macro_arg; \
5121 } \
5122 while ( 0 )
5123
5124 /* Accessor methods (get/set functions) to struct members. */
5125
5126 /** Get the current line number.
5127 *
5128 */
yyget_lineno(void)5129 int yyget_lineno (void)
5130 {
5131
5132 return yylineno;
5133 }
5134
5135 /** Get the input stream.
5136 *
5137 */
yyget_in(void)5138 FILE *yyget_in (void)
5139 {
5140 return yyin;
5141 }
5142
5143 /** Get the output stream.
5144 *
5145 */
yyget_out(void)5146 FILE *yyget_out (void)
5147 {
5148 return yyout;
5149 }
5150
5151 /** Get the length of the current token.
5152 *
5153 */
yyget_leng(void)5154 int yyget_leng (void)
5155 {
5156 return yyleng;
5157 }
5158
5159 /** Get the current token.
5160 *
5161 */
5162
yyget_text(void)5163 char *yyget_text (void)
5164 {
5165 return yytext;
5166 }
5167
5168 /** Set the current line number.
5169 * @param _line_number line number
5170 *
5171 */
yyset_lineno(int _line_number)5172 void yyset_lineno (int _line_number )
5173 {
5174
5175 yylineno = _line_number;
5176 }
5177
5178 /** Set the input stream. This does not discard the current
5179 * input buffer.
5180 * @param _in_str A readable stream.
5181 *
5182 * @see yy_switch_to_buffer
5183 */
yyset_in(FILE * _in_str)5184 void yyset_in (FILE * _in_str )
5185 {
5186 yyin = _in_str ;
5187 }
5188
yyset_out(FILE * _out_str)5189 void yyset_out (FILE * _out_str )
5190 {
5191 yyout = _out_str ;
5192 }
5193
yyget_debug(void)5194 int yyget_debug (void)
5195 {
5196 return yy_flex_debug;
5197 }
5198
yyset_debug(int _bdebug)5199 void yyset_debug (int _bdebug )
5200 {
5201 yy_flex_debug = _bdebug ;
5202 }
5203
yy_init_globals(void)5204 static int yy_init_globals (void)
5205 {
5206 /* Initialization is the same as for the non-reentrant scanner.
5207 * This function is called from yylex_destroy(), so don't allocate here.
5208 */
5209
5210 /* We do not touch yylineno unless the option is enabled. */
5211 yylineno = 1;
5212
5213 (yy_buffer_stack) = NULL;
5214 (yy_buffer_stack_top) = 0;
5215 (yy_buffer_stack_max) = 0;
5216 (yy_c_buf_p) = NULL;
5217 (yy_init) = 0;
5218 (yy_start) = 0;
5219
5220 /* Defined in main.c */
5221 #ifdef YY_STDINIT
5222 yyin = stdin;
5223 yyout = stdout;
5224 #else
5225 yyin = NULL;
5226 yyout = NULL;
5227 #endif
5228
5229 /* For future reference: Set errno on error, since we are called by
5230 * yylex_init()
5231 */
5232 return 0;
5233 }
5234
5235 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
yylex_destroy(void)5236 int yylex_destroy (void)
5237 {
5238
5239 /* Pop the buffer stack, destroying each element. */
5240 while(YY_CURRENT_BUFFER){
5241 yy_delete_buffer( YY_CURRENT_BUFFER );
5242 YY_CURRENT_BUFFER_LVALUE = NULL;
5243 yypop_buffer_state();
5244 }
5245
5246 /* Destroy the stack itself. */
5247 yyfree((yy_buffer_stack) );
5248 (yy_buffer_stack) = NULL;
5249
5250 /* Reset the globals. This is important in a non-reentrant scanner so the next time
5251 * yylex() is called, initialization will occur. */
5252 yy_init_globals( );
5253
5254 return 0;
5255 }
5256
5257 /*
5258 * Internal utility routines.
5259 */
5260
5261 #ifndef yytext_ptr
yy_flex_strncpy(char * s1,const char * s2,int n)5262 static void yy_flex_strncpy (char* s1, const char * s2, int n )
5263 {
5264
5265 int i;
5266 for ( i = 0; i < n; ++i )
5267 s1[i] = s2[i];
5268 }
5269 #endif
5270
5271 #ifdef YY_NEED_STRLEN
yy_flex_strlen(const char * s)5272 static int yy_flex_strlen (const char * s )
5273 {
5274 int n;
5275 for ( n = 0; s[n]; ++n )
5276 ;
5277
5278 return n;
5279 }
5280 #endif
5281
yyalloc(yy_size_t size)5282 void *yyalloc (yy_size_t size )
5283 {
5284 return malloc(size);
5285 }
5286
yyrealloc(void * ptr,yy_size_t size)5287 void *yyrealloc (void * ptr, yy_size_t size )
5288 {
5289
5290 /* The cast to (char *) in the following accommodates both
5291 * implementations that use char* generic pointers, and those
5292 * that use void* generic pointers. It works with the latter
5293 * because both ANSI C and C++ allow castless assignment from
5294 * any pointer type to void*, and deal with argument conversions
5295 * as though doing an assignment.
5296 */
5297 return realloc(ptr, size);
5298 }
5299
yyfree(void * ptr)5300 void yyfree (void * ptr )
5301 {
5302 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
5303 }
5304
5305 #define YYTABLES_NAME "yytables"
5306
5307 #line 1294 "pgc.l"
5308
5309
5310 /* LCOV_EXCL_STOP */
5311
5312 void
lex_init(void)5313 lex_init(void)
5314 {
5315 braces_open = 0;
5316 parenths_open = 0;
5317 current_function = NULL;
5318
5319 preproc_tos = 0;
5320 yylineno = 1;
5321 ifcond = true;
5322 stacked_if_value[preproc_tos].condition = ifcond;
5323 stacked_if_value[preproc_tos].else_branch = false;
5324
5325 /* initialize literal buffer to a reasonable but expansible size */
5326 if (literalbuf == NULL)
5327 {
5328 literalalloc = 1024;
5329 literalbuf = (char *) malloc(literalalloc);
5330 }
5331 startlit();
5332
5333 BEGIN(C);
5334 }
5335
5336 static void
addlit(char * ytext,int yleng)5337 addlit(char *ytext, int yleng)
5338 {
5339 /* enlarge buffer if needed */
5340 if ((literallen+yleng) >= literalalloc)
5341 {
5342 do
5343 literalalloc *= 2;
5344 while ((literallen+yleng) >= literalalloc);
5345 literalbuf = (char *) realloc(literalbuf, literalalloc);
5346 }
5347 /* append new data, add trailing null */
5348 memcpy(literalbuf+literallen, ytext, yleng);
5349 literallen += yleng;
5350 literalbuf[literallen] = '\0';
5351 }
5352
5353 static void
addlitchar(unsigned char ychar)5354 addlitchar(unsigned char ychar)
5355 {
5356 /* enlarge buffer if needed */
5357 if ((literallen+1) >= literalalloc)
5358 {
5359 literalalloc *= 2;
5360 literalbuf = (char *) realloc(literalbuf, literalalloc);
5361 }
5362 /* append new data, add trailing null */
5363 literalbuf[literallen] = ychar;
5364 literallen += 1;
5365 literalbuf[literallen] = '\0';
5366 }
5367
5368 static void
parse_include(void)5369 parse_include(void)
5370 {
5371 /* got the include file name */
5372 struct _yy_buffer *yb;
5373 struct _include_path *ip;
5374 char inc_file[MAXPGPATH];
5375 unsigned int i;
5376
5377 yb = mm_alloc(sizeof(struct _yy_buffer));
5378
5379 yb->buffer = YY_CURRENT_BUFFER;
5380 yb->lineno = yylineno;
5381 yb->filename = input_filename;
5382 yb->next = yy_buffer;
5383
5384 yy_buffer = yb;
5385
5386 /*
5387 * skip the ";" if there is one and trailing whitespace. Note that
5388 * yytext contains at least one non-space character plus the ";"
5389 */
5390 for (i = strlen(yytext)-2;
5391 i > 0 && ecpg_isspace(yytext[i]);
5392 i--)
5393 ;
5394
5395 if (yytext[i] == ';')
5396 i--;
5397
5398 yytext[i+1] = '\0';
5399
5400 yyin = NULL;
5401
5402 /* If file name is enclosed in '"' remove these and look only in '.' */
5403 /* Informix does look into all include paths though, except filename starts with '/' */
5404 if (yytext[0] == '"' && yytext[i] == '"' &&
5405 ((compat != ECPG_COMPAT_INFORMIX && compat != ECPG_COMPAT_INFORMIX_SE) || yytext[1] == '/'))
5406 {
5407 yytext[i] = '\0';
5408 memmove(yytext, yytext+1, strlen(yytext));
5409
5410 strlcpy(inc_file, yytext, sizeof(inc_file));
5411 yyin = fopen(inc_file, "r");
5412 if (!yyin)
5413 {
5414 if (strlen(inc_file) <= 2 || strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
5415 {
5416 strcat(inc_file, ".h");
5417 yyin = fopen(inc_file, "r");
5418 }
5419 }
5420
5421 }
5422 else
5423 {
5424 if ((yytext[0] == '"' && yytext[i] == '"') || (yytext[0] == '<' && yytext[i] == '>'))
5425 {
5426 yytext[i] = '\0';
5427 memmove(yytext, yytext+1, strlen(yytext));
5428 }
5429
5430 for (ip = include_paths; yyin == NULL && ip != NULL; ip = ip->next)
5431 {
5432 if (strlen(ip->path) + strlen(yytext) + 4 > MAXPGPATH)
5433 {
5434 fprintf(stderr, _("Error: include path \"%s/%s\" is too long on line %d, skipping\n"), ip->path, yytext, yylineno);
5435 continue;
5436 }
5437 snprintf (inc_file, sizeof(inc_file), "%s/%s", ip->path, yytext);
5438 yyin = fopen(inc_file, "r");
5439 if (!yyin)
5440 {
5441 if (strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
5442 {
5443 strcat(inc_file, ".h");
5444 yyin = fopen( inc_file, "r" );
5445 }
5446 }
5447 /* if the command was "include_next" we have to disregard the first hit */
5448 if (yyin && include_next)
5449 {
5450 fclose (yyin);
5451 yyin = NULL;
5452 include_next = false;
5453 }
5454 }
5455 }
5456 if (!yyin)
5457 mmfatal(NO_INCLUDE_FILE, "could not open include file \"%s\" on line %d", yytext, yylineno);
5458
5459 input_filename = mm_strdup(inc_file);
5460 yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE ));
5461 yylineno = 1;
5462 output_line_number();
5463
5464 BEGIN(C);
5465 }
5466
5467 /*
5468 * ecpg_isspace() --- return true if flex scanner considers char whitespace
5469 */
5470 static bool
ecpg_isspace(char ch)5471 ecpg_isspace(char ch)
5472 {
5473 if (ch == ' ' ||
5474 ch == '\t' ||
5475 ch == '\n' ||
5476 ch == '\r' ||
5477 ch == '\f')
5478 return true;
5479 return false;
5480 }
5481
isdefine(void)5482 static bool isdefine(void)
5483 {
5484 struct _defines *ptr;
5485
5486 /* is it a define? */
5487 for (ptr = defines; ptr; ptr = ptr->next)
5488 {
5489 if (strcmp(yytext, ptr->old) == 0 && ptr->used == NULL)
5490 {
5491 struct _yy_buffer *yb;
5492
5493 yb = mm_alloc(sizeof(struct _yy_buffer));
5494
5495 yb->buffer = YY_CURRENT_BUFFER;
5496 yb->lineno = yylineno;
5497 yb->filename = mm_strdup(input_filename);
5498 yb->next = yy_buffer;
5499
5500 ptr->used = yy_buffer = yb;
5501
5502 yy_scan_string(ptr->new);
5503 return true;
5504 }
5505 }
5506
5507 return false;
5508 }
5509
isinformixdefine(void)5510 static bool isinformixdefine(void)
5511 {
5512 const char *new = NULL;
5513
5514 if (strcmp(yytext, "dec_t") == 0)
5515 new = "decimal";
5516 else if (strcmp(yytext, "intrvl_t") == 0)
5517 new = "interval";
5518 else if (strcmp(yytext, "dtime_t") == 0)
5519 new = "timestamp";
5520
5521 if (new)
5522 {
5523 struct _yy_buffer *yb;
5524
5525 yb = mm_alloc(sizeof(struct _yy_buffer));
5526
5527 yb->buffer = YY_CURRENT_BUFFER;
5528 yb->lineno = yylineno;
5529 yb->filename = mm_strdup(input_filename);
5530 yb->next = yy_buffer;
5531 yy_buffer = yb;
5532
5533 yy_scan_string(new);
5534 return true;
5535 }
5536
5537 return false;
5538 }
5539
5540 /*
5541 * Called before any actual parsing is done
5542 */
5543 void
scanner_init(const char * str)5544 scanner_init(const char *str)
5545 {
5546 Size slen = strlen(str);
5547
5548 /*
5549 * Might be left over after ereport()
5550 */
5551 if (YY_CURRENT_BUFFER)
5552 yy_delete_buffer(YY_CURRENT_BUFFER);
5553
5554 /*
5555 * Make a scan buffer with special termination needed by flex.
5556 */
5557 scanbuf = mm_alloc(slen + 2);
5558 memcpy(scanbuf, str, slen);
5559 scanbuf[slen] = scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
5560 scanbufhandle = yy_scan_buffer(scanbuf, slen + 2);
5561
5562 /* initialize literal buffer to a reasonable but expansible size */
5563 literalalloc = 128;
5564 literalbuf = (char *) mm_alloc(literalalloc);
5565 startlit();
5566
5567 BEGIN(INITIAL);
5568 }
5569
5570
5571 /*
5572 * Called after parsing is done to clean up after scanner_init()
5573 */
5574 void
scanner_finish(void)5575 scanner_finish(void)
5576 {
5577 yy_delete_buffer(scanbufhandle);
5578 free(scanbuf);
5579 }
5580
5581