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