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