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