From 5566f0c2475cb1d68437de2df7200cc692e184ac Mon Sep 17 00:00:00 2001 From: David Rose Date: Mon, 4 Oct 2004 03:14:26 +0000 Subject: [PATCH] prebuild-bison --- pandatool/src/vrml/vrmlLexer.cxx.prebuilt | 4441 ++++++++++++++++++++ pandatool/src/vrml/vrmlParser.cxx.prebuilt | 1761 ++++++++ pandatool/src/vrml/vrmlParser.h.prebuilt | 52 + pandatool/src/xfile/xLexer.cxx.prebuilt | 2194 ++++++++++ pandatool/src/xfile/xParser.cxx.prebuilt | 1383 ++++++ pandatool/src/xfile/xParser.h.prebuilt | 26 + 6 files changed, 9857 insertions(+) create mode 100644 pandatool/src/vrml/vrmlLexer.cxx.prebuilt create mode 100644 pandatool/src/vrml/vrmlParser.cxx.prebuilt create mode 100644 pandatool/src/vrml/vrmlParser.h.prebuilt create mode 100644 pandatool/src/xfile/xLexer.cxx.prebuilt create mode 100644 pandatool/src/xfile/xParser.cxx.prebuilt create mode 100644 pandatool/src/xfile/xParser.h.prebuilt diff --git a/pandatool/src/vrml/vrmlLexer.cxx.prebuilt b/pandatool/src/vrml/vrmlLexer.cxx.prebuilt new file mode 100644 index 0000000000..0d38f88ba9 --- /dev/null +++ b/pandatool/src/vrml/vrmlLexer.cxx.prebuilt @@ -0,0 +1,4441 @@ +#define yy_create_buffer vrmlyy_create_buffer +#define yy_delete_buffer vrmlyy_delete_buffer +#define yy_scan_buffer vrmlyy_scan_buffer +#define yy_scan_string vrmlyy_scan_string +#define yy_scan_bytes vrmlyy_scan_bytes +#define yy_flex_debug vrmlyy_flex_debug +#define yy_init_buffer vrmlyy_init_buffer +#define yy_flush_buffer vrmlyy_flush_buffer +#define yy_load_buffer_state vrmlyy_load_buffer_state +#define yy_switch_to_buffer vrmlyy_switch_to_buffer +#define yyin vrmlyyin +#define yyleng vrmlyyleng +#define yylex vrmlyylex +#define yyout vrmlyyout +#define yyrestart vrmlyyrestart +#define yytext vrmlyytext +#define yywrap vrmlyywrap + +#line 20 "lex.yy.c" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 48 +#define YY_END_OF_BUFFER 49 +static yyconst short int yy_accept[975] = + { 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 49, 47, 45, 46, 45, 14, + 45, 15, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 47, 47, 47, 47, 47, 47, 47, 47, + 24, 47, 47, 47, 47, 22, 22, 47, 47, 47, + 37, 35, 37, 37, 47, 47, 34, 47, 47, 47, + 47, 47, 47, 47, 47, 47, 47, 18, 19, 47, + + 47, 25, 47, 23, 23, 47, 47, 47, 38, 36, + 38, 38, 47, 47, 47, 47, 47, 47, 40, 40, + 41, 40, 40, 42, 47, 44, 44, 45, 46, 45, + 46, 46, 45, 45, 45, 45, 14, 15, 14, 14, + 7, 14, 14, 14, 6, 14, 14, 14, 14, 0, + 16, 0, 0, 0, 0, 0, 0, 0, 24, 24, + 0, 0, 0, 0, 22, 22, 0, 0, 0, 0, + 0, 37, 37, 37, 16, 0, 34, 34, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 17, 0, 25, 25, 23, 23, 0, + + 0, 0, 0, 0, 38, 38, 38, 17, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 40, 40, + 40, 40, 40, 40, 39, 44, 44, 46, 46, 46, + 45, 4, 14, 14, 14, 14, 5, 14, 14, 14, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 43, 43, 0, 0, 0, 0, + 43, 43, 0, 22, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, + 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 27, 0, 0, 0, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 44, 45, 14, + 9, 14, 14, 14, 14, 14, 0, 20, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 24, 43, + 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 34, 0, 0, 26, 26, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 27, 27, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 45, 14, + 2, 8, 14, 14, 12, 21, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 32, 0, 0, 0, 32, + 0, 0, 0, 32, 0, 0, 0, 0, 0, 32, + 43, 43, 43, 43, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 28, 0, 0, 0, 0, 0, 28, + 0, 0, 0, 28, 0, 0, 0, 28, 0, 0, + + 0, 0, 0, 28, 0, 0, 0, 33, 0, 0, + 0, 0, 0, 33, 0, 0, 0, 33, 0, 0, + 0, 33, 0, 0, 0, 0, 0, 33, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, + 0, 0, 0, 29, 0, 0, 0, 29, 0, 0, + 0, 29, 0, 0, 0, 0, 0, 29, 45, 14, + 14, 14, 14, 0, 0, 32, 32, 0, 0, 0, + 32, 32, 32, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 26, 0, 0, 26, 0, + 0, 28, 28, 0, 0, 0, 28, 28, 28, 0, + 0, 33, 33, 0, 0, 0, 33, 33, 33, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 27, 0, 0, 27, 0, 0, 29, 29, 0, + 0, 0, 29, 29, 29, 45, 14, 10, 14, 14, + 0, 0, 0, 0, 0, 0, 0, 0, 30, 0, + 0, 0, 0, 0, 30, 0, 0, 0, 30, 0, + + 0, 30, 0, 0, 0, 0, 0, 30, 0, 0, + 0, 30, 0, 0, 0, 30, 0, 0, 0, 0, + 0, 30, 0, 0, 0, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 31, 0, 0, 0, 0, 0, 31, 0, 0, 0, + 31, 0, 0, 31, 0, 0, 0, 0, 0, 31, + 0, 0, 0, 31, 0, 0, 0, 31, 0, 0, + 0, 0, 0, 31, 0, 0, 0, 0, 31, 0, + 0, 0, 0, 0, 45, 14, 11, 14, 0, 32, + 0, 0, 32, 0, 0, 32, 0, 32, 0, 0, + + 32, 0, 0, 30, 30, 0, 0, 0, 30, 30, + 30, 0, 0, 0, 30, 30, 30, 0, 0, 0, + 0, 0, 30, 0, 28, 0, 0, 28, 0, 0, + 28, 0, 28, 0, 0, 28, 0, 33, 0, 0, + 33, 0, 0, 33, 0, 33, 0, 0, 33, 0, + 0, 31, 31, 0, 0, 0, 31, 31, 31, 0, + 0, 0, 31, 31, 31, 0, 0, 0, 0, 0, + 31, 0, 29, 0, 0, 29, 0, 0, 29, 0, + 29, 0, 0, 29, 45, 14, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 45, 14, 14, 0, 30, + 0, 0, 30, 0, 0, 30, 0, 30, 0, 0, + 30, 0, 0, 30, 0, 30, 0, 0, 30, 0, + 0, 30, 0, 31, 0, 0, 31, 0, 0, 31, + 0, 31, 0, 0, 31, 0, 0, 31, 0, 31, + 0, 0, 31, 0, 0, 31, 45, 3, 14, 45, + 13, 45, 45, 45, 45, 45, 1, 45, 1, 1, + 1, 1, 1, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 5, 6, 7, 5, 5, 5, 1, 5, + 5, 5, 8, 2, 9, 10, 5, 11, 12, 13, + 12, 12, 12, 12, 12, 14, 12, 5, 5, 5, + 5, 5, 5, 5, 15, 16, 16, 17, 18, 19, + 5, 5, 20, 5, 5, 21, 22, 23, 24, 25, + 5, 26, 27, 28, 29, 30, 5, 31, 5, 5, + 32, 33, 34, 5, 5, 5, 16, 16, 16, 35, + + 36, 37, 5, 5, 38, 5, 5, 39, 5, 40, + 41, 42, 5, 5, 43, 44, 45, 46, 5, 47, + 5, 5, 1, 5, 1, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5 + } ; + +static yyconst int yy_meta[48] = + { 0, + 1, 2, 3, 2, 4, 5, 6, 1, 4, 1, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 8, 1, 8, 7, 7, 7, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4 + } ; + +static yyconst short int yy_base[1137] = + { 0, + 0, 6, 13, 0, 59, 65, 92, 0, 104, 110, + 116, 122, 128, 134, 140, 146, 159, 165, 164, 177, + 183, 189, 195, 201, 207, 233, 259, 285, 311, 337, + 363, 389, 422, 455, 481, 507, 533, 559, 222, 228, + 256, 274, 324, 350, 672, 8258, 73, 79, 280, 0, + 247, 0, 652, 638, 633, 630, 630, 627, 625, 621, + 18, 597, 619, 600, 589, 78, 96, 592, 170, 289, + 301, 315, 605, 51, 328, 373, 341, 368, 354, 651, + 0, 8258, 386, 587, 400, 394, 405, 420, 424, 664, + 433, 437, 677, 453, 457, 690, 586, 8258, 8258, 466, + + 470, 486, 491, 517, 495, 512, 521, 703, 0, 8258, + 548, 584, 546, 563, 716, 573, 609, 729, 0, 559, + 8258, 622, 604, 8258, 619, 626, 630, 643, 302, 742, + 746, 750, 756, 762, 768, 774, 0, 0, 582, 572, + 0, 577, 573, 563, 0, 572, 553, 546, 545, 557, + 8258, 520, 771, 0, 799, 834, 847, 775, 780, 816, + 0, 860, 873, 812, 784, 0, 809, 0, 886, 921, + 934, 0, 899, 905, 0, 902, 907, 938, 946, 0, + 973, 1008, 1021, 950, 0, 1034, 1069, 1082, 954, 0, + 1095, 1130, 1143, 8258, 958, 982, 990, 986, 0, 1042, + + 0, 1156, 1191, 1204, 0, 1056, 1117, 0, 1053, 0, + 1217, 1252, 1265, 1103, 1278, 1291, 1326, 1339, 0, 1123, + 1169, 1175, 1181, 1230, 8258, 1227, 0, 1240, 1241, 1304, + 1310, 0, 522, 517, 486, 484, 0, 448, 433, 421, + 428, 423, 1307, 1312, 1238, 1352, 1365, 1378, 0, 0, + 1382, 1395, 1392, 1396, 1400, 1404, 1446, 1459, 1472, 1485, + 1498, 191, 1417, 0, 1414, 1422, 1426, 1544, 1557, 1570, + 0, 0, 1430, 1511, 1508, 1519, 1524, 1512, 1529, 1583, + 0, 0, 0, 1587, 0, 1594, 1599, 1603, 1616, 1629, + 0, 0, 0, 1633, 1646, 1643, 1648, 1652, 1665, 1678, + + 0, 0, 0, 1682, 1695, 1692, 0, 1699, 1704, 1708, + 1721, 1734, 0, 0, 0, 1738, 1751, 1748, 1753, 1757, + 1762, 1775, 0, 0, 0, 1779, 0, 1786, 1791, 1795, + 1808, 1821, 0, 0, 0, 1825, 1838, 0, 1844, 401, + 0, 398, 378, 350, 348, 323, 338, 8258, 1841, 1864, + 1877, 1912, 1925, 1938, 1966, 2001, 2014, 1845, 1849, 0, + 2018, 1885, 2064, 2077, 2112, 2125, 2138, 2166, 2201, 2214, + 1889, 1893, 1897, 2227, 1946, 1954, 1974, 2240, 2253, 2288, + 2301, 2314, 2342, 2377, 2390, 1980, 2403, 2416, 2451, 2464, + 2477, 2512, 2525, 2538, 1984, 2027, 2031, 2551, 2564, 2599, + + 2612, 2625, 2660, 2673, 2686, 2045, 2699, 2094, 2712, 2049, + 2747, 2760, 2795, 2808, 2821, 2856, 2869, 2882, 2044, 309, + 0, 0, 50, 294, 0, 8258, 2085, 2090, 2146, 2151, + 2895, 2908, 0, 0, 2155, 0, 2921, 2934, 2175, 2188, + 2947, 2186, 2159, 2960, 2973, 0, 0, 0, 2261, 0, + 0, 2987, 205, 209, 2268, 2273, 2322, 3033, 3046, 3059, + 0, 0, 2326, 2339, 3072, 3085, 2351, 2364, 3098, 2362, + 2424, 3111, 3124, 0, 0, 0, 2428, 2441, 2485, 3137, + 2492, 2497, 2572, 2577, 3150, 3163, 0, 0, 2581, 0, + 3176, 3189, 2634, 2647, 3202, 2645, 2585, 3215, 3228, 0, + + 0, 0, 2720, 0, 2727, 2732, 2768, 2773, 3241, 3254, + 0, 0, 2777, 0, 3267, 3280, 2830, 2843, 3293, 2841, + 2781, 3306, 3319, 0, 0, 0, 3323, 0, 3330, 3335, + 3339, 3352, 3365, 3378, 0, 0, 3382, 3395, 3401, 3414, + 3419, 3432, 3438, 3443, 3447, 3460, 3473, 0, 0, 0, + 3477, 3490, 3487, 3500, 3507, 3512, 3516, 3521, 3534, 3547, + 0, 0, 3551, 0, 3564, 3577, 3582, 3595, 3601, 3606, + 3610, 3623, 3636, 0, 0, 0, 3640, 0, 3653, 293, + 276, 263, 257, 3650, 3682, 3654, 3695, 3730, 3743, 3667, + 3756, 3791, 3826, 3664, 3861, 3874, 3909, 3922, 3935, 3970, + + 3983, 3996, 4009, 4022, 3708, 4035, 4063, 4098, 4111, 4124, + 4159, 4172, 4207, 4220, 3668, 3705, 4233, 4246, 0, 3709, + 4259, 3764, 4272, 4307, 4320, 3722, 4333, 4368, 4403, 3772, + 4438, 3805, 4451, 4486, 4499, 3804, 4512, 4547, 4582, 3776, + 4617, 4630, 4665, 4678, 4691, 4726, 4739, 4752, 4765, 4778, + 3818, 4791, 4819, 4854, 4867, 4880, 4915, 4928, 4963, 4976, + 3801, 3834, 4989, 5002, 0, 3838, 5015, 3843, 5028, 5063, + 5076, 3887, 5089, 5124, 5159, 3893, 264, 0, 244, 247, + 3890, 5194, 5207, 3943, 5220, 3950, 3955, 4043, 4048, 5233, + 5246, 0, 0, 4052, 0, 5259, 5272, 4072, 4085, 4083, + + 4056, 5285, 5298, 5311, 0, 0, 4132, 0, 5324, 5337, + 4137, 4150, 5350, 4181, 4185, 5363, 5376, 0, 0, 0, + 4189, 0, 4280, 5389, 5402, 4285, 4298, 4341, 5415, 5428, + 4348, 5441, 4376, 5454, 5467, 4383, 5480, 4411, 4353, 4193, + 4388, 5493, 5506, 0, 0, 4415, 0, 5519, 5532, 4420, + 4464, 4462, 4424, 5545, 5558, 5571, 0, 0, 4466, 0, + 5584, 5597, 4471, 4525, 5610, 4523, 4527, 5623, 5636, 0, + 0, 0, 4531, 0, 4555, 5649, 5662, 4560, 4573, 4590, + 5675, 5688, 4597, 5701, 4643, 240, 0, 219, 4601, 4643, + 5714, 0, 0, 5727, 0, 4656, 4699, 5740, 5753, 5766, + + 0, 4703, 5779, 4708, 5792, 5827, 5840, 4804, 5853, 5888, + 5923, 5958, 5971, 4810, 5984, 6019, 6054, 4807, 6089, 6102, + 6115, 4832, 6128, 4811, 4829, 6163, 6176, 0, 6189, 6202, + 4842, 4839, 6215, 6228, 6241, 0, 4888, 4892, 6254, 6267, + 0, 6280, 6293, 4905, 4936, 6306, 6319, 6332, 0, 4940, + 6345, 4945, 6358, 6393, 6406, 5041, 6419, 6454, 6489, 6524, + 6537, 5047, 6550, 6585, 6620, 5044, 6655, 6668, 6681, 5102, + 6694, 5048, 5099, 6729, 6742, 0, 6755, 6768, 5112, 5109, + 6781, 6794, 6807, 0, 5137, 220, 201, 5138, 6820, 6833, + 5145, 6846, 6859, 5167, 6872, 6885, 5174, 6898, 5800, 5807, + + 6911, 5861, 5868, 6924, 5896, 5187, 209, 184, 5811, 5872, + 6937, 0, 0, 6950, 0, 5909, 5906, 6963, 6976, 0, + 0, 6989, 0, 5936, 5933, 7002, 7015, 0, 0, 7028, + 0, 5946, 5943, 5992, 3, 266, 277, 5996, 6000, 6033, + 6004, 6027, 431, 444, 464, 6062, 6066, 6071, 6136, 6140, + 477, 502, 528, 6144, 6148, 6375, 6432, 0, 135, 6438, + 0, 6375, 6046, 6444, 6467, 6476, 6482, 6502, 6506, 6510, + 6514, 6563, 6567, 8258, 7042, 7050, 7058, 7066, 7074, 7079, + 7083, 7090, 7098, 7106, 7113, 7121, 7129, 7137, 7145, 7153, + 7160, 157, 7167, 7175, 7183, 7191, 104, 7199, 7207, 7215, + + 7223, 7231, 93, 7239, 7247, 7252, 7259, 7267, 7274, 90, + 7281, 7289, 7297, 66, 7305, 7313, 7321, 7329, 7337, 7345, + 7353, 7361, 7369, 7377, 7385, 7393, 7401, 7409, 7417, 7422, + 7429, 7437, 7445, 64, 7453, 7461, 7469, 7477, 7485, 7493, + 7501, 7509, 7517, 7525, 7533, 7541, 7549, 7557, 7565, 7573, + 7581, 7589, 7594, 7601, 7609, 7617, 7625, 7633, 7641, 7649, + 7657, 7665, 7673, 7681, 7689, 7697, 7705, 7713, 7721, 7729, + 7737, 7745, 7753, 7761, 7769, 7777, 7785, 7793, 7801, 7809, + 7814, 7821, 7829, 7837, 7845, 7853, 7861, 7869, 7877, 7885, + 7893, 7901, 7909, 7917, 7925, 7933, 7941, 7949, 7957, 7965, + + 7973, 7981, 7989, 7997, 8005, 8013, 8021, 8029, 8037, 8045, + 8053, 8061, 8069, 8077, 8085, 8093, 8101, 8109, 8117, 8125, + 8133, 8141, 8149, 8157, 8165, 8173, 8181, 8186, 8193, 8201, + 8209, 8217, 8225, 8233, 8241, 8249 + } ; + +static yyconst short int yy_def[1137] = + { 0, + 975, 975, 974, 3, 975, 975, 975, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 976, 976, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 977, 977, 7, 7, 7, 7, 978, 978, + 978, 978, 7, 7, 974, 974, 974, 974, 979, 980, + 979, 981, 980, 980, 980, 980, 980, 980, 980, 980, + 980, 980, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 73, 974, 974, 974, 974, 974, 974, + 982, 974, 983, 982, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + + 974, 974, 974, 974, 974, 974, 974, 974, 984, 974, + 985, 984, 974, 974, 974, 974, 974, 974, 986, 986, + 974, 987, 986, 974, 974, 974, 974, 974, 974, 979, + 974, 988, 979, 979, 979, 979, 980, 981, 980, 980, + 980, 980, 980, 980, 980, 980, 980, 980, 980, 974, + 974, 974, 974, 68, 974, 974, 989, 974, 974, 974, + 74, 974, 990, 991, 974, 992, 974, 80, 974, 974, + 993, 982, 983, 983, 982, 974, 974, 974, 974, 90, + 974, 974, 994, 974, 93, 974, 974, 995, 974, 96, + 974, 974, 996, 974, 974, 974, 974, 974, 997, 974, + + 108, 974, 974, 998, 984, 985, 985, 984, 974, 115, + 974, 974, 999, 974, 974, 974, 974, 1000, 1001, 1001, + 1002, 1002, 1002, 1002, 974, 974, 1003, 1004, 1004, 1004, + 1005, 1006, 1006, 1006, 1006, 1006, 1006, 1006, 1006, 1006, + 974, 974, 974, 974, 974, 974, 1007, 1007, 248, 248, + 248, 248, 974, 974, 974, 974, 1008, 1008, 1008, 1008, + 1008, 261, 1009, 1010, 974, 974, 974, 974, 1011, 1011, + 270, 270, 270, 270, 974, 974, 974, 974, 974, 994, + 280, 280, 280, 280, 280, 974, 974, 974, 974, 995, + 290, 290, 290, 290, 290, 974, 974, 974, 974, 996, + + 300, 300, 300, 300, 300, 974, 997, 974, 974, 974, + 974, 998, 312, 312, 312, 312, 312, 974, 974, 974, + 974, 999, 322, 322, 322, 322, 322, 974, 974, 974, + 974, 1000, 332, 332, 332, 332, 332, 1003, 1005, 1006, + 1006, 1006, 1006, 1006, 1006, 1006, 974, 974, 974, 974, + 974, 974, 1012, 248, 354, 974, 1013, 974, 974, 1014, + 261, 974, 974, 974, 974, 1015, 270, 367, 974, 1016, + 974, 974, 974, 974, 974, 280, 974, 974, 974, 974, + 1017, 290, 382, 974, 1018, 974, 974, 974, 974, 1019, + 1020, 1020, 974, 1021, 974, 974, 974, 974, 974, 974, + + 1022, 1023, 1023, 974, 1024, 974, 974, 974, 1025, 974, + 974, 974, 974, 1026, 1027, 1027, 974, 1028, 1029, 1030, + 1030, 1030, 1030, 1030, 1030, 974, 974, 974, 974, 974, + 1031, 1031, 432, 432, 432, 432, 1032, 1032, 438, 438, + 1033, 974, 974, 974, 1033, 445, 445, 445, 445, 445, + 1034, 974, 452, 452, 974, 974, 974, 974, 1035, 1035, + 460, 460, 460, 460, 1036, 1036, 466, 466, 1037, 974, + 974, 974, 1037, 473, 473, 473, 473, 473, 974, 1038, + 974, 974, 974, 974, 1039, 1039, 486, 486, 486, 486, + 1040, 1040, 492, 492, 1041, 974, 974, 974, 1041, 499, + + 499, 499, 499, 499, 974, 974, 974, 974, 1042, 1042, + 510, 510, 510, 510, 1043, 1043, 516, 516, 1044, 974, + 974, 974, 1044, 523, 523, 523, 523, 523, 974, 974, + 974, 974, 1045, 1045, 534, 534, 534, 534, 1046, 1046, + 540, 540, 1047, 974, 974, 974, 1047, 547, 547, 547, + 547, 547, 974, 1048, 974, 974, 974, 974, 1049, 1049, + 560, 560, 560, 560, 1050, 1050, 566, 566, 1051, 974, + 974, 974, 1051, 573, 573, 573, 573, 573, 1052, 1053, + 1053, 1053, 1053, 974, 974, 974, 1054, 1055, 1055, 589, + 589, 974, 1056, 974, 974, 974, 974, 1057, 1058, 1058, + + 974, 1059, 1060, 1060, 604, 604, 606, 974, 1061, 974, + 1059, 1062, 1062, 1061, 974, 974, 1063, 1063, 618, 974, + 974, 974, 1064, 1065, 1065, 625, 625, 974, 1066, 974, + 974, 974, 1067, 1068, 1068, 635, 635, 974, 1069, 974, + 974, 974, 974, 1070, 1071, 1071, 974, 1072, 1073, 1073, + 650, 650, 652, 974, 1074, 974, 1072, 1075, 1075, 1074, + 974, 974, 1076, 1076, 664, 974, 974, 974, 1077, 1078, + 1078, 671, 671, 974, 1079, 1080, 1081, 1081, 1081, 1081, + 974, 1082, 1083, 974, 1084, 974, 974, 974, 974, 1085, + 1085, 691, 691, 691, 691, 1086, 1086, 697, 697, 974, + + 974, 974, 1087, 1087, 704, 704, 704, 704, 1088, 1088, + 710, 710, 1089, 974, 974, 974, 1089, 717, 717, 717, + 717, 717, 974, 1090, 1090, 725, 725, 974, 1091, 1092, + 974, 1093, 974, 1094, 1095, 974, 1096, 974, 974, 974, + 974, 1097, 1097, 743, 743, 743, 743, 1098, 1098, 749, + 749, 974, 974, 974, 1099, 1099, 756, 756, 756, 756, + 1100, 1100, 762, 762, 1101, 974, 974, 974, 1101, 769, + 769, 769, 769, 769, 974, 1102, 1102, 777, 777, 974, + 1103, 1104, 974, 1079, 1080, 1081, 1081, 1081, 974, 974, + 1082, 791, 791, 1083, 794, 794, 974, 974, 1105, 1105, + + 800, 974, 974, 974, 1106, 1107, 1107, 807, 807, 974, + 1108, 1109, 1109, 813, 813, 974, 1110, 974, 974, 1111, + 1111, 821, 821, 974, 974, 1112, 1112, 827, 1113, 1113, + 830, 974, 974, 1114, 1114, 835, 974, 974, 1115, 1115, + 840, 1116, 1116, 843, 974, 974, 1117, 1117, 848, 974, + 974, 974, 1118, 1119, 1119, 855, 855, 974, 1120, 1121, + 1121, 861, 861, 974, 1122, 974, 974, 1123, 1123, 869, + 869, 974, 974, 1124, 1124, 875, 1125, 1125, 878, 974, + 974, 1126, 1126, 883, 1127, 1128, 1128, 974, 1129, 1130, + 974, 1131, 1132, 974, 1133, 1134, 974, 1118, 855, 974, + + 1120, 861, 974, 1122, 869, 1127, 1128, 1128, 974, 974, + 1129, 911, 911, 1130, 914, 914, 974, 974, 1131, 919, + 919, 1132, 922, 922, 974, 974, 1133, 927, 927, 1134, + 930, 930, 974, 974, 898, 898, 898, 855, 855, 857, + 974, 851, 901, 901, 901, 861, 861, 863, 974, 867, + 904, 904, 904, 869, 869, 871, 1127, 1128, 1128, 1127, + 1128, 1127, 1127, 1135, 1135, 1135, 974, 1135, 974, 1136, + 1136, 1136, 1136, 0, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974 + } ; + +static yyconst short int yy_nxt[8306] = + { 0, + 974, 47, 48, 47, 974, 974, 49, 47, 48, 47, + 742, 745, 49, 46, 47, 48, 47, 50, 46, 51, + 46, 46, 46, 52, 52, 52, 52, 50, 50, 53, + 54, 50, 55, 50, 50, 56, 50, 57, 58, 50, + 59, 60, 50, 50, 46, 46, 46, 50, 61, 62, + 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, + 47, 48, 47, 147, 148, 51, 47, 48, 47, 581, + 451, 51, 451, 582, 128, 129, 128, 63, 64, 130, + 131, 974, 131, 63, 64, 132, 65, 153, 154, 154, + 154, 154, 65, 47, 48, 47, 264, 974, 51, 338, + + 66, 67, 68, 68, 68, 68, 155, 155, 155, 155, + 307, 64, 69, 70, 71, 71, 71, 71, 69, 70, + 71, 71, 71, 71, 72, 46, 73, 74, 74, 74, + 72, 46, 73, 74, 74, 74, 75, 46, 76, 77, + 77, 77, 75, 46, 76, 77, 77, 77, 78, 79, + 80, 80, 80, 80, 78, 79, 80, 80, 80, 80, + 47, 48, 47, 264, 82, 83, 47, 48, 47, 961, + 82, 83, 85, 86, 87, 87, 87, 87, 84, 158, + 159, 159, 159, 159, 84, 85, 86, 87, 87, 87, + 87, 88, 89, 90, 90, 90, 90, 88, 89, 90, + + 90, 90, 90, 91, 92, 93, 93, 93, 93, 91, + 92, 93, 93, 93, 93, 94, 95, 96, 96, 96, + 96, 257, 959, 120, 48, 120, 97, 121, 122, 120, + 48, 120, 958, 121, 122, 257, 908, 257, 98, 257, + 99, 94, 95, 96, 96, 96, 96, 907, 134, 129, + 134, 257, 97, 135, 123, 257, 887, 120, 48, 120, + 123, 124, 122, 886, 98, 788, 99, 100, 101, 102, + 102, 102, 102, 742, 745, 120, 48, 120, 97, 124, + 122, 134, 129, 134, 742, 745, 135, 787, 123, 786, + 98, 680, 99, 100, 101, 102, 102, 102, 102, 160, + + 160, 160, 160, 131, 97, 131, 123, 679, 132, 136, + 158, 159, 159, 159, 159, 678, 98, 677, 99, 103, + 46, 104, 105, 105, 105, 161, 161, 161, 161, 583, + 97, 580, 125, 46, 126, 127, 127, 127, 165, 165, + 165, 165, 98, 46, 99, 103, 46, 104, 105, 105, + 105, 165, 165, 165, 165, 426, 97, 425, 125, 46, + 126, 127, 127, 127, 169, 169, 169, 169, 98, 46, + 99, 106, 107, 108, 108, 108, 108, 167, 168, 168, + 168, 168, 97, 165, 165, 165, 165, 134, 129, 134, + 424, 133, 174, 423, 98, 422, 99, 106, 107, 108, + + 108, 108, 108, 166, 178, 178, 178, 178, 97, 176, + 177, 177, 177, 177, 176, 177, 177, 177, 177, 166, + 98, 421, 99, 47, 48, 47, 420, 110, 111, 179, + 180, 180, 180, 180, 181, 181, 181, 181, 755, 758, + 348, 112, 184, 185, 185, 185, 185, 186, 186, 186, + 186, 755, 758, 98, 347, 99, 47, 48, 47, 346, + 110, 111, 189, 190, 190, 190, 190, 191, 191, 191, + 191, 755, 758, 345, 112, 195, 196, 196, 196, 196, + 197, 197, 197, 197, 769, 772, 98, 344, 99, 113, + 114, 115, 115, 115, 115, 195, 196, 196, 196, 196, + + 97, 198, 198, 198, 198, 198, 198, 198, 198, 769, + 772, 343, 98, 342, 99, 113, 114, 115, 115, 115, + 115, 200, 201, 201, 201, 201, 97, 198, 198, 198, + 198, 202, 202, 202, 202, 769, 772, 341, 98, 340, + 99, 116, 117, 118, 118, 118, 118, 199, 242, 134, + 129, 134, 97, 133, 207, 209, 210, 210, 210, 210, + 220, 129, 220, 199, 98, 221, 99, 116, 117, 118, + 118, 118, 118, 211, 211, 211, 211, 241, 97, 133, + 240, 133, 214, 215, 215, 215, 215, 239, 238, 237, + 98, 236, 99, 156, 156, 156, 235, 234, 157, 233, + + 232, 153, 154, 154, 154, 154, 162, 162, 162, 225, + 208, 163, 194, 175, 152, 161, 161, 161, 161, 216, + 216, 216, 216, 223, 129, 223, 151, 133, 224, 226, + 226, 226, 226, 150, 149, 164, 226, 226, 226, 226, + 226, 226, 226, 226, 128, 129, 128, 146, 145, 130, + 144, 164, 170, 170, 170, 143, 227, 171, 142, 141, + 167, 168, 168, 168, 168, 182, 182, 182, 140, 139, + 183, 974, 227, 179, 180, 180, 180, 180, 187, 187, + 187, 974, 974, 188, 974, 974, 184, 185, 185, 185, + 185, 192, 192, 192, 974, 974, 193, 974, 974, 189, + + 190, 190, 190, 190, 203, 203, 203, 974, 974, 204, + 974, 974, 200, 201, 201, 201, 201, 212, 212, 212, + 974, 974, 213, 974, 974, 209, 210, 210, 210, 210, + 217, 217, 217, 974, 974, 218, 974, 974, 214, 215, + 215, 215, 215, 134, 129, 134, 974, 131, 135, 131, + 974, 229, 132, 229, 974, 974, 230, 134, 129, 134, + 974, 974, 135, 134, 129, 134, 974, 974, 135, 134, + 129, 134, 974, 974, 135, 134, 129, 134, 974, 974, + 135, 155, 155, 155, 155, 160, 160, 160, 160, 158, + 159, 159, 159, 159, 165, 165, 165, 165, 974, 231, + + 156, 156, 156, 974, 974, 157, 974, 974, 974, 155, + 155, 155, 155, 162, 162, 162, 243, 974, 163, 169, + 169, 169, 169, 974, 974, 974, 160, 160, 160, 160, + 974, 974, 974, 253, 243, 156, 156, 156, 974, 974, + 157, 974, 244, 245, 246, 246, 246, 246, 248, 156, + 248, 253, 974, 249, 974, 250, 251, 252, 252, 252, + 252, 162, 162, 162, 974, 974, 163, 974, 254, 974, + 255, 256, 256, 256, 258, 162, 258, 974, 974, 259, + 974, 260, 974, 261, 262, 262, 262, 170, 170, 170, + 974, 974, 171, 974, 974, 974, 169, 169, 169, 169, + + 134, 129, 134, 265, 133, 174, 134, 129, 134, 974, + 133, 174, 178, 178, 178, 178, 176, 177, 177, 177, + 177, 265, 170, 170, 170, 974, 974, 171, 974, 266, + 267, 268, 268, 268, 268, 270, 170, 270, 974, 974, + 271, 974, 272, 273, 274, 274, 274, 274, 178, 178, + 178, 178, 974, 974, 974, 275, 181, 181, 181, 181, + 186, 186, 186, 186, 191, 191, 191, 191, 197, 197, + 197, 197, 974, 275, 182, 182, 182, 974, 974, 183, + 974, 974, 974, 181, 181, 181, 181, 974, 974, 974, + 276, 195, 196, 196, 196, 196, 198, 198, 198, 198, + + 197, 197, 197, 197, 974, 974, 974, 306, 276, 182, + 182, 182, 974, 974, 183, 974, 277, 278, 279, 279, + 279, 279, 281, 182, 281, 306, 974, 282, 974, 283, + 284, 285, 285, 285, 285, 187, 187, 187, 974, 974, + 188, 974, 974, 974, 186, 186, 186, 186, 974, 974, + 974, 286, 202, 202, 202, 202, 974, 134, 129, 134, + 974, 133, 207, 211, 211, 211, 211, 974, 974, 286, + 187, 187, 187, 974, 974, 188, 974, 287, 288, 289, + 289, 289, 289, 291, 187, 291, 974, 133, 292, 133, + 293, 294, 295, 295, 295, 295, 192, 192, 192, 974, + + 974, 193, 974, 974, 974, 191, 191, 191, 191, 974, + 974, 974, 296, 216, 216, 216, 216, 974, 134, 129, + 134, 974, 133, 207, 220, 129, 220, 974, 974, 221, + 296, 192, 192, 192, 974, 974, 193, 974, 297, 298, + 299, 299, 299, 299, 301, 192, 301, 974, 133, 302, + 133, 303, 304, 305, 305, 305, 305, 203, 203, 203, + 974, 974, 204, 974, 974, 974, 202, 202, 202, 202, + 223, 129, 223, 308, 133, 224, 223, 129, 223, 974, + 133, 224, 223, 129, 223, 974, 133, 224, 974, 974, + 974, 308, 203, 203, 203, 974, 974, 204, 974, 309, + + 310, 311, 311, 311, 311, 313, 203, 313, 974, 974, + 314, 974, 315, 316, 317, 317, 317, 317, 212, 212, + 212, 974, 974, 213, 974, 974, 974, 211, 211, 211, + 211, 223, 129, 223, 318, 133, 224, 226, 226, 226, + 226, 229, 229, 229, 229, 974, 230, 230, 351, 351, + 351, 351, 318, 212, 212, 212, 974, 974, 213, 974, + 319, 320, 321, 321, 321, 321, 323, 212, 323, 974, + 974, 324, 974, 325, 326, 327, 327, 327, 327, 217, + 217, 217, 974, 974, 218, 974, 974, 214, 215, 215, + 215, 215, 217, 217, 217, 974, 974, 218, 974, 974, + + 974, 216, 216, 216, 216, 229, 974, 229, 328, 974, + 230, 134, 129, 134, 349, 349, 135, 350, 350, 350, + 350, 245, 246, 246, 246, 246, 328, 217, 217, 217, + 974, 339, 218, 974, 329, 330, 331, 331, 331, 331, + 333, 217, 333, 974, 974, 334, 974, 335, 336, 337, + 337, 337, 337, 352, 352, 352, 974, 974, 353, 974, + 974, 245, 246, 246, 246, 246, 248, 156, 248, 974, + 974, 249, 974, 250, 251, 252, 252, 252, 252, 248, + 156, 248, 974, 974, 249, 974, 250, 251, 252, 252, + 252, 252, 354, 354, 354, 354, 355, 356, 355, 358, + + 358, 357, 359, 359, 359, 359, 256, 256, 256, 256, + 256, 256, 256, 256, 256, 256, 256, 256, 162, 162, + 162, 362, 362, 163, 363, 363, 363, 363, 974, 974, + 360, 267, 268, 268, 268, 268, 364, 364, 364, 364, + 367, 367, 367, 367, 974, 974, 360, 258, 162, 258, + 974, 974, 259, 974, 260, 974, 261, 262, 262, 262, + 258, 162, 258, 974, 974, 259, 974, 260, 974, 261, + 262, 262, 262, 258, 162, 258, 974, 974, 259, 974, + 260, 974, 261, 262, 262, 262, 258, 162, 258, 974, + 974, 259, 974, 260, 974, 261, 262, 262, 262, 258, + + 162, 258, 974, 974, 259, 974, 260, 974, 261, 262, + 262, 262, 368, 369, 368, 371, 371, 370, 372, 372, + 372, 372, 375, 375, 375, 375, 373, 373, 361, 374, + 374, 374, 374, 278, 279, 279, 279, 279, 278, 279, + 279, 279, 279, 974, 361, 365, 365, 365, 974, 974, + 366, 974, 974, 267, 268, 268, 268, 268, 270, 170, + 270, 974, 974, 271, 974, 272, 273, 274, 274, 274, + 274, 270, 170, 270, 974, 974, 271, 974, 272, 273, + 274, 274, 274, 274, 281, 182, 281, 974, 974, 282, + 974, 283, 284, 285, 285, 285, 285, 376, 376, 376, + + 376, 377, 377, 974, 378, 378, 378, 378, 288, 289, + 289, 289, 289, 379, 379, 379, 379, 380, 380, 380, + 974, 974, 381, 974, 974, 288, 289, 289, 289, 289, + 291, 187, 291, 974, 974, 292, 974, 293, 294, 295, + 295, 295, 295, 382, 382, 382, 382, 383, 384, 383, + 386, 386, 385, 387, 387, 387, 387, 298, 299, 299, + 299, 299, 388, 388, 388, 388, 389, 389, 389, 974, + 974, 390, 974, 974, 298, 299, 299, 299, 299, 301, + 192, 301, 974, 974, 302, 974, 303, 304, 305, 305, + 305, 305, 391, 391, 391, 391, 392, 393, 392, 395, + + 395, 394, 396, 396, 396, 396, 397, 397, 974, 398, + 398, 398, 398, 310, 311, 311, 311, 311, 399, 399, + 399, 399, 400, 400, 400, 974, 974, 401, 974, 974, + 310, 311, 311, 311, 311, 313, 203, 313, 974, 974, + 314, 974, 315, 316, 317, 317, 317, 317, 402, 402, + 402, 402, 403, 404, 403, 406, 406, 405, 407, 407, + 407, 407, 320, 321, 321, 321, 321, 408, 408, 408, + 408, 320, 321, 321, 321, 321, 323, 212, 323, 974, + 974, 324, 974, 325, 326, 327, 327, 327, 327, 409, + 409, 409, 409, 410, 410, 974, 411, 411, 411, 411, + + 330, 331, 331, 331, 331, 412, 412, 412, 412, 413, + 413, 413, 974, 974, 414, 974, 974, 330, 331, 331, + 331, 331, 333, 217, 333, 974, 974, 334, 974, 335, + 336, 337, 337, 337, 337, 415, 415, 415, 415, 416, + 417, 416, 974, 974, 418, 134, 129, 134, 974, 974, + 135, 350, 350, 350, 350, 359, 359, 359, 359, 359, + 359, 359, 359, 974, 419, 156, 156, 156, 974, 974, + 157, 974, 974, 974, 350, 350, 350, 350, 352, 352, + 352, 974, 974, 353, 974, 974, 974, 351, 351, 351, + 351, 974, 974, 974, 427, 363, 363, 363, 363, 372, + + 372, 372, 372, 372, 372, 372, 372, 374, 374, 374, + 374, 974, 427, 352, 352, 352, 974, 974, 353, 974, + 428, 429, 430, 430, 430, 430, 432, 352, 432, 974, + 974, 433, 974, 434, 435, 436, 436, 436, 436, 355, + 356, 355, 974, 974, 357, 974, 974, 974, 354, 354, + 354, 354, 974, 974, 974, 437, 375, 375, 375, 375, + 974, 974, 974, 479, 376, 376, 376, 376, 974, 974, + 974, 480, 974, 437, 438, 439, 440, 440, 440, 440, + 974, 479, 974, 247, 378, 378, 378, 378, 974, 480, + 387, 387, 387, 387, 396, 396, 396, 396, 974, 974, + + 974, 247, 356, 356, 356, 974, 974, 441, 974, 442, + 443, 444, 444, 444, 444, 446, 356, 446, 974, 974, + 447, 974, 448, 449, 450, 450, 450, 450, 452, 453, + 453, 453, 454, 454, 454, 454, 454, 396, 396, 396, + 396, 398, 398, 398, 398, 134, 129, 579, 257, 974, + 135, 974, 454, 454, 454, 407, 407, 407, 407, 411, + 411, 411, 411, 974, 257, 170, 170, 170, 974, 974, + 171, 974, 974, 974, 363, 363, 363, 363, 365, 365, + 365, 974, 974, 366, 974, 974, 974, 364, 364, 364, + 364, 974, 584, 584, 455, 585, 585, 585, 585, 429, + + 430, 430, 430, 430, 408, 408, 408, 408, 974, 974, + 974, 553, 455, 365, 365, 365, 974, 974, 366, 974, + 456, 457, 458, 458, 458, 458, 460, 365, 460, 553, + 974, 461, 974, 462, 463, 464, 464, 464, 464, 368, + 369, 368, 974, 974, 370, 974, 974, 974, 367, 367, + 367, 367, 974, 974, 974, 465, 586, 586, 586, 586, + 429, 430, 430, 430, 430, 587, 587, 587, 587, 592, + 592, 592, 592, 465, 466, 467, 468, 468, 468, 468, + 974, 974, 974, 269, 251, 591, 591, 591, 591, 355, + 356, 355, 974, 974, 357, 443, 444, 444, 444, 444, + + 974, 269, 369, 369, 369, 974, 974, 469, 974, 470, + 471, 472, 472, 472, 472, 474, 369, 474, 974, 974, + 475, 974, 476, 477, 478, 478, 478, 478, 182, 182, + 182, 974, 974, 183, 974, 974, 974, 374, 374, 374, + 374, 187, 187, 187, 974, 974, 188, 974, 974, 974, + 378, 378, 378, 378, 380, 380, 380, 974, 974, 381, + 974, 974, 974, 379, 379, 379, 379, 974, 974, 974, + 481, 593, 593, 593, 593, 594, 594, 974, 595, 595, + 595, 595, 457, 458, 458, 458, 458, 974, 481, 380, + 380, 380, 974, 974, 381, 974, 482, 483, 484, 484, + + 484, 484, 486, 380, 486, 974, 974, 487, 974, 488, + 489, 490, 490, 490, 490, 383, 384, 383, 974, 974, + 385, 974, 974, 974, 382, 382, 382, 382, 974, 974, + 974, 491, 596, 596, 596, 596, 599, 599, 599, 599, + 600, 601, 600, 974, 974, 602, 974, 974, 974, 491, + 492, 493, 494, 494, 494, 494, 974, 974, 974, 290, + 273, 606, 606, 606, 606, 607, 608, 607, 974, 974, + 609, 471, 472, 472, 472, 472, 974, 290, 384, 384, + 384, 974, 974, 495, 974, 496, 497, 498, 498, 498, + 498, 500, 384, 500, 974, 974, 501, 974, 502, 503, + + 504, 504, 504, 504, 192, 192, 192, 974, 974, 193, + 974, 974, 974, 387, 387, 387, 387, 389, 389, 389, + 974, 974, 390, 974, 974, 974, 388, 388, 388, 388, + 974, 974, 974, 505, 610, 610, 610, 610, 612, 612, + 612, 612, 613, 608, 613, 974, 974, 614, 974, 974, + 974, 505, 389, 389, 389, 974, 974, 390, 974, 506, + 507, 508, 508, 508, 508, 510, 389, 510, 974, 974, + 511, 974, 512, 513, 514, 514, 514, 514, 392, 393, + 392, 974, 974, 394, 974, 303, 304, 391, 391, 391, + 391, 974, 615, 615, 515, 616, 616, 616, 616, 620, + + 620, 974, 621, 621, 621, 621, 483, 484, 484, 484, + 484, 974, 515, 392, 393, 392, 974, 974, 394, 974, + 516, 517, 518, 518, 518, 518, 393, 393, 393, 974, + 974, 519, 974, 520, 521, 522, 522, 522, 522, 524, + 393, 524, 974, 974, 525, 974, 526, 527, 528, 528, + 528, 528, 203, 203, 203, 974, 974, 204, 974, 974, + 974, 398, 398, 398, 398, 400, 400, 400, 974, 974, + 401, 974, 974, 974, 399, 399, 399, 399, 974, 974, + 974, 529, 622, 622, 622, 622, 483, 484, 484, 484, + 484, 623, 623, 623, 623, 628, 628, 628, 628, 529, + + 400, 400, 400, 974, 974, 401, 974, 530, 531, 532, + 532, 532, 532, 534, 400, 534, 974, 974, 535, 974, + 536, 537, 538, 538, 538, 538, 403, 404, 403, 974, + 974, 405, 974, 315, 316, 402, 402, 402, 402, 974, + 974, 974, 539, 294, 627, 627, 627, 627, 383, 384, + 383, 974, 974, 385, 497, 498, 498, 498, 498, 974, + 539, 403, 404, 403, 974, 974, 405, 974, 540, 541, + 542, 542, 542, 542, 404, 404, 404, 974, 974, 543, + 974, 544, 545, 546, 546, 546, 546, 548, 404, 548, + 974, 974, 549, 974, 550, 551, 552, 552, 552, 552, + + 212, 212, 212, 974, 974, 213, 974, 974, 974, 407, + 407, 407, 407, 323, 212, 323, 974, 974, 324, 974, + 325, 326, 409, 409, 409, 409, 974, 974, 974, 554, + 629, 629, 629, 629, 630, 630, 974, 631, 631, 631, + 631, 507, 508, 508, 508, 508, 974, 554, 217, 217, + 217, 974, 974, 218, 974, 974, 974, 411, 411, 411, + 411, 413, 413, 413, 974, 974, 414, 974, 974, 974, + 412, 412, 412, 412, 974, 974, 974, 555, 632, 632, + 632, 632, 507, 508, 508, 508, 508, 633, 633, 633, + 633, 638, 638, 638, 638, 555, 413, 413, 413, 974, + + 974, 414, 974, 556, 557, 558, 558, 558, 558, 560, + 413, 560, 974, 974, 561, 974, 562, 563, 564, 564, + 564, 564, 416, 417, 416, 974, 974, 418, 974, 335, + 336, 415, 415, 415, 415, 974, 974, 974, 565, 304, + 637, 637, 637, 637, 392, 393, 392, 974, 974, 394, + 521, 522, 522, 522, 522, 974, 565, 416, 417, 416, + 974, 974, 418, 974, 566, 567, 568, 568, 568, 568, + 417, 417, 417, 974, 974, 569, 974, 570, 571, 572, + 572, 572, 572, 574, 417, 574, 974, 974, 575, 974, + 576, 577, 578, 578, 578, 578, 432, 352, 432, 974, + + 974, 433, 974, 434, 435, 436, 436, 436, 436, 432, + 352, 432, 974, 974, 433, 974, 434, 435, 436, 436, + 436, 436, 248, 156, 248, 974, 974, 249, 588, 589, + 251, 590, 590, 590, 590, 248, 156, 248, 974, 974, + 249, 974, 250, 439, 440, 440, 440, 440, 446, 356, + 446, 974, 974, 447, 974, 448, 449, 450, 450, 450, + 450, 352, 352, 352, 974, 974, 353, 974, 974, 443, + 444, 444, 444, 444, 446, 356, 446, 974, 974, 447, + 974, 448, 449, 450, 450, 450, 450, 257, 258, 162, + 258, 257, 257, 259, 257, 260, 257, 452, 453, 453, + + 453, 454, 454, 454, 454, 454, 257, 257, 257, 257, + 257, 257, 257, 257, 257, 257, 257, 361, 257, 257, + 257, 454, 454, 454, 257, 257, 257, 257, 257, 257, + 257, 257, 257, 361, 597, 597, 597, 974, 974, 598, + 974, 974, 457, 458, 458, 458, 458, 460, 365, 460, + 974, 974, 461, 974, 462, 463, 464, 464, 464, 464, + 460, 365, 460, 974, 974, 461, 974, 462, 463, 464, + 464, 464, 464, 270, 170, 270, 974, 974, 271, 603, + 604, 273, 605, 605, 605, 605, 270, 170, 270, 974, + 974, 271, 974, 272, 467, 468, 468, 468, 468, 474, + + 369, 474, 974, 974, 475, 974, 476, 477, 478, 478, + 478, 478, 601, 601, 601, 974, 974, 611, 974, 974, + 471, 472, 472, 472, 472, 474, 369, 474, 974, 974, + 475, 974, 476, 477, 478, 478, 478, 478, 281, 182, + 281, 974, 974, 282, 617, 618, 284, 619, 619, 619, + 619, 486, 380, 486, 974, 974, 487, 974, 488, 489, + 490, 490, 490, 490, 486, 380, 486, 974, 974, 487, + 974, 488, 489, 490, 490, 490, 490, 291, 187, 291, + 974, 974, 292, 624, 625, 294, 626, 626, 626, 626, + 291, 187, 291, 974, 974, 292, 974, 293, 493, 494, + + 494, 494, 494, 500, 384, 500, 974, 974, 501, 974, + 502, 503, 504, 504, 504, 504, 380, 380, 380, 974, + 974, 381, 974, 974, 497, 498, 498, 498, 498, 500, + 384, 500, 974, 974, 501, 974, 502, 503, 504, 504, + 504, 504, 510, 389, 510, 974, 974, 511, 974, 512, + 513, 514, 514, 514, 514, 510, 389, 510, 974, 974, + 511, 974, 512, 513, 514, 514, 514, 514, 301, 192, + 301, 974, 974, 302, 634, 635, 304, 636, 636, 636, + 636, 301, 192, 301, 974, 974, 302, 974, 303, 517, + 518, 518, 518, 518, 524, 393, 524, 974, 974, 525, + + 974, 526, 527, 528, 528, 528, 528, 389, 389, 389, + 974, 974, 390, 974, 974, 521, 522, 522, 522, 522, + 524, 393, 524, 974, 974, 525, 974, 526, 527, 528, + 528, 528, 528, 639, 639, 639, 639, 640, 640, 974, + 641, 641, 641, 641, 531, 532, 532, 532, 532, 642, + 642, 642, 642, 643, 643, 643, 974, 974, 644, 974, + 974, 531, 532, 532, 532, 532, 534, 400, 534, 974, + 974, 535, 974, 536, 537, 538, 538, 538, 538, 534, + 400, 534, 974, 974, 535, 974, 536, 537, 538, 538, + 538, 538, 645, 645, 645, 645, 646, 647, 646, 974, + + 974, 648, 313, 203, 313, 974, 974, 314, 649, 650, + 316, 651, 651, 651, 651, 313, 203, 313, 974, 974, + 314, 974, 315, 541, 542, 542, 542, 542, 316, 652, + 652, 652, 652, 653, 654, 653, 974, 974, 655, 548, + 404, 548, 974, 974, 549, 974, 550, 551, 552, 552, + 552, 552, 545, 546, 546, 546, 546, 656, 656, 656, + 656, 647, 647, 647, 974, 974, 657, 974, 974, 545, + 546, 546, 546, 546, 548, 404, 548, 974, 974, 549, + 974, 550, 551, 552, 552, 552, 552, 658, 658, 658, + 658, 659, 654, 659, 661, 661, 660, 662, 662, 662, + + 662, 323, 212, 323, 974, 974, 324, 663, 664, 326, + 665, 665, 665, 665, 666, 666, 974, 667, 667, 667, + 667, 557, 558, 558, 558, 558, 668, 668, 668, 668, + 557, 558, 558, 558, 558, 560, 413, 560, 974, 974, + 561, 974, 562, 563, 564, 564, 564, 564, 560, 413, + 560, 974, 974, 561, 974, 562, 563, 564, 564, 564, + 564, 669, 669, 669, 669, 333, 217, 333, 974, 974, + 334, 670, 671, 336, 672, 672, 672, 672, 333, 217, + 333, 974, 974, 334, 974, 335, 567, 568, 568, 568, + 568, 336, 673, 673, 673, 673, 416, 417, 416, 974, + + 974, 418, 574, 417, 574, 974, 974, 575, 974, 576, + 577, 578, 578, 578, 578, 571, 572, 572, 572, 572, + 674, 674, 674, 674, 413, 413, 413, 974, 974, 414, + 974, 974, 571, 572, 572, 572, 572, 574, 417, 574, + 974, 974, 575, 974, 576, 577, 578, 578, 578, 578, + 675, 675, 675, 675, 134, 129, 134, 974, 974, 135, + 585, 585, 585, 585, 586, 586, 586, 586, 355, 356, + 355, 681, 974, 357, 595, 595, 595, 595, 616, 616, + 616, 616, 676, 352, 352, 352, 974, 974, 353, 681, + 974, 974, 585, 585, 585, 585, 432, 352, 432, 974, + + 974, 433, 974, 434, 435, 587, 587, 587, 587, 368, + 369, 368, 682, 974, 370, 616, 616, 616, 616, 621, + 621, 621, 621, 383, 384, 383, 974, 974, 385, 974, + 682, 248, 156, 248, 974, 974, 249, 974, 250, 251, + 590, 590, 590, 590, 248, 156, 248, 974, 974, 249, + 974, 250, 251, 590, 590, 590, 590, 355, 356, 355, + 974, 974, 357, 974, 974, 974, 591, 591, 591, 591, + 974, 974, 974, 683, 622, 622, 622, 622, 974, 974, + 974, 728, 631, 631, 631, 631, 641, 641, 641, 641, + 974, 683, 352, 352, 352, 974, 974, 353, 974, 728, + + 974, 592, 592, 592, 592, 392, 393, 392, 684, 974, + 394, 662, 662, 662, 662, 632, 632, 632, 632, 403, + 404, 403, 733, 974, 405, 974, 684, 446, 356, 446, + 974, 974, 447, 974, 448, 449, 593, 593, 593, 593, + 733, 974, 974, 685, 662, 662, 662, 662, 667, 667, + 667, 667, 974, 668, 668, 668, 668, 974, 974, 974, + 780, 685, 365, 365, 365, 974, 974, 366, 974, 974, + 974, 595, 595, 595, 595, 597, 597, 597, 780, 974, + 598, 974, 974, 974, 596, 596, 596, 596, 416, 417, + 416, 686, 974, 418, 134, 129, 134, 789, 789, 135, + + 790, 790, 790, 790, 974, 785, 974, 974, 974, 686, + 597, 597, 597, 974, 974, 598, 974, 687, 688, 689, + 689, 689, 689, 691, 597, 691, 974, 974, 692, 974, + 693, 694, 695, 695, 695, 695, 600, 601, 600, 974, + 974, 602, 974, 462, 463, 599, 599, 599, 599, 974, + 797, 797, 696, 798, 798, 798, 798, 802, 802, 974, + 803, 803, 803, 803, 688, 689, 689, 689, 689, 974, + 696, 600, 601, 600, 974, 974, 602, 974, 697, 698, + 699, 699, 699, 699, 601, 601, 601, 974, 974, 611, + 974, 700, 701, 702, 702, 702, 702, 704, 601, 704, + + 974, 974, 705, 974, 706, 707, 708, 708, 708, 708, + 270, 170, 270, 974, 974, 271, 974, 272, 273, 605, + 605, 605, 605, 270, 170, 270, 974, 974, 271, 974, + 272, 273, 605, 605, 605, 605, 607, 608, 607, 974, + 974, 609, 974, 974, 974, 606, 606, 606, 606, 974, + 974, 974, 709, 804, 804, 804, 804, 688, 689, 689, + 689, 689, 805, 805, 805, 805, 810, 810, 810, 810, + 709, 710, 711, 712, 712, 712, 712, 974, 974, 974, + 269, 463, 809, 809, 809, 809, 600, 601, 600, 974, + 974, 602, 701, 702, 702, 702, 702, 974, 269, 608, + + 608, 608, 974, 974, 713, 974, 714, 715, 716, 716, + 716, 716, 718, 608, 718, 974, 974, 719, 974, 720, + 721, 722, 722, 722, 722, 601, 601, 601, 974, 974, + 611, 974, 974, 974, 610, 610, 610, 610, 974, 974, + 974, 723, 811, 811, 811, 811, 273, 815, 815, 815, + 815, 607, 608, 607, 974, 974, 609, 974, 974, 723, + 704, 601, 704, 974, 974, 705, 974, 706, 707, 708, + 708, 708, 708, 613, 608, 613, 974, 974, 614, 974, + 476, 477, 612, 612, 612, 612, 974, 974, 974, 724, + 715, 716, 716, 716, 716, 816, 816, 816, 816, 817, + + 817, 817, 817, 852, 852, 852, 852, 724, 613, 608, + 613, 974, 974, 614, 974, 725, 726, 727, 727, 727, + 727, 718, 608, 718, 974, 974, 719, 974, 720, 721, + 722, 722, 722, 722, 281, 182, 281, 974, 974, 282, + 974, 283, 284, 619, 619, 619, 619, 281, 182, 281, + 974, 974, 282, 974, 283, 284, 619, 619, 619, 619, + 380, 380, 380, 974, 974, 381, 974, 974, 974, 621, + 621, 621, 621, 486, 380, 486, 974, 974, 487, 974, + 488, 489, 623, 623, 623, 623, 974, 818, 818, 729, + 819, 819, 819, 819, 477, 823, 823, 823, 823, 613, + + 608, 613, 974, 974, 614, 974, 974, 729, 291, 187, + 291, 974, 974, 292, 974, 293, 294, 626, 626, 626, + 626, 291, 187, 291, 974, 974, 292, 974, 293, 294, + 626, 626, 626, 626, 383, 384, 383, 974, 974, 385, + 974, 974, 974, 627, 627, 627, 627, 974, 824, 824, + 730, 825, 825, 825, 825, 832, 832, 974, 833, 833, + 833, 833, 740, 741, 741, 741, 741, 974, 730, 380, + 380, 380, 974, 974, 381, 974, 974, 974, 628, 628, + 628, 628, 974, 837, 837, 731, 838, 838, 838, 838, + 845, 845, 974, 846, 846, 846, 846, 740, 741, 741, + + 741, 741, 974, 731, 500, 384, 500, 974, 974, 501, + 974, 502, 503, 629, 629, 629, 629, 974, 850, 850, + 732, 851, 851, 851, 851, 853, 853, 853, 853, 537, + 857, 857, 857, 857, 858, 858, 858, 858, 732, 389, + 389, 389, 974, 974, 390, 974, 974, 974, 631, 631, + 631, 631, 510, 389, 510, 974, 974, 511, 974, 512, + 513, 633, 633, 633, 633, 646, 647, 646, 734, 974, + 648, 753, 754, 754, 754, 754, 859, 859, 859, 859, + 316, 863, 863, 863, 863, 974, 734, 301, 192, 301, + 974, 974, 302, 974, 303, 304, 636, 636, 636, 636, + + 301, 192, 301, 974, 974, 302, 974, 303, 304, 636, + 636, 636, 636, 392, 393, 392, 974, 974, 394, 974, + 974, 974, 637, 637, 637, 637, 653, 654, 653, 735, + 974, 655, 767, 768, 768, 768, 768, 864, 864, 864, + 864, 865, 865, 865, 865, 974, 974, 735, 389, 389, + 389, 974, 974, 390, 974, 974, 974, 638, 638, 638, + 638, 974, 866, 866, 736, 867, 867, 867, 867, 551, + 871, 871, 871, 871, 659, 654, 659, 974, 974, 660, + 974, 974, 736, 524, 393, 524, 974, 974, 525, 974, + 526, 527, 639, 639, 639, 639, 974, 872, 872, 737, + + 873, 873, 873, 873, 880, 880, 974, 881, 881, 881, + 881, 790, 790, 790, 790, 974, 974, 737, 400, 400, + 400, 974, 974, 401, 974, 974, 974, 641, 641, 641, + 641, 643, 643, 643, 974, 974, 644, 974, 974, 974, + 642, 642, 642, 642, 134, 129, 134, 738, 974, 135, + 974, 974, 885, 790, 790, 790, 790, 355, 356, 355, + 974, 974, 357, 974, 974, 738, 643, 643, 643, 974, + 974, 644, 974, 739, 740, 741, 741, 741, 741, 743, + 643, 743, 974, 974, 744, 974, 745, 746, 747, 747, + 747, 747, 646, 647, 646, 974, 974, 648, 974, 536, + + 537, 645, 645, 645, 645, 974, 974, 974, 748, 798, + 798, 798, 798, 803, 803, 803, 803, 974, 804, 804, + 804, 804, 974, 974, 974, 888, 748, 646, 647, 646, + 974, 974, 648, 974, 749, 750, 751, 751, 751, 751, + 647, 647, 647, 888, 974, 657, 974, 752, 753, 754, + 754, 754, 754, 756, 647, 756, 974, 974, 757, 974, + 758, 759, 760, 760, 760, 760, 313, 203, 313, 974, + 974, 314, 974, 315, 316, 651, 651, 651, 651, 313, + 203, 313, 974, 974, 314, 974, 315, 316, 651, 651, + 651, 651, 653, 654, 653, 974, 974, 655, 974, 974, + + 974, 652, 652, 652, 652, 600, 601, 600, 761, 974, + 602, 607, 608, 607, 974, 974, 609, 819, 819, 819, + 819, 825, 825, 825, 825, 974, 761, 762, 763, 764, + 764, 764, 764, 613, 608, 613, 312, 974, 614, 825, + 825, 825, 825, 383, 384, 383, 974, 974, 385, 833, + 833, 833, 833, 974, 312, 654, 654, 654, 974, 974, + 765, 974, 766, 767, 768, 768, 768, 768, 770, 654, + 770, 974, 974, 771, 974, 772, 773, 774, 774, 774, + 774, 647, 647, 647, 974, 974, 657, 974, 974, 974, + 656, 656, 656, 656, 974, 974, 974, 775, 838, 838, + + 838, 838, 838, 838, 838, 838, 392, 393, 392, 974, + 974, 394, 974, 974, 974, 775, 756, 647, 756, 974, + 974, 757, 974, 758, 759, 760, 760, 760, 760, 659, + 654, 659, 974, 974, 660, 974, 550, 551, 658, 658, + 658, 658, 974, 974, 974, 776, 846, 846, 846, 846, + 851, 851, 851, 851, 974, 852, 852, 852, 852, 974, + 974, 974, 897, 776, 659, 654, 659, 974, 974, 660, + 974, 777, 778, 779, 779, 779, 779, 770, 654, 770, + 897, 974, 771, 974, 772, 773, 774, 774, 774, 774, + 323, 212, 323, 974, 974, 324, 974, 325, 326, 665, + + 665, 665, 665, 323, 212, 323, 974, 974, 324, 974, + 325, 326, 665, 665, 665, 665, 413, 413, 413, 974, + 974, 414, 974, 974, 974, 667, 667, 667, 667, 560, + 413, 560, 974, 974, 561, 974, 562, 563, 669, 669, + 669, 669, 646, 647, 646, 781, 974, 648, 653, 654, + 653, 974, 974, 655, 867, 867, 867, 867, 873, 873, + 873, 873, 974, 781, 333, 217, 333, 974, 974, 334, + 974, 335, 336, 672, 672, 672, 672, 333, 217, 333, + 974, 974, 334, 974, 335, 336, 672, 672, 672, 672, + 416, 417, 416, 974, 974, 418, 974, 974, 974, 673, + + 673, 673, 673, 659, 654, 659, 782, 974, 660, 873, + 873, 873, 873, 416, 417, 416, 974, 974, 418, 881, + 881, 881, 881, 974, 782, 413, 413, 413, 974, 974, + 414, 974, 974, 974, 674, 674, 674, 674, 134, 129, + 134, 783, 974, 135, 974, 909, 909, 906, 910, 910, + 910, 910, 917, 917, 974, 918, 918, 918, 918, 783, + 574, 417, 574, 974, 974, 575, 974, 576, 577, 675, + 675, 675, 675, 974, 925, 925, 784, 926, 926, 926, + 926, 933, 933, 974, 934, 934, 934, 934, 134, 129, + 957, 974, 974, 135, 784, 432, 352, 432, 974, 974, + + 433, 791, 792, 435, 793, 793, 793, 793, 248, 156, + 248, 974, 974, 249, 794, 795, 251, 796, 796, 796, + 796, 446, 356, 446, 974, 974, 447, 799, 800, 449, + 801, 801, 801, 801, 691, 597, 691, 974, 974, 692, + 974, 693, 694, 695, 695, 695, 695, 691, 597, 691, + 974, 974, 692, 974, 693, 694, 695, 695, 695, 695, + 460, 365, 460, 974, 974, 461, 806, 807, 463, 808, + 808, 808, 808, 460, 365, 460, 974, 974, 461, 974, + 462, 698, 699, 699, 699, 699, 597, 597, 597, 974, + 974, 598, 974, 974, 701, 702, 702, 702, 702, 704, + + 601, 704, 974, 974, 705, 974, 706, 707, 708, 708, + 708, 708, 704, 601, 704, 974, 974, 705, 974, 706, + 707, 708, 708, 708, 708, 270, 170, 270, 974, 974, + 271, 812, 813, 273, 814, 814, 814, 814, 270, 170, + 270, 974, 974, 271, 974, 272, 711, 712, 712, 712, + 712, 718, 608, 718, 974, 974, 719, 974, 720, 721, + 722, 722, 722, 722, 601, 601, 601, 974, 974, 611, + 974, 974, 715, 716, 716, 716, 716, 718, 608, 718, + 974, 974, 719, 974, 720, 721, 722, 722, 722, 722, + 474, 369, 474, 974, 974, 475, 820, 821, 477, 822, + + 822, 822, 822, 474, 369, 474, 974, 974, 475, 974, + 476, 726, 727, 727, 727, 727, 486, 380, 486, 974, + 974, 487, 826, 827, 489, 828, 828, 828, 828, 291, + 187, 291, 974, 974, 292, 829, 830, 294, 831, 831, + 831, 831, 500, 384, 500, 974, 974, 501, 834, 835, + 503, 836, 836, 836, 836, 510, 389, 510, 974, 974, + 511, 839, 840, 513, 841, 841, 841, 841, 301, 192, + 301, 974, 974, 302, 842, 843, 304, 844, 844, 844, + 844, 524, 393, 524, 974, 974, 525, 847, 848, 527, + 849, 849, 849, 849, 743, 643, 743, 974, 974, 744, + + 974, 745, 746, 747, 747, 747, 747, 743, 643, 743, + 974, 974, 744, 974, 745, 746, 747, 747, 747, 747, + 534, 400, 534, 974, 974, 535, 854, 855, 537, 856, + 856, 856, 856, 534, 400, 534, 974, 974, 535, 974, + 536, 750, 751, 751, 751, 751, 643, 643, 643, 974, + 974, 644, 974, 974, 753, 754, 754, 754, 754, 756, + 647, 756, 974, 974, 757, 974, 758, 759, 760, 760, + 760, 760, 756, 647, 756, 974, 974, 757, 974, 758, + 759, 760, 760, 760, 760, 313, 203, 313, 974, 974, + 314, 860, 861, 316, 862, 862, 862, 862, 313, 203, + + 313, 974, 974, 314, 974, 315, 763, 764, 764, 764, + 764, 770, 654, 770, 974, 974, 771, 974, 772, 773, + 774, 774, 774, 774, 647, 647, 647, 974, 974, 657, + 974, 974, 767, 768, 768, 768, 768, 770, 654, 770, + 974, 974, 771, 974, 772, 773, 774, 774, 774, 774, + 548, 404, 548, 974, 974, 549, 868, 869, 551, 870, + 870, 870, 870, 548, 404, 548, 974, 974, 549, 974, + 550, 778, 779, 779, 779, 779, 560, 413, 560, 974, + 974, 561, 874, 875, 563, 876, 876, 876, 876, 333, + 217, 333, 974, 974, 334, 877, 878, 336, 879, 879, + + 879, 879, 574, 417, 574, 974, 974, 575, 882, 883, + 577, 884, 884, 884, 884, 432, 352, 432, 974, 974, + 433, 974, 434, 435, 793, 793, 793, 793, 248, 156, + 248, 974, 974, 249, 974, 250, 251, 796, 796, 796, + 796, 352, 352, 352, 974, 974, 353, 974, 974, 974, + 798, 798, 798, 798, 446, 356, 446, 974, 974, 447, + 974, 448, 449, 801, 801, 801, 801, 446, 356, 446, + 974, 974, 447, 974, 448, 449, 801, 801, 801, 801, + 597, 597, 597, 974, 974, 598, 974, 974, 974, 803, + 803, 803, 803, 691, 597, 691, 974, 974, 692, 974, + + 693, 694, 805, 805, 805, 805, 974, 938, 939, 889, + 940, 940, 940, 940, 941, 941, 974, 942, 942, 942, + 942, 910, 910, 910, 910, 974, 974, 889, 460, 365, + 460, 974, 974, 461, 974, 462, 463, 808, 808, 808, + 808, 460, 365, 460, 974, 974, 461, 974, 462, 463, + 808, 808, 808, 808, 600, 601, 600, 974, 974, 602, + 974, 974, 974, 809, 809, 809, 809, 974, 946, 947, + 890, 948, 948, 948, 948, 949, 949, 974, 950, 950, + 950, 950, 910, 910, 910, 910, 974, 974, 890, 597, + 597, 597, 974, 974, 598, 974, 974, 974, 810, 810, + + 810, 810, 974, 954, 955, 891, 956, 956, 956, 956, + 600, 601, 600, 974, 974, 602, 918, 918, 918, 918, + 974, 974, 974, 891, 704, 601, 704, 974, 974, 705, + 974, 706, 707, 811, 811, 811, 811, 607, 608, 607, + 892, 974, 609, 926, 926, 926, 926, 613, 608, 613, + 974, 974, 614, 934, 934, 934, 934, 974, 892, 270, + 170, 270, 974, 974, 271, 974, 272, 273, 814, 814, + 814, 814, 270, 170, 270, 974, 974, 271, 974, 272, + 273, 814, 814, 814, 814, 607, 608, 607, 974, 974, + 609, 974, 974, 974, 815, 815, 815, 815, 974, 974, + + 974, 893, 934, 934, 934, 934, 940, 940, 940, 940, + 940, 940, 940, 940, 942, 942, 942, 942, 974, 893, + 601, 601, 601, 974, 974, 611, 974, 974, 974, 816, + 816, 816, 816, 974, 974, 974, 894, 942, 942, 942, + 942, 974, 974, 940, 940, 940, 940, 134, 129, 134, + 533, 974, 135, 974, 894, 718, 608, 718, 974, 964, + 719, 974, 720, 721, 817, 817, 817, 817, 533, 974, + 974, 895, 948, 948, 948, 948, 948, 948, 948, 948, + 974, 948, 948, 948, 948, 974, 974, 974, 312, 895, + 601, 601, 601, 974, 974, 611, 974, 974, 974, 819, + + 819, 819, 819, 474, 369, 474, 312, 974, 475, 974, + 476, 477, 822, 822, 822, 822, 474, 369, 474, 974, + 974, 475, 974, 476, 477, 822, 822, 822, 822, 613, + 608, 613, 974, 974, 614, 974, 974, 974, 823, 823, + 823, 823, 974, 974, 974, 896, 950, 950, 950, 950, + 950, 950, 950, 950, 956, 956, 956, 956, 956, 956, + 956, 956, 974, 896, 486, 380, 486, 974, 974, 487, + 974, 488, 489, 828, 828, 828, 828, 486, 380, 486, + 974, 974, 487, 974, 488, 489, 828, 828, 828, 828, + 291, 187, 291, 974, 974, 292, 974, 293, 294, 831, + + 831, 831, 831, 291, 187, 291, 974, 974, 292, 974, + 293, 294, 831, 831, 831, 831, 380, 380, 380, 974, + 974, 381, 974, 974, 974, 833, 833, 833, 833, 500, + 384, 500, 974, 974, 501, 974, 502, 503, 836, 836, + 836, 836, 500, 384, 500, 974, 974, 501, 974, 502, + 503, 836, 836, 836, 836, 510, 389, 510, 974, 974, + 511, 974, 512, 513, 841, 841, 841, 841, 510, 389, + 510, 974, 974, 511, 974, 512, 513, 841, 841, 841, + 841, 301, 192, 301, 974, 974, 302, 974, 303, 304, + 844, 844, 844, 844, 301, 192, 301, 974, 974, 302, + + 974, 303, 304, 844, 844, 844, 844, 389, 389, 389, + 974, 974, 390, 974, 974, 974, 846, 846, 846, 846, + 524, 393, 524, 974, 974, 525, 974, 526, 527, 849, + 849, 849, 849, 524, 393, 524, 974, 974, 525, 974, + 526, 527, 849, 849, 849, 849, 643, 643, 643, 974, + 974, 644, 974, 974, 974, 851, 851, 851, 851, 743, + 643, 743, 974, 974, 744, 974, 745, 746, 853, 853, + 853, 853, 974, 974, 974, 898, 134, 129, 134, 974, + 974, 135, 974, 974, 974, 956, 956, 956, 956, 974, + 974, 974, 547, 898, 534, 400, 534, 974, 974, 535, + + 974, 536, 537, 856, 856, 856, 856, 534, 400, 534, + 547, 963, 535, 974, 536, 537, 856, 856, 856, 856, + 646, 647, 646, 974, 974, 648, 974, 974, 974, 857, + 857, 857, 857, 134, 129, 134, 899, 974, 135, 134, + 129, 134, 974, 974, 135, 966, 967, 966, 974, 974, + 968, 974, 974, 974, 899, 643, 643, 643, 974, 974, + 644, 974, 974, 974, 858, 858, 858, 858, 966, 967, + 966, 900, 974, 968, 974, 974, 960, 966, 967, 966, + 974, 962, 968, 969, 974, 969, 974, 974, 970, 900, + 756, 647, 756, 974, 974, 757, 974, 758, 759, 859, + + 859, 859, 859, 966, 967, 966, 901, 969, 968, 969, + 974, 972, 970, 972, 974, 972, 973, 972, 974, 974, + 973, 974, 974, 974, 901, 313, 203, 313, 974, 974, + 314, 974, 315, 316, 862, 862, 862, 862, 313, 203, + 313, 974, 974, 314, 974, 315, 316, 862, 862, 862, + 862, 653, 654, 653, 974, 974, 655, 974, 974, 974, + 863, 863, 863, 863, 972, 974, 972, 902, 972, 973, + 972, 974, 974, 973, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 902, 647, 647, 647, 974, + 974, 657, 974, 974, 974, 864, 864, 864, 864, 974, + + 974, 974, 903, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 903, 770, 654, 770, 974, 974, 771, 974, 772, 773, + 865, 865, 865, 865, 974, 974, 974, 904, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 904, 647, 647, 647, 974, + 974, 657, 974, 974, 974, 867, 867, 867, 867, 548, + 404, 548, 974, 974, 549, 974, 550, 551, 870, 870, + 870, 870, 548, 404, 548, 974, 974, 549, 974, 550, + 551, 870, 870, 870, 870, 659, 654, 659, 974, 974, + + 660, 974, 974, 974, 871, 871, 871, 871, 974, 974, + 974, 905, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 905, + 560, 413, 560, 974, 974, 561, 974, 562, 563, 876, + 876, 876, 876, 560, 413, 560, 974, 974, 561, 974, + 562, 563, 876, 876, 876, 876, 333, 217, 333, 974, + 974, 334, 974, 335, 336, 879, 879, 879, 879, 333, + 217, 333, 974, 974, 334, 974, 335, 336, 879, 879, + 879, 879, 413, 413, 413, 974, 974, 414, 974, 974, + 974, 881, 881, 881, 881, 574, 417, 574, 974, 974, + + 575, 974, 576, 577, 884, 884, 884, 884, 574, 417, + 574, 974, 974, 575, 974, 576, 577, 884, 884, 884, + 884, 691, 597, 691, 974, 974, 692, 911, 912, 694, + 913, 913, 913, 913, 460, 365, 460, 974, 974, 461, + 914, 915, 463, 916, 916, 916, 916, 704, 601, 704, + 974, 974, 705, 919, 920, 707, 921, 921, 921, 921, + 270, 170, 270, 974, 974, 271, 922, 923, 273, 924, + 924, 924, 924, 718, 608, 718, 974, 974, 719, 927, + 928, 721, 929, 929, 929, 929, 474, 369, 474, 974, + 974, 475, 930, 931, 477, 932, 932, 932, 932, 743, + + 643, 743, 974, 974, 744, 935, 936, 746, 937, 937, + 937, 937, 756, 647, 756, 974, 974, 757, 943, 944, + 759, 945, 945, 945, 945, 770, 654, 770, 974, 974, + 771, 951, 952, 773, 953, 953, 953, 953, 691, 597, + 691, 974, 974, 692, 974, 693, 694, 913, 913, 913, + 913, 460, 365, 460, 974, 974, 461, 974, 462, 463, + 916, 916, 916, 916, 597, 597, 597, 974, 974, 598, + 974, 974, 974, 918, 918, 918, 918, 704, 601, 704, + 974, 974, 705, 974, 706, 707, 921, 921, 921, 921, + 270, 170, 270, 974, 974, 271, 974, 272, 273, 924, + + 924, 924, 924, 601, 601, 601, 974, 974, 611, 974, + 974, 974, 926, 926, 926, 926, 718, 608, 718, 974, + 974, 719, 974, 720, 721, 929, 929, 929, 929, 474, + 369, 474, 974, 974, 475, 974, 476, 477, 932, 932, + 932, 932, 46, 46, 46, 46, 46, 46, 46, 46, + 81, 81, 81, 81, 81, 81, 81, 81, 109, 109, + 109, 109, 109, 109, 109, 109, 119, 119, 119, 119, + 119, 119, 119, 119, 133, 133, 133, 133, 133, 133, + 133, 133, 137, 974, 974, 137, 138, 974, 974, 138, + 172, 974, 974, 172, 974, 172, 172, 172, 173, 173, + + 173, 173, 173, 173, 173, 173, 205, 974, 974, 205, + 974, 205, 205, 206, 206, 206, 206, 206, 206, 206, + 206, 219, 219, 974, 219, 974, 219, 219, 219, 222, + 222, 222, 222, 222, 222, 222, 222, 228, 228, 974, + 228, 228, 228, 228, 228, 247, 247, 247, 247, 247, + 247, 247, 247, 257, 257, 257, 257, 257, 257, 257, + 257, 263, 263, 974, 974, 263, 263, 269, 269, 269, + 269, 269, 269, 269, 269, 280, 280, 280, 280, 280, + 280, 280, 280, 290, 290, 290, 290, 290, 290, 290, + 290, 300, 300, 300, 300, 300, 300, 300, 300, 312, + + 312, 312, 312, 312, 312, 312, 312, 322, 322, 322, + 322, 322, 322, 322, 322, 332, 332, 332, 332, 332, + 332, 332, 332, 219, 219, 974, 219, 974, 219, 219, + 219, 222, 222, 222, 222, 222, 222, 222, 222, 228, + 228, 974, 228, 228, 228, 228, 228, 133, 133, 133, + 133, 133, 133, 133, 133, 137, 974, 974, 137, 247, + 247, 247, 247, 247, 247, 247, 247, 257, 257, 257, + 257, 257, 257, 257, 257, 263, 263, 974, 974, 263, + 263, 269, 269, 269, 269, 269, 269, 269, 269, 431, + 431, 431, 431, 431, 431, 431, 431, 445, 445, 445, + + 445, 445, 445, 445, 445, 459, 459, 459, 459, 459, + 459, 459, 459, 473, 473, 473, 473, 473, 473, 473, + 473, 485, 485, 485, 485, 485, 485, 485, 485, 499, + 499, 499, 499, 499, 499, 499, 499, 509, 509, 509, + 509, 509, 509, 509, 509, 300, 300, 300, 300, 300, + 300, 300, 300, 523, 523, 523, 523, 523, 523, 523, + 523, 533, 533, 533, 533, 533, 533, 533, 533, 312, + 312, 312, 312, 312, 312, 312, 312, 547, 547, 547, + 547, 547, 547, 547, 547, 322, 322, 322, 322, 322, + 322, 322, 322, 559, 559, 559, 559, 559, 559, 559, + + 559, 332, 332, 332, 332, 332, 332, 332, 332, 573, + 573, 573, 573, 573, 573, 573, 573, 133, 133, 133, + 133, 133, 133, 133, 133, 137, 974, 974, 137, 431, + 431, 431, 431, 431, 431, 431, 431, 247, 247, 247, + 247, 247, 247, 247, 247, 445, 445, 445, 445, 445, + 445, 445, 445, 459, 459, 459, 459, 459, 459, 459, + 459, 269, 269, 269, 269, 269, 269, 269, 269, 473, + 473, 473, 473, 473, 473, 473, 473, 280, 280, 280, + 280, 280, 280, 280, 280, 485, 485, 485, 485, 485, + 485, 485, 485, 290, 290, 290, 290, 290, 290, 290, + + 290, 499, 499, 499, 499, 499, 499, 499, 499, 509, + 509, 509, 509, 509, 509, 509, 509, 300, 300, 300, + 300, 300, 300, 300, 300, 523, 523, 523, 523, 523, + 523, 523, 523, 533, 533, 533, 533, 533, 533, 533, + 533, 312, 312, 312, 312, 312, 312, 312, 312, 547, + 547, 547, 547, 547, 547, 547, 547, 322, 322, 322, + 322, 322, 322, 322, 322, 559, 559, 559, 559, 559, + 559, 559, 559, 332, 332, 332, 332, 332, 332, 332, + 332, 573, 573, 573, 573, 573, 573, 573, 573, 133, + 133, 133, 133, 133, 133, 133, 133, 137, 974, 974, + + 137, 431, 431, 431, 431, 431, 431, 431, 431, 247, + 247, 247, 247, 247, 247, 247, 247, 445, 445, 445, + 445, 445, 445, 445, 445, 690, 690, 690, 690, 690, + 690, 690, 690, 459, 459, 459, 459, 459, 459, 459, + 459, 703, 703, 703, 703, 703, 703, 703, 703, 269, + 269, 269, 269, 269, 269, 269, 269, 717, 717, 717, + 717, 717, 717, 717, 717, 473, 473, 473, 473, 473, + 473, 473, 473, 280, 280, 280, 280, 280, 280, 280, + 280, 485, 485, 485, 485, 485, 485, 485, 485, 290, + 290, 290, 290, 290, 290, 290, 290, 499, 499, 499, + + 499, 499, 499, 499, 499, 509, 509, 509, 509, 509, + 509, 509, 509, 300, 300, 300, 300, 300, 300, 300, + 300, 523, 523, 523, 523, 523, 523, 523, 523, 742, + 742, 742, 742, 742, 742, 742, 742, 533, 533, 533, + 533, 533, 533, 533, 533, 755, 755, 755, 755, 755, + 755, 755, 755, 312, 312, 312, 312, 312, 312, 312, + 312, 769, 769, 769, 769, 769, 769, 769, 769, 547, + 547, 547, 547, 547, 547, 547, 547, 322, 322, 322, + 322, 322, 322, 322, 322, 559, 559, 559, 559, 559, + 559, 559, 559, 332, 332, 332, 332, 332, 332, 332, + + 332, 573, 573, 573, 573, 573, 573, 573, 573, 133, + 133, 133, 133, 133, 133, 133, 133, 137, 974, 974, + 137, 431, 431, 431, 431, 431, 431, 431, 431, 247, + 247, 247, 247, 247, 247, 247, 247, 445, 445, 445, + 445, 445, 445, 445, 445, 690, 690, 690, 690, 690, + 690, 690, 690, 459, 459, 459, 459, 459, 459, 459, + 459, 703, 703, 703, 703, 703, 703, 703, 703, 269, + 269, 269, 269, 269, 269, 269, 269, 717, 717, 717, + 717, 717, 717, 717, 717, 473, 473, 473, 473, 473, + 473, 473, 473, 485, 485, 485, 485, 485, 485, 485, + + 485, 290, 290, 290, 290, 290, 290, 290, 290, 499, + 499, 499, 499, 499, 499, 499, 499, 509, 509, 509, + 509, 509, 509, 509, 509, 300, 300, 300, 300, 300, + 300, 300, 300, 523, 523, 523, 523, 523, 523, 523, + 523, 742, 742, 742, 742, 742, 742, 742, 742, 533, + 533, 533, 533, 533, 533, 533, 533, 755, 755, 755, + 755, 755, 755, 755, 755, 312, 312, 312, 312, 312, + 312, 312, 312, 769, 769, 769, 769, 769, 769, 769, + 769, 547, 547, 547, 547, 547, 547, 547, 547, 559, + 559, 559, 559, 559, 559, 559, 559, 332, 332, 332, + + 332, 332, 332, 332, 332, 445, 445, 445, 445, 445, + 445, 445, 445, 690, 690, 690, 690, 690, 690, 690, + 690, 459, 459, 459, 459, 459, 459, 459, 459, 703, + 703, 703, 703, 703, 703, 703, 703, 269, 269, 269, + 269, 269, 269, 269, 269, 717, 717, 717, 717, 717, + 717, 717, 717, 473, 473, 473, 473, 473, 473, 473, + 473, 485, 485, 485, 485, 485, 485, 485, 485, 290, + 290, 290, 290, 290, 290, 290, 290, 499, 499, 499, + 499, 499, 499, 499, 499, 509, 509, 509, 509, 509, + 509, 509, 509, 300, 300, 300, 300, 300, 300, 300, + + 300, 523, 523, 523, 523, 523, 523, 523, 523, 742, + 742, 742, 742, 742, 742, 742, 742, 533, 533, 533, + 533, 533, 533, 533, 533, 755, 755, 755, 755, 755, + 755, 755, 755, 312, 312, 312, 312, 312, 312, 312, + 312, 769, 769, 769, 769, 769, 769, 769, 769, 547, + 547, 547, 547, 547, 547, 547, 547, 559, 559, 559, + 559, 559, 559, 559, 559, 332, 332, 332, 332, 332, + 332, 332, 332, 573, 573, 573, 573, 573, 573, 573, + 573, 133, 133, 133, 133, 133, 133, 133, 133, 137, + 974, 974, 137, 690, 690, 690, 690, 690, 690, 690, + + 690, 459, 459, 459, 459, 459, 459, 459, 459, 703, + 703, 703, 703, 703, 703, 703, 703, 269, 269, 269, + 269, 269, 269, 269, 269, 717, 717, 717, 717, 717, + 717, 717, 717, 473, 473, 473, 473, 473, 473, 473, + 473, 965, 965, 965, 965, 965, 965, 965, 965, 971, + 971, 974, 971, 971, 971, 971, 971, 45, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + + 974, 974, 974, 974, 974 + } ; + +static yyconst short int yy_chk[8306] = + { 0, + 0, 1, 1, 1, 0, 0, 1, 2, 2, 2, + 935, 935, 2, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 5, 5, 5, 61, 61, 5, 6, 6, 6, 423, + 1034, 6, 1014, 423, 47, 47, 47, 5, 5, 47, + 48, 74, 48, 6, 6, 48, 5, 66, 66, 66, + 66, 66, 6, 7, 7, 7, 1010, 74, 7, 1003, + + 7, 7, 7, 7, 7, 7, 67, 67, 67, 67, + 997, 7, 9, 9, 9, 9, 9, 9, 10, 10, + 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, + 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, + 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, + 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, + 17, 17, 17, 992, 17, 17, 18, 18, 18, 959, + 18, 18, 19, 19, 19, 19, 19, 19, 17, 69, + 69, 69, 69, 69, 18, 20, 20, 20, 20, 20, + 20, 21, 21, 21, 21, 21, 21, 22, 22, 22, + + 22, 22, 22, 23, 23, 23, 23, 23, 23, 24, + 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, + 25, 262, 908, 39, 39, 39, 25, 39, 39, 40, + 40, 40, 907, 40, 40, 453, 887, 262, 25, 454, + 25, 26, 26, 26, 26, 26, 26, 886, 51, 51, + 51, 453, 26, 51, 39, 454, 788, 41, 41, 41, + 40, 41, 41, 786, 26, 680, 26, 27, 27, 27, + 27, 27, 27, 936, 936, 42, 42, 42, 27, 42, + 42, 49, 49, 49, 937, 937, 49, 679, 41, 677, + 27, 583, 27, 28, 28, 28, 28, 28, 28, 70, + + 70, 70, 70, 129, 28, 129, 42, 582, 129, 49, + 71, 71, 71, 71, 71, 581, 28, 580, 28, 29, + 29, 29, 29, 29, 29, 72, 72, 72, 72, 424, + 29, 420, 43, 43, 43, 43, 43, 43, 75, 75, + 75, 75, 29, 43, 29, 30, 30, 30, 30, 30, + 30, 77, 77, 77, 77, 347, 30, 346, 44, 44, + 44, 44, 44, 44, 79, 79, 79, 79, 30, 44, + 30, 31, 31, 31, 31, 31, 31, 78, 78, 78, + 78, 78, 31, 76, 76, 76, 76, 83, 83, 83, + 345, 83, 83, 344, 31, 343, 31, 32, 32, 32, + + 32, 32, 32, 76, 86, 86, 86, 86, 32, 85, + 85, 85, 85, 85, 87, 87, 87, 87, 87, 76, + 32, 342, 32, 33, 33, 33, 340, 33, 33, 88, + 88, 88, 88, 88, 89, 89, 89, 89, 943, 943, + 242, 33, 91, 91, 91, 91, 91, 92, 92, 92, + 92, 944, 944, 33, 241, 33, 34, 34, 34, 240, + 34, 34, 94, 94, 94, 94, 94, 95, 95, 95, + 95, 945, 945, 239, 34, 100, 100, 100, 100, 100, + 101, 101, 101, 101, 951, 951, 34, 238, 34, 35, + 35, 35, 35, 35, 35, 102, 102, 102, 102, 102, + + 35, 103, 103, 103, 103, 105, 105, 105, 105, 952, + 952, 236, 35, 235, 35, 36, 36, 36, 36, 36, + 36, 106, 106, 106, 106, 106, 36, 104, 104, 104, + 104, 107, 107, 107, 107, 953, 953, 234, 36, 233, + 36, 37, 37, 37, 37, 37, 37, 104, 152, 111, + 111, 111, 37, 111, 111, 113, 113, 113, 113, 113, + 120, 120, 120, 104, 37, 120, 37, 38, 38, 38, + 38, 38, 38, 114, 114, 114, 114, 150, 38, 111, + 149, 111, 116, 116, 116, 116, 116, 148, 147, 146, + 38, 144, 38, 68, 68, 68, 143, 142, 68, 140, + + 139, 68, 68, 68, 68, 68, 73, 73, 73, 123, + 112, 73, 97, 84, 65, 73, 73, 73, 73, 117, + 117, 117, 117, 122, 122, 122, 64, 122, 122, 125, + 125, 125, 125, 63, 62, 73, 126, 126, 126, 126, + 127, 127, 127, 127, 128, 128, 128, 60, 59, 128, + 58, 73, 80, 80, 80, 57, 126, 80, 56, 55, + 80, 80, 80, 80, 80, 90, 90, 90, 54, 53, + 90, 45, 126, 90, 90, 90, 90, 90, 93, 93, + 93, 0, 0, 93, 0, 0, 93, 93, 93, 93, + 93, 96, 96, 96, 0, 0, 96, 0, 0, 96, + + 96, 96, 96, 96, 108, 108, 108, 0, 0, 108, + 0, 0, 108, 108, 108, 108, 108, 115, 115, 115, + 0, 0, 115, 0, 0, 115, 115, 115, 115, 115, + 118, 118, 118, 0, 0, 118, 0, 0, 118, 118, + 118, 118, 118, 130, 130, 130, 0, 131, 130, 131, + 0, 132, 131, 132, 0, 0, 132, 133, 133, 133, + 0, 0, 133, 134, 134, 134, 0, 0, 134, 135, + 135, 135, 0, 0, 135, 136, 136, 136, 0, 0, + 136, 153, 153, 153, 153, 158, 158, 158, 158, 159, + 159, 159, 159, 159, 165, 165, 165, 165, 0, 136, + + 155, 155, 155, 0, 0, 155, 0, 0, 0, 155, + 155, 155, 155, 164, 164, 164, 155, 0, 164, 167, + 167, 167, 167, 0, 0, 0, 160, 160, 160, 160, + 0, 0, 0, 160, 155, 156, 156, 156, 0, 0, + 156, 0, 156, 156, 156, 156, 156, 156, 157, 157, + 157, 160, 0, 157, 0, 157, 157, 157, 157, 157, + 157, 162, 162, 162, 0, 0, 162, 0, 162, 0, + 162, 162, 162, 162, 163, 163, 163, 0, 0, 163, + 0, 163, 0, 163, 163, 163, 163, 169, 169, 169, + 0, 0, 169, 0, 0, 0, 169, 169, 169, 169, + + 173, 173, 173, 169, 173, 173, 174, 174, 174, 0, + 174, 174, 176, 176, 176, 176, 177, 177, 177, 177, + 177, 169, 170, 170, 170, 0, 0, 170, 0, 170, + 170, 170, 170, 170, 170, 171, 171, 171, 0, 0, + 171, 0, 171, 171, 171, 171, 171, 171, 178, 178, + 178, 178, 0, 0, 0, 178, 179, 179, 179, 179, + 184, 184, 184, 184, 189, 189, 189, 189, 195, 195, + 195, 195, 0, 178, 181, 181, 181, 0, 0, 181, + 0, 0, 0, 181, 181, 181, 181, 0, 0, 0, + 181, 196, 196, 196, 196, 196, 198, 198, 198, 198, + + 197, 197, 197, 197, 0, 0, 0, 197, 181, 182, + 182, 182, 0, 0, 182, 0, 182, 182, 182, 182, + 182, 182, 183, 183, 183, 197, 0, 183, 0, 183, + 183, 183, 183, 183, 183, 186, 186, 186, 0, 0, + 186, 0, 0, 0, 186, 186, 186, 186, 0, 0, + 0, 186, 200, 200, 200, 200, 0, 206, 206, 206, + 0, 206, 206, 209, 209, 209, 209, 0, 0, 186, + 187, 187, 187, 0, 0, 187, 0, 187, 187, 187, + 187, 187, 187, 188, 188, 188, 0, 206, 188, 206, + 188, 188, 188, 188, 188, 188, 191, 191, 191, 0, + + 0, 191, 0, 0, 0, 191, 191, 191, 191, 0, + 0, 0, 191, 214, 214, 214, 214, 0, 207, 207, + 207, 0, 207, 207, 220, 220, 220, 0, 0, 220, + 191, 192, 192, 192, 0, 0, 192, 0, 192, 192, + 192, 192, 192, 192, 193, 193, 193, 0, 207, 193, + 207, 193, 193, 193, 193, 193, 193, 202, 202, 202, + 0, 0, 202, 0, 0, 0, 202, 202, 202, 202, + 221, 221, 221, 202, 221, 221, 222, 222, 222, 0, + 222, 222, 223, 223, 223, 0, 223, 223, 0, 0, + 0, 202, 203, 203, 203, 0, 0, 203, 0, 203, + + 203, 203, 203, 203, 203, 204, 204, 204, 0, 0, + 204, 0, 204, 204, 204, 204, 204, 204, 211, 211, + 211, 0, 0, 211, 0, 0, 0, 211, 211, 211, + 211, 224, 224, 224, 211, 224, 224, 226, 226, 226, + 226, 228, 229, 228, 229, 0, 228, 229, 245, 245, + 245, 245, 211, 212, 212, 212, 0, 0, 212, 0, + 212, 212, 212, 212, 212, 212, 213, 213, 213, 0, + 0, 213, 0, 213, 213, 213, 213, 213, 213, 215, + 215, 215, 0, 0, 215, 0, 0, 215, 215, 215, + 215, 215, 216, 216, 216, 0, 0, 216, 0, 0, + + 0, 216, 216, 216, 216, 230, 0, 230, 216, 0, + 230, 231, 231, 231, 243, 243, 231, 243, 243, 243, + 243, 244, 244, 244, 244, 244, 216, 217, 217, 217, + 0, 231, 217, 0, 217, 217, 217, 217, 217, 217, + 218, 218, 218, 0, 0, 218, 0, 218, 218, 218, + 218, 218, 218, 246, 246, 246, 0, 0, 246, 0, + 0, 246, 246, 246, 246, 246, 247, 247, 247, 0, + 0, 247, 0, 247, 247, 247, 247, 247, 247, 248, + 248, 248, 0, 0, 248, 0, 248, 248, 248, 248, + 248, 248, 251, 251, 251, 251, 252, 252, 252, 253, + + 253, 252, 253, 253, 253, 253, 254, 254, 254, 254, + 255, 255, 255, 255, 256, 256, 256, 256, 263, 263, + 263, 265, 265, 263, 265, 265, 265, 265, 0, 0, + 255, 266, 266, 266, 266, 266, 267, 267, 267, 267, + 273, 273, 273, 273, 0, 0, 255, 257, 257, 257, + 0, 0, 257, 0, 257, 0, 257, 257, 257, 257, + 258, 258, 258, 0, 0, 258, 0, 258, 0, 258, + 258, 258, 258, 259, 259, 259, 0, 0, 259, 0, + 259, 0, 259, 259, 259, 259, 260, 260, 260, 0, + 0, 260, 0, 260, 0, 260, 260, 260, 260, 261, + + 261, 261, 0, 0, 261, 0, 261, 0, 261, 261, + 261, 261, 274, 274, 274, 275, 275, 274, 275, 275, + 275, 275, 278, 278, 278, 278, 276, 276, 261, 276, + 276, 276, 276, 277, 277, 277, 277, 277, 279, 279, + 279, 279, 279, 0, 261, 268, 268, 268, 0, 0, + 268, 0, 0, 268, 268, 268, 268, 268, 269, 269, + 269, 0, 0, 269, 0, 269, 269, 269, 269, 269, + 269, 270, 270, 270, 0, 0, 270, 0, 270, 270, + 270, 270, 270, 270, 280, 280, 280, 0, 0, 280, + 0, 280, 280, 280, 280, 280, 280, 284, 284, 284, + + 284, 286, 286, 0, 286, 286, 286, 286, 287, 287, + 287, 287, 287, 288, 288, 288, 288, 289, 289, 289, + 0, 0, 289, 0, 0, 289, 289, 289, 289, 289, + 290, 290, 290, 0, 0, 290, 0, 290, 290, 290, + 290, 290, 290, 294, 294, 294, 294, 295, 295, 295, + 296, 296, 295, 296, 296, 296, 296, 297, 297, 297, + 297, 297, 298, 298, 298, 298, 299, 299, 299, 0, + 0, 299, 0, 0, 299, 299, 299, 299, 299, 300, + 300, 300, 0, 0, 300, 0, 300, 300, 300, 300, + 300, 300, 304, 304, 304, 304, 305, 305, 305, 306, + + 306, 305, 306, 306, 306, 306, 308, 308, 0, 308, + 308, 308, 308, 309, 309, 309, 309, 309, 310, 310, + 310, 310, 311, 311, 311, 0, 0, 311, 0, 0, + 311, 311, 311, 311, 311, 312, 312, 312, 0, 0, + 312, 0, 312, 312, 312, 312, 312, 312, 316, 316, + 316, 316, 317, 317, 317, 318, 318, 317, 318, 318, + 318, 318, 319, 319, 319, 319, 319, 320, 320, 320, + 320, 321, 321, 321, 321, 321, 322, 322, 322, 0, + 0, 322, 0, 322, 322, 322, 322, 322, 322, 326, + 326, 326, 326, 328, 328, 0, 328, 328, 328, 328, + + 329, 329, 329, 329, 329, 330, 330, 330, 330, 331, + 331, 331, 0, 0, 331, 0, 0, 331, 331, 331, + 331, 331, 332, 332, 332, 0, 0, 332, 0, 332, + 332, 332, 332, 332, 332, 336, 336, 336, 336, 337, + 337, 337, 0, 0, 337, 339, 339, 339, 0, 0, + 339, 349, 349, 349, 349, 358, 358, 358, 358, 359, + 359, 359, 359, 0, 339, 350, 350, 350, 0, 0, + 350, 0, 0, 0, 350, 350, 350, 350, 351, 351, + 351, 0, 0, 351, 0, 0, 0, 351, 351, 351, + 351, 0, 0, 0, 351, 362, 362, 362, 362, 371, + + 371, 371, 371, 372, 372, 372, 372, 373, 373, 373, + 373, 0, 351, 352, 352, 352, 0, 0, 352, 0, + 352, 352, 352, 352, 352, 352, 353, 353, 353, 0, + 0, 353, 0, 353, 353, 353, 353, 353, 353, 354, + 354, 354, 0, 0, 354, 0, 0, 0, 354, 354, + 354, 354, 0, 0, 0, 354, 375, 375, 375, 375, + 0, 0, 0, 375, 376, 376, 376, 376, 0, 0, + 0, 376, 0, 354, 355, 355, 355, 355, 355, 355, + 0, 375, 0, 355, 377, 377, 377, 377, 0, 376, + 386, 386, 386, 386, 395, 395, 395, 395, 0, 0, + + 0, 355, 356, 356, 356, 0, 0, 356, 0, 356, + 356, 356, 356, 356, 356, 357, 357, 357, 0, 0, + 357, 0, 357, 357, 357, 357, 357, 357, 361, 361, + 361, 361, 361, 361, 361, 361, 361, 396, 396, 396, + 396, 397, 397, 397, 397, 419, 419, 419, 361, 0, + 419, 0, 361, 361, 361, 406, 406, 406, 406, 410, + 410, 410, 410, 0, 361, 363, 363, 363, 0, 0, + 363, 0, 0, 0, 363, 363, 363, 363, 364, 364, + 364, 0, 0, 364, 0, 0, 0, 364, 364, 364, + 364, 0, 427, 427, 364, 427, 427, 427, 427, 428, + + 428, 428, 428, 428, 408, 408, 408, 408, 0, 0, + 0, 408, 364, 365, 365, 365, 0, 0, 365, 0, + 365, 365, 365, 365, 365, 365, 366, 366, 366, 408, + 0, 366, 0, 366, 366, 366, 366, 366, 366, 367, + 367, 367, 0, 0, 367, 0, 0, 0, 367, 367, + 367, 367, 0, 0, 0, 367, 429, 429, 429, 429, + 430, 430, 430, 430, 430, 435, 435, 435, 435, 443, + 443, 443, 443, 367, 368, 368, 368, 368, 368, 368, + 0, 0, 0, 368, 439, 439, 439, 439, 439, 440, + 440, 440, 0, 0, 440, 442, 442, 442, 442, 442, + + 0, 368, 369, 369, 369, 0, 0, 369, 0, 369, + 369, 369, 369, 369, 369, 370, 370, 370, 0, 0, + 370, 0, 370, 370, 370, 370, 370, 370, 374, 374, + 374, 0, 0, 374, 0, 0, 0, 374, 374, 374, + 374, 378, 378, 378, 0, 0, 378, 0, 0, 0, + 378, 378, 378, 378, 379, 379, 379, 0, 0, 379, + 0, 0, 0, 379, 379, 379, 379, 0, 0, 0, + 379, 449, 449, 449, 449, 455, 455, 0, 455, 455, + 455, 455, 456, 456, 456, 456, 456, 0, 379, 380, + 380, 380, 0, 0, 380, 0, 380, 380, 380, 380, + + 380, 380, 381, 381, 381, 0, 0, 381, 0, 381, + 381, 381, 381, 381, 381, 382, 382, 382, 0, 0, + 382, 0, 0, 0, 382, 382, 382, 382, 0, 0, + 0, 382, 457, 457, 457, 457, 463, 463, 463, 463, + 464, 464, 464, 0, 0, 464, 0, 0, 0, 382, + 383, 383, 383, 383, 383, 383, 0, 0, 0, 383, + 467, 467, 467, 467, 467, 468, 468, 468, 0, 0, + 468, 470, 470, 470, 470, 470, 0, 383, 384, 384, + 384, 0, 0, 384, 0, 384, 384, 384, 384, 384, + 384, 385, 385, 385, 0, 0, 385, 0, 385, 385, + + 385, 385, 385, 385, 387, 387, 387, 0, 0, 387, + 0, 0, 0, 387, 387, 387, 387, 388, 388, 388, + 0, 0, 388, 0, 0, 0, 388, 388, 388, 388, + 0, 0, 0, 388, 471, 471, 471, 471, 477, 477, + 477, 477, 478, 478, 478, 0, 0, 478, 0, 0, + 0, 388, 389, 389, 389, 0, 0, 389, 0, 389, + 389, 389, 389, 389, 389, 390, 390, 390, 0, 0, + 390, 0, 390, 390, 390, 390, 390, 390, 391, 391, + 391, 0, 0, 391, 0, 391, 391, 391, 391, 391, + 391, 0, 479, 479, 391, 479, 479, 479, 479, 481, + + 481, 0, 481, 481, 481, 481, 482, 482, 482, 482, + 482, 0, 391, 392, 392, 392, 0, 0, 392, 0, + 392, 392, 392, 392, 392, 392, 393, 393, 393, 0, + 0, 393, 0, 393, 393, 393, 393, 393, 393, 394, + 394, 394, 0, 0, 394, 0, 394, 394, 394, 394, + 394, 394, 398, 398, 398, 0, 0, 398, 0, 0, + 0, 398, 398, 398, 398, 399, 399, 399, 0, 0, + 399, 0, 0, 0, 399, 399, 399, 399, 0, 0, + 0, 399, 483, 483, 483, 483, 484, 484, 484, 484, + 484, 489, 489, 489, 489, 497, 497, 497, 497, 399, + + 400, 400, 400, 0, 0, 400, 0, 400, 400, 400, + 400, 400, 400, 401, 401, 401, 0, 0, 401, 0, + 401, 401, 401, 401, 401, 401, 402, 402, 402, 0, + 0, 402, 0, 402, 402, 402, 402, 402, 402, 0, + 0, 0, 402, 493, 493, 493, 493, 493, 494, 494, + 494, 0, 0, 494, 496, 496, 496, 496, 496, 0, + 402, 403, 403, 403, 0, 0, 403, 0, 403, 403, + 403, 403, 403, 403, 404, 404, 404, 0, 0, 404, + 0, 404, 404, 404, 404, 404, 404, 405, 405, 405, + 0, 0, 405, 0, 405, 405, 405, 405, 405, 405, + + 407, 407, 407, 0, 0, 407, 0, 0, 0, 407, + 407, 407, 407, 409, 409, 409, 0, 0, 409, 0, + 409, 409, 409, 409, 409, 409, 0, 0, 0, 409, + 503, 503, 503, 503, 505, 505, 0, 505, 505, 505, + 505, 506, 506, 506, 506, 506, 0, 409, 411, 411, + 411, 0, 0, 411, 0, 0, 0, 411, 411, 411, + 411, 412, 412, 412, 0, 0, 412, 0, 0, 0, + 412, 412, 412, 412, 0, 0, 0, 412, 507, 507, + 507, 507, 508, 508, 508, 508, 508, 513, 513, 513, + 513, 521, 521, 521, 521, 412, 413, 413, 413, 0, + + 0, 413, 0, 413, 413, 413, 413, 413, 413, 414, + 414, 414, 0, 0, 414, 0, 414, 414, 414, 414, + 414, 414, 415, 415, 415, 0, 0, 415, 0, 415, + 415, 415, 415, 415, 415, 0, 0, 0, 415, 517, + 517, 517, 517, 517, 518, 518, 518, 0, 0, 518, + 520, 520, 520, 520, 520, 0, 415, 416, 416, 416, + 0, 0, 416, 0, 416, 416, 416, 416, 416, 416, + 417, 417, 417, 0, 0, 417, 0, 417, 417, 417, + 417, 417, 417, 418, 418, 418, 0, 0, 418, 0, + 418, 418, 418, 418, 418, 418, 431, 431, 431, 0, + + 0, 431, 0, 431, 431, 431, 431, 431, 431, 432, + 432, 432, 0, 0, 432, 0, 432, 432, 432, 432, + 432, 432, 437, 437, 437, 0, 0, 437, 437, 437, + 437, 437, 437, 437, 437, 438, 438, 438, 0, 0, + 438, 0, 438, 438, 438, 438, 438, 438, 441, 441, + 441, 0, 0, 441, 0, 441, 441, 441, 441, 441, + 441, 444, 444, 444, 0, 0, 444, 0, 0, 444, + 444, 444, 444, 444, 445, 445, 445, 0, 0, 445, + 0, 445, 445, 445, 445, 445, 445, 452, 452, 452, + 452, 452, 452, 452, 452, 452, 452, 452, 452, 452, + + 452, 452, 452, 452, 452, 452, 452, 452, 452, 452, + 452, 452, 452, 452, 452, 452, 452, 452, 452, 452, + 452, 452, 452, 452, 452, 452, 452, 452, 452, 452, + 452, 452, 452, 452, 458, 458, 458, 0, 0, 458, + 0, 0, 458, 458, 458, 458, 458, 459, 459, 459, + 0, 0, 459, 0, 459, 459, 459, 459, 459, 459, + 460, 460, 460, 0, 0, 460, 0, 460, 460, 460, + 460, 460, 460, 465, 465, 465, 0, 0, 465, 465, + 465, 465, 465, 465, 465, 465, 466, 466, 466, 0, + 0, 466, 0, 466, 466, 466, 466, 466, 466, 469, + + 469, 469, 0, 0, 469, 0, 469, 469, 469, 469, + 469, 469, 472, 472, 472, 0, 0, 472, 0, 0, + 472, 472, 472, 472, 472, 473, 473, 473, 0, 0, + 473, 0, 473, 473, 473, 473, 473, 473, 480, 480, + 480, 0, 0, 480, 480, 480, 480, 480, 480, 480, + 480, 485, 485, 485, 0, 0, 485, 0, 485, 485, + 485, 485, 485, 485, 486, 486, 486, 0, 0, 486, + 0, 486, 486, 486, 486, 486, 486, 491, 491, 491, + 0, 0, 491, 491, 491, 491, 491, 491, 491, 491, + 492, 492, 492, 0, 0, 492, 0, 492, 492, 492, + + 492, 492, 492, 495, 495, 495, 0, 0, 495, 0, + 495, 495, 495, 495, 495, 495, 498, 498, 498, 0, + 0, 498, 0, 0, 498, 498, 498, 498, 498, 499, + 499, 499, 0, 0, 499, 0, 499, 499, 499, 499, + 499, 499, 509, 509, 509, 0, 0, 509, 0, 509, + 509, 509, 509, 509, 509, 510, 510, 510, 0, 0, + 510, 0, 510, 510, 510, 510, 510, 510, 515, 515, + 515, 0, 0, 515, 515, 515, 515, 515, 515, 515, + 515, 516, 516, 516, 0, 0, 516, 0, 516, 516, + 516, 516, 516, 516, 519, 519, 519, 0, 0, 519, + + 0, 519, 519, 519, 519, 519, 519, 522, 522, 522, + 0, 0, 522, 0, 0, 522, 522, 522, 522, 522, + 523, 523, 523, 0, 0, 523, 0, 523, 523, 523, + 523, 523, 523, 527, 527, 527, 527, 529, 529, 0, + 529, 529, 529, 529, 530, 530, 530, 530, 530, 531, + 531, 531, 531, 532, 532, 532, 0, 0, 532, 0, + 0, 532, 532, 532, 532, 532, 533, 533, 533, 0, + 0, 533, 0, 533, 533, 533, 533, 533, 533, 534, + 534, 534, 0, 0, 534, 0, 534, 534, 534, 534, + 534, 534, 537, 537, 537, 537, 538, 538, 538, 0, + + 0, 538, 539, 539, 539, 0, 0, 539, 539, 539, + 539, 539, 539, 539, 539, 540, 540, 540, 0, 0, + 540, 0, 540, 540, 540, 540, 540, 540, 541, 541, + 541, 541, 541, 542, 542, 542, 0, 0, 542, 543, + 543, 543, 0, 0, 543, 0, 543, 543, 543, 543, + 543, 543, 544, 544, 544, 544, 544, 545, 545, 545, + 545, 546, 546, 546, 0, 0, 546, 0, 0, 546, + 546, 546, 546, 546, 547, 547, 547, 0, 0, 547, + 0, 547, 547, 547, 547, 547, 547, 551, 551, 551, + 551, 552, 552, 552, 553, 553, 552, 553, 553, 553, + + 553, 554, 554, 554, 0, 0, 554, 554, 554, 554, + 554, 554, 554, 554, 555, 555, 0, 555, 555, 555, + 555, 556, 556, 556, 556, 556, 557, 557, 557, 557, + 558, 558, 558, 558, 558, 559, 559, 559, 0, 0, + 559, 0, 559, 559, 559, 559, 559, 559, 560, 560, + 560, 0, 0, 560, 0, 560, 560, 560, 560, 560, + 560, 563, 563, 563, 563, 565, 565, 565, 0, 0, + 565, 565, 565, 565, 565, 565, 565, 565, 566, 566, + 566, 0, 0, 566, 0, 566, 566, 566, 566, 566, + 566, 567, 567, 567, 567, 567, 568, 568, 568, 0, + + 0, 568, 569, 569, 569, 0, 0, 569, 0, 569, + 569, 569, 569, 569, 569, 570, 570, 570, 570, 570, + 571, 571, 571, 571, 572, 572, 572, 0, 0, 572, + 0, 0, 572, 572, 572, 572, 572, 573, 573, 573, + 0, 0, 573, 0, 573, 573, 573, 573, 573, 573, + 577, 577, 577, 577, 579, 579, 579, 0, 0, 579, + 584, 584, 584, 584, 586, 586, 586, 586, 590, 590, + 590, 586, 0, 590, 594, 594, 594, 594, 615, 615, + 615, 615, 579, 585, 585, 585, 0, 0, 585, 586, + 0, 0, 585, 585, 585, 585, 587, 587, 587, 0, + + 0, 587, 0, 587, 587, 587, 587, 587, 587, 605, + 605, 605, 587, 0, 605, 616, 616, 616, 616, 620, + 620, 620, 620, 626, 626, 626, 0, 0, 626, 0, + 587, 588, 588, 588, 0, 0, 588, 0, 588, 588, + 588, 588, 588, 588, 589, 589, 589, 0, 0, 589, + 0, 589, 589, 589, 589, 589, 589, 591, 591, 591, + 0, 0, 591, 0, 0, 0, 591, 591, 591, 591, + 0, 0, 0, 591, 622, 622, 622, 622, 0, 0, + 0, 622, 630, 630, 630, 630, 640, 640, 640, 640, + 0, 591, 592, 592, 592, 0, 0, 592, 0, 622, + + 0, 592, 592, 592, 592, 636, 636, 636, 592, 0, + 636, 661, 661, 661, 661, 632, 632, 632, 632, 651, + 651, 651, 632, 0, 651, 0, 592, 593, 593, 593, + 0, 0, 593, 0, 593, 593, 593, 593, 593, 593, + 632, 0, 0, 593, 662, 662, 662, 662, 666, 666, + 666, 666, 0, 668, 668, 668, 668, 0, 0, 0, + 668, 593, 595, 595, 595, 0, 0, 595, 0, 0, + 0, 595, 595, 595, 595, 596, 596, 596, 668, 0, + 596, 0, 0, 0, 596, 596, 596, 596, 672, 672, + 672, 596, 0, 672, 676, 676, 676, 681, 681, 676, + + 681, 681, 681, 681, 0, 676, 0, 0, 0, 596, + 597, 597, 597, 0, 0, 597, 0, 597, 597, 597, + 597, 597, 597, 598, 598, 598, 0, 0, 598, 0, + 598, 598, 598, 598, 598, 598, 599, 599, 599, 0, + 0, 599, 0, 599, 599, 599, 599, 599, 599, 0, + 684, 684, 599, 684, 684, 684, 684, 686, 686, 0, + 686, 686, 686, 686, 687, 687, 687, 687, 687, 0, + 599, 600, 600, 600, 0, 0, 600, 0, 600, 600, + 600, 600, 600, 600, 601, 601, 601, 0, 0, 601, + 0, 601, 601, 601, 601, 601, 601, 602, 602, 602, + + 0, 0, 602, 0, 602, 602, 602, 602, 602, 602, + 603, 603, 603, 0, 0, 603, 0, 603, 603, 603, + 603, 603, 603, 604, 604, 604, 0, 0, 604, 0, + 604, 604, 604, 604, 604, 604, 606, 606, 606, 0, + 0, 606, 0, 0, 0, 606, 606, 606, 606, 0, + 0, 0, 606, 688, 688, 688, 688, 689, 689, 689, + 689, 689, 694, 694, 694, 694, 701, 701, 701, 701, + 606, 607, 607, 607, 607, 607, 607, 0, 0, 0, + 607, 698, 698, 698, 698, 698, 699, 699, 699, 0, + 0, 699, 700, 700, 700, 700, 700, 0, 607, 608, + + 608, 608, 0, 0, 608, 0, 608, 608, 608, 608, + 608, 608, 609, 609, 609, 0, 0, 609, 0, 609, + 609, 609, 609, 609, 609, 610, 610, 610, 0, 0, + 610, 0, 0, 0, 610, 610, 610, 610, 0, 0, + 0, 610, 707, 707, 707, 707, 711, 711, 711, 711, + 711, 712, 712, 712, 0, 0, 712, 0, 0, 610, + 611, 611, 611, 0, 0, 611, 0, 611, 611, 611, + 611, 611, 611, 612, 612, 612, 0, 0, 612, 0, + 612, 612, 612, 612, 612, 612, 0, 0, 0, 612, + 714, 714, 714, 714, 714, 715, 715, 715, 715, 721, + + 721, 721, 721, 740, 740, 740, 740, 612, 613, 613, + 613, 0, 0, 613, 0, 613, 613, 613, 613, 613, + 613, 614, 614, 614, 0, 0, 614, 0, 614, 614, + 614, 614, 614, 614, 617, 617, 617, 0, 0, 617, + 0, 617, 617, 617, 617, 617, 617, 618, 618, 618, + 0, 0, 618, 0, 618, 618, 618, 618, 618, 618, + 621, 621, 621, 0, 0, 621, 0, 0, 0, 621, + 621, 621, 621, 623, 623, 623, 0, 0, 623, 0, + 623, 623, 623, 623, 623, 623, 0, 723, 723, 623, + 723, 723, 723, 723, 726, 726, 726, 726, 726, 727, + + 727, 727, 0, 0, 727, 0, 0, 623, 624, 624, + 624, 0, 0, 624, 0, 624, 624, 624, 624, 624, + 624, 625, 625, 625, 0, 0, 625, 0, 625, 625, + 625, 625, 625, 625, 627, 627, 627, 0, 0, 627, + 0, 0, 0, 627, 627, 627, 627, 0, 728, 728, + 627, 728, 728, 728, 728, 731, 731, 0, 731, 731, + 731, 731, 739, 739, 739, 739, 739, 0, 627, 628, + 628, 628, 0, 0, 628, 0, 0, 0, 628, 628, + 628, 628, 0, 733, 733, 628, 733, 733, 733, 733, + 736, 736, 0, 736, 736, 736, 736, 741, 741, 741, + + 741, 741, 0, 628, 629, 629, 629, 0, 0, 629, + 0, 629, 629, 629, 629, 629, 629, 0, 738, 738, + 629, 738, 738, 738, 738, 746, 746, 746, 746, 750, + 750, 750, 750, 750, 753, 753, 753, 753, 629, 631, + 631, 631, 0, 0, 631, 0, 0, 0, 631, 631, + 631, 631, 633, 633, 633, 0, 0, 633, 0, 633, + 633, 633, 633, 633, 633, 751, 751, 751, 633, 0, + 751, 752, 752, 752, 752, 752, 759, 759, 759, 759, + 763, 763, 763, 763, 763, 0, 633, 634, 634, 634, + 0, 0, 634, 0, 634, 634, 634, 634, 634, 634, + + 635, 635, 635, 0, 0, 635, 0, 635, 635, 635, + 635, 635, 635, 637, 637, 637, 0, 0, 637, 0, + 0, 0, 637, 637, 637, 637, 764, 764, 764, 637, + 0, 764, 766, 766, 766, 766, 766, 767, 767, 767, + 767, 773, 773, 773, 773, 0, 0, 637, 638, 638, + 638, 0, 0, 638, 0, 0, 0, 638, 638, 638, + 638, 0, 775, 775, 638, 775, 775, 775, 775, 778, + 778, 778, 778, 778, 779, 779, 779, 0, 0, 779, + 0, 0, 638, 639, 639, 639, 0, 0, 639, 0, + 639, 639, 639, 639, 639, 639, 0, 780, 780, 639, + + 780, 780, 780, 780, 783, 783, 0, 783, 783, 783, + 783, 789, 789, 789, 789, 0, 0, 639, 641, 641, + 641, 0, 0, 641, 0, 0, 0, 641, 641, 641, + 641, 642, 642, 642, 0, 0, 642, 0, 0, 0, + 642, 642, 642, 642, 785, 785, 785, 642, 0, 785, + 0, 0, 785, 790, 790, 790, 790, 796, 796, 796, + 0, 0, 796, 0, 0, 642, 643, 643, 643, 0, + 0, 643, 0, 643, 643, 643, 643, 643, 643, 644, + 644, 644, 0, 0, 644, 0, 644, 644, 644, 644, + 644, 644, 645, 645, 645, 0, 0, 645, 0, 645, + + 645, 645, 645, 645, 645, 0, 0, 0, 645, 797, + 797, 797, 797, 802, 802, 802, 802, 0, 804, 804, + 804, 804, 0, 0, 0, 804, 645, 646, 646, 646, + 0, 0, 646, 0, 646, 646, 646, 646, 646, 646, + 647, 647, 647, 804, 0, 647, 0, 647, 647, 647, + 647, 647, 647, 648, 648, 648, 0, 0, 648, 0, + 648, 648, 648, 648, 648, 648, 649, 649, 649, 0, + 0, 649, 0, 649, 649, 649, 649, 649, 649, 650, + 650, 650, 0, 0, 650, 0, 650, 650, 650, 650, + 650, 650, 652, 652, 652, 0, 0, 652, 0, 0, + + 0, 652, 652, 652, 652, 808, 808, 808, 652, 0, + 808, 814, 814, 814, 0, 0, 814, 818, 818, 818, + 818, 824, 824, 824, 824, 0, 652, 653, 653, 653, + 653, 653, 653, 822, 822, 822, 653, 0, 822, 825, + 825, 825, 825, 831, 831, 831, 0, 0, 831, 832, + 832, 832, 832, 0, 653, 654, 654, 654, 0, 0, + 654, 0, 654, 654, 654, 654, 654, 654, 655, 655, + 655, 0, 0, 655, 0, 655, 655, 655, 655, 655, + 655, 656, 656, 656, 0, 0, 656, 0, 0, 0, + 656, 656, 656, 656, 0, 0, 0, 656, 837, 837, + + 837, 837, 838, 838, 838, 838, 844, 844, 844, 0, + 0, 844, 0, 0, 0, 656, 657, 657, 657, 0, + 0, 657, 0, 657, 657, 657, 657, 657, 657, 658, + 658, 658, 0, 0, 658, 0, 658, 658, 658, 658, + 658, 658, 0, 0, 0, 658, 845, 845, 845, 845, + 850, 850, 850, 850, 0, 852, 852, 852, 852, 0, + 0, 0, 852, 658, 659, 659, 659, 0, 0, 659, + 0, 659, 659, 659, 659, 659, 659, 660, 660, 660, + 852, 0, 660, 0, 660, 660, 660, 660, 660, 660, + 663, 663, 663, 0, 0, 663, 0, 663, 663, 663, + + 663, 663, 663, 664, 664, 664, 0, 0, 664, 0, + 664, 664, 664, 664, 664, 664, 667, 667, 667, 0, + 0, 667, 0, 0, 0, 667, 667, 667, 667, 669, + 669, 669, 0, 0, 669, 0, 669, 669, 669, 669, + 669, 669, 856, 856, 856, 669, 0, 856, 862, 862, + 862, 0, 0, 862, 866, 866, 866, 866, 872, 872, + 872, 872, 0, 669, 670, 670, 670, 0, 0, 670, + 0, 670, 670, 670, 670, 670, 670, 671, 671, 671, + 0, 0, 671, 0, 671, 671, 671, 671, 671, 671, + 673, 673, 673, 0, 0, 673, 0, 0, 0, 673, + + 673, 673, 673, 870, 870, 870, 673, 0, 870, 873, + 873, 873, 873, 879, 879, 879, 0, 0, 879, 880, + 880, 880, 880, 0, 673, 674, 674, 674, 0, 0, + 674, 0, 0, 0, 674, 674, 674, 674, 885, 885, + 885, 674, 0, 885, 0, 888, 888, 885, 888, 888, + 888, 888, 891, 891, 0, 891, 891, 891, 891, 674, + 675, 675, 675, 0, 0, 675, 0, 675, 675, 675, + 675, 675, 675, 0, 894, 894, 675, 894, 894, 894, + 894, 897, 897, 0, 897, 897, 897, 897, 906, 906, + 906, 0, 0, 906, 675, 682, 682, 682, 0, 0, + + 682, 682, 682, 682, 682, 682, 682, 682, 683, 683, + 683, 0, 0, 683, 683, 683, 683, 683, 683, 683, + 683, 685, 685, 685, 0, 0, 685, 685, 685, 685, + 685, 685, 685, 685, 690, 690, 690, 0, 0, 690, + 0, 690, 690, 690, 690, 690, 690, 691, 691, 691, + 0, 0, 691, 0, 691, 691, 691, 691, 691, 691, + 696, 696, 696, 0, 0, 696, 696, 696, 696, 696, + 696, 696, 696, 697, 697, 697, 0, 0, 697, 0, + 697, 697, 697, 697, 697, 697, 702, 702, 702, 0, + 0, 702, 0, 0, 702, 702, 702, 702, 702, 703, + + 703, 703, 0, 0, 703, 0, 703, 703, 703, 703, + 703, 703, 704, 704, 704, 0, 0, 704, 0, 704, + 704, 704, 704, 704, 704, 709, 709, 709, 0, 0, + 709, 709, 709, 709, 709, 709, 709, 709, 710, 710, + 710, 0, 0, 710, 0, 710, 710, 710, 710, 710, + 710, 713, 713, 713, 0, 0, 713, 0, 713, 713, + 713, 713, 713, 713, 716, 716, 716, 0, 0, 716, + 0, 0, 716, 716, 716, 716, 716, 717, 717, 717, + 0, 0, 717, 0, 717, 717, 717, 717, 717, 717, + 724, 724, 724, 0, 0, 724, 724, 724, 724, 724, + + 724, 724, 724, 725, 725, 725, 0, 0, 725, 0, + 725, 725, 725, 725, 725, 725, 729, 729, 729, 0, + 0, 729, 729, 729, 729, 729, 729, 729, 729, 730, + 730, 730, 0, 0, 730, 730, 730, 730, 730, 730, + 730, 730, 732, 732, 732, 0, 0, 732, 732, 732, + 732, 732, 732, 732, 732, 734, 734, 734, 0, 0, + 734, 734, 734, 734, 734, 734, 734, 734, 735, 735, + 735, 0, 0, 735, 735, 735, 735, 735, 735, 735, + 735, 737, 737, 737, 0, 0, 737, 737, 737, 737, + 737, 737, 737, 737, 742, 742, 742, 0, 0, 742, + + 0, 742, 742, 742, 742, 742, 742, 743, 743, 743, + 0, 0, 743, 0, 743, 743, 743, 743, 743, 743, + 748, 748, 748, 0, 0, 748, 748, 748, 748, 748, + 748, 748, 748, 749, 749, 749, 0, 0, 749, 0, + 749, 749, 749, 749, 749, 749, 754, 754, 754, 0, + 0, 754, 0, 0, 754, 754, 754, 754, 754, 755, + 755, 755, 0, 0, 755, 0, 755, 755, 755, 755, + 755, 755, 756, 756, 756, 0, 0, 756, 0, 756, + 756, 756, 756, 756, 756, 761, 761, 761, 0, 0, + 761, 761, 761, 761, 761, 761, 761, 761, 762, 762, + + 762, 0, 0, 762, 0, 762, 762, 762, 762, 762, + 762, 765, 765, 765, 0, 0, 765, 0, 765, 765, + 765, 765, 765, 765, 768, 768, 768, 0, 0, 768, + 0, 0, 768, 768, 768, 768, 768, 769, 769, 769, + 0, 0, 769, 0, 769, 769, 769, 769, 769, 769, + 776, 776, 776, 0, 0, 776, 776, 776, 776, 776, + 776, 776, 776, 777, 777, 777, 0, 0, 777, 0, + 777, 777, 777, 777, 777, 777, 781, 781, 781, 0, + 0, 781, 781, 781, 781, 781, 781, 781, 781, 782, + 782, 782, 0, 0, 782, 782, 782, 782, 782, 782, + + 782, 782, 784, 784, 784, 0, 0, 784, 784, 784, + 784, 784, 784, 784, 784, 791, 791, 791, 0, 0, + 791, 0, 791, 791, 791, 791, 791, 791, 794, 794, + 794, 0, 0, 794, 0, 794, 794, 794, 794, 794, + 794, 798, 798, 798, 0, 0, 798, 0, 0, 0, + 798, 798, 798, 798, 799, 799, 799, 0, 0, 799, + 0, 799, 799, 799, 799, 799, 799, 800, 800, 800, + 0, 0, 800, 0, 800, 800, 800, 800, 800, 800, + 803, 803, 803, 0, 0, 803, 0, 0, 0, 803, + 803, 803, 803, 805, 805, 805, 0, 0, 805, 0, + + 805, 805, 805, 805, 805, 805, 0, 899, 899, 805, + 899, 899, 899, 899, 900, 900, 0, 900, 900, 900, + 900, 909, 909, 909, 909, 0, 0, 805, 806, 806, + 806, 0, 0, 806, 0, 806, 806, 806, 806, 806, + 806, 807, 807, 807, 0, 0, 807, 0, 807, 807, + 807, 807, 807, 807, 809, 809, 809, 0, 0, 809, + 0, 0, 0, 809, 809, 809, 809, 0, 902, 902, + 809, 902, 902, 902, 902, 903, 903, 0, 903, 903, + 903, 903, 910, 910, 910, 910, 0, 0, 809, 810, + 810, 810, 0, 0, 810, 0, 0, 0, 810, 810, + + 810, 810, 0, 905, 905, 810, 905, 905, 905, 905, + 916, 916, 916, 0, 0, 916, 917, 917, 917, 917, + 0, 0, 0, 810, 811, 811, 811, 0, 0, 811, + 0, 811, 811, 811, 811, 811, 811, 924, 924, 924, + 811, 0, 924, 925, 925, 925, 925, 932, 932, 932, + 0, 0, 932, 933, 933, 933, 933, 0, 811, 812, + 812, 812, 0, 0, 812, 0, 812, 812, 812, 812, + 812, 812, 813, 813, 813, 0, 0, 813, 0, 813, + 813, 813, 813, 813, 813, 815, 815, 815, 0, 0, + 815, 0, 0, 0, 815, 815, 815, 815, 0, 0, + + 0, 815, 934, 934, 934, 934, 938, 938, 938, 938, + 939, 939, 939, 939, 941, 941, 941, 941, 0, 815, + 816, 816, 816, 0, 0, 816, 0, 0, 0, 816, + 816, 816, 816, 0, 0, 0, 816, 942, 942, 942, + 942, 0, 0, 940, 940, 940, 940, 963, 963, 963, + 940, 0, 963, 0, 816, 817, 817, 817, 0, 963, + 817, 0, 817, 817, 817, 817, 817, 817, 940, 0, + 0, 817, 946, 946, 946, 946, 947, 947, 947, 947, + 0, 948, 948, 948, 948, 0, 0, 0, 948, 817, + 819, 819, 819, 0, 0, 819, 0, 0, 0, 819, + + 819, 819, 819, 820, 820, 820, 948, 0, 820, 0, + 820, 820, 820, 820, 820, 820, 821, 821, 821, 0, + 0, 821, 0, 821, 821, 821, 821, 821, 821, 823, + 823, 823, 0, 0, 823, 0, 0, 0, 823, 823, + 823, 823, 0, 0, 0, 823, 949, 949, 949, 949, + 950, 950, 950, 950, 954, 954, 954, 954, 955, 955, + 955, 955, 0, 823, 826, 826, 826, 0, 0, 826, + 0, 826, 826, 826, 826, 826, 826, 827, 827, 827, + 0, 0, 827, 0, 827, 827, 827, 827, 827, 827, + 829, 829, 829, 0, 0, 829, 0, 829, 829, 829, + + 829, 829, 829, 830, 830, 830, 0, 0, 830, 0, + 830, 830, 830, 830, 830, 830, 833, 833, 833, 0, + 0, 833, 0, 0, 0, 833, 833, 833, 833, 834, + 834, 834, 0, 0, 834, 0, 834, 834, 834, 834, + 834, 834, 835, 835, 835, 0, 0, 835, 0, 835, + 835, 835, 835, 835, 835, 839, 839, 839, 0, 0, + 839, 0, 839, 839, 839, 839, 839, 839, 840, 840, + 840, 0, 0, 840, 0, 840, 840, 840, 840, 840, + 840, 842, 842, 842, 0, 0, 842, 0, 842, 842, + 842, 842, 842, 842, 843, 843, 843, 0, 0, 843, + + 0, 843, 843, 843, 843, 843, 843, 846, 846, 846, + 0, 0, 846, 0, 0, 0, 846, 846, 846, 846, + 847, 847, 847, 0, 0, 847, 0, 847, 847, 847, + 847, 847, 847, 848, 848, 848, 0, 0, 848, 0, + 848, 848, 848, 848, 848, 848, 851, 851, 851, 0, + 0, 851, 0, 0, 0, 851, 851, 851, 851, 853, + 853, 853, 0, 0, 853, 0, 853, 853, 853, 853, + 853, 853, 0, 0, 0, 853, 962, 962, 962, 0, + 0, 962, 0, 0, 0, 956, 956, 956, 956, 0, + 0, 0, 956, 853, 854, 854, 854, 0, 0, 854, + + 0, 854, 854, 854, 854, 854, 854, 855, 855, 855, + 956, 962, 855, 0, 855, 855, 855, 855, 855, 855, + 857, 857, 857, 0, 0, 857, 0, 0, 0, 857, + 857, 857, 857, 957, 957, 957, 857, 0, 957, 960, + 960, 960, 0, 0, 960, 964, 964, 964, 0, 0, + 964, 0, 0, 0, 857, 858, 858, 858, 0, 0, + 858, 0, 0, 0, 858, 858, 858, 858, 965, 965, + 965, 858, 0, 965, 0, 0, 957, 966, 966, 966, + 0, 960, 966, 967, 0, 967, 0, 0, 967, 858, + 859, 859, 859, 0, 0, 859, 0, 859, 859, 859, + + 859, 859, 859, 968, 968, 968, 859, 969, 968, 969, + 0, 970, 969, 970, 0, 971, 970, 971, 0, 0, + 971, 0, 0, 0, 859, 860, 860, 860, 0, 0, + 860, 0, 860, 860, 860, 860, 860, 860, 861, 861, + 861, 0, 0, 861, 0, 861, 861, 861, 861, 861, + 861, 863, 863, 863, 0, 0, 863, 0, 0, 0, + 863, 863, 863, 863, 972, 0, 972, 863, 973, 972, + 973, 0, 0, 973, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 863, 864, 864, 864, 0, + 0, 864, 0, 0, 0, 864, 864, 864, 864, 0, + + 0, 0, 864, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 864, 865, 865, 865, 0, 0, 865, 0, 865, 865, + 865, 865, 865, 865, 0, 0, 0, 865, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 865, 867, 867, 867, 0, + 0, 867, 0, 0, 0, 867, 867, 867, 867, 868, + 868, 868, 0, 0, 868, 0, 868, 868, 868, 868, + 868, 868, 869, 869, 869, 0, 0, 869, 0, 869, + 869, 869, 869, 869, 869, 871, 871, 871, 0, 0, + + 871, 0, 0, 0, 871, 871, 871, 871, 0, 0, + 0, 871, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 871, + 874, 874, 874, 0, 0, 874, 0, 874, 874, 874, + 874, 874, 874, 875, 875, 875, 0, 0, 875, 0, + 875, 875, 875, 875, 875, 875, 877, 877, 877, 0, + 0, 877, 0, 877, 877, 877, 877, 877, 877, 878, + 878, 878, 0, 0, 878, 0, 878, 878, 878, 878, + 878, 878, 881, 881, 881, 0, 0, 881, 0, 0, + 0, 881, 881, 881, 881, 882, 882, 882, 0, 0, + + 882, 0, 882, 882, 882, 882, 882, 882, 883, 883, + 883, 0, 0, 883, 0, 883, 883, 883, 883, 883, + 883, 889, 889, 889, 0, 0, 889, 889, 889, 889, + 889, 889, 889, 889, 890, 890, 890, 0, 0, 890, + 890, 890, 890, 890, 890, 890, 890, 892, 892, 892, + 0, 0, 892, 892, 892, 892, 892, 892, 892, 892, + 893, 893, 893, 0, 0, 893, 893, 893, 893, 893, + 893, 893, 893, 895, 895, 895, 0, 0, 895, 895, + 895, 895, 895, 895, 895, 895, 896, 896, 896, 0, + 0, 896, 896, 896, 896, 896, 896, 896, 896, 898, + + 898, 898, 0, 0, 898, 898, 898, 898, 898, 898, + 898, 898, 901, 901, 901, 0, 0, 901, 901, 901, + 901, 901, 901, 901, 901, 904, 904, 904, 0, 0, + 904, 904, 904, 904, 904, 904, 904, 904, 911, 911, + 911, 0, 0, 911, 0, 911, 911, 911, 911, 911, + 911, 914, 914, 914, 0, 0, 914, 0, 914, 914, + 914, 914, 914, 914, 918, 918, 918, 0, 0, 918, + 0, 0, 0, 918, 918, 918, 918, 919, 919, 919, + 0, 0, 919, 0, 919, 919, 919, 919, 919, 919, + 922, 922, 922, 0, 0, 922, 0, 922, 922, 922, + + 922, 922, 922, 926, 926, 926, 0, 0, 926, 0, + 0, 0, 926, 926, 926, 926, 927, 927, 927, 0, + 0, 927, 0, 927, 927, 927, 927, 927, 927, 930, + 930, 930, 0, 0, 930, 0, 930, 930, 930, 930, + 930, 930, 975, 975, 975, 975, 975, 975, 975, 975, + 976, 976, 976, 976, 976, 976, 976, 976, 977, 977, + 977, 977, 977, 977, 977, 977, 978, 978, 978, 978, + 978, 978, 978, 978, 979, 979, 979, 979, 979, 979, + 979, 979, 980, 0, 0, 980, 981, 0, 0, 981, + 982, 0, 0, 982, 0, 982, 982, 982, 983, 983, + + 983, 983, 983, 983, 983, 983, 984, 0, 0, 984, + 0, 984, 984, 985, 985, 985, 985, 985, 985, 985, + 985, 986, 986, 0, 986, 0, 986, 986, 986, 987, + 987, 987, 987, 987, 987, 987, 987, 988, 988, 0, + 988, 988, 988, 988, 988, 989, 989, 989, 989, 989, + 989, 989, 989, 990, 990, 990, 990, 990, 990, 990, + 990, 991, 991, 0, 0, 991, 991, 993, 993, 993, + 993, 993, 993, 993, 993, 994, 994, 994, 994, 994, + 994, 994, 994, 995, 995, 995, 995, 995, 995, 995, + 995, 996, 996, 996, 996, 996, 996, 996, 996, 998, + + 998, 998, 998, 998, 998, 998, 998, 999, 999, 999, + 999, 999, 999, 999, 999, 1000, 1000, 1000, 1000, 1000, + 1000, 1000, 1000, 1001, 1001, 0, 1001, 0, 1001, 1001, + 1001, 1002, 1002, 1002, 1002, 1002, 1002, 1002, 1002, 1004, + 1004, 0, 1004, 1004, 1004, 1004, 1004, 1005, 1005, 1005, + 1005, 1005, 1005, 1005, 1005, 1006, 0, 0, 1006, 1007, + 1007, 1007, 1007, 1007, 1007, 1007, 1007, 1008, 1008, 1008, + 1008, 1008, 1008, 1008, 1008, 1009, 1009, 0, 0, 1009, + 1009, 1011, 1011, 1011, 1011, 1011, 1011, 1011, 1011, 1012, + 1012, 1012, 1012, 1012, 1012, 1012, 1012, 1013, 1013, 1013, + + 1013, 1013, 1013, 1013, 1013, 1015, 1015, 1015, 1015, 1015, + 1015, 1015, 1015, 1016, 1016, 1016, 1016, 1016, 1016, 1016, + 1016, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1017, 1018, + 1018, 1018, 1018, 1018, 1018, 1018, 1018, 1019, 1019, 1019, + 1019, 1019, 1019, 1019, 1019, 1020, 1020, 1020, 1020, 1020, + 1020, 1020, 1020, 1021, 1021, 1021, 1021, 1021, 1021, 1021, + 1021, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1022, 1023, + 1023, 1023, 1023, 1023, 1023, 1023, 1023, 1024, 1024, 1024, + 1024, 1024, 1024, 1024, 1024, 1025, 1025, 1025, 1025, 1025, + 1025, 1025, 1025, 1026, 1026, 1026, 1026, 1026, 1026, 1026, + + 1026, 1027, 1027, 1027, 1027, 1027, 1027, 1027, 1027, 1028, + 1028, 1028, 1028, 1028, 1028, 1028, 1028, 1029, 1029, 1029, + 1029, 1029, 1029, 1029, 1029, 1030, 0, 0, 1030, 1031, + 1031, 1031, 1031, 1031, 1031, 1031, 1031, 1032, 1032, 1032, + 1032, 1032, 1032, 1032, 1032, 1033, 1033, 1033, 1033, 1033, + 1033, 1033, 1033, 1035, 1035, 1035, 1035, 1035, 1035, 1035, + 1035, 1036, 1036, 1036, 1036, 1036, 1036, 1036, 1036, 1037, + 1037, 1037, 1037, 1037, 1037, 1037, 1037, 1038, 1038, 1038, + 1038, 1038, 1038, 1038, 1038, 1039, 1039, 1039, 1039, 1039, + 1039, 1039, 1039, 1040, 1040, 1040, 1040, 1040, 1040, 1040, + + 1040, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1042, + 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1044, 1044, 1044, 1044, 1044, + 1044, 1044, 1044, 1045, 1045, 1045, 1045, 1045, 1045, 1045, + 1045, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1047, + 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1048, 1048, 1048, + 1048, 1048, 1048, 1048, 1048, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1050, 1050, 1050, 1050, 1050, 1050, 1050, + 1050, 1051, 1051, 1051, 1051, 1051, 1051, 1051, 1051, 1052, + 1052, 1052, 1052, 1052, 1052, 1052, 1052, 1053, 0, 0, + + 1053, 1054, 1054, 1054, 1054, 1054, 1054, 1054, 1054, 1055, + 1055, 1055, 1055, 1055, 1055, 1055, 1055, 1056, 1056, 1056, + 1056, 1056, 1056, 1056, 1056, 1057, 1057, 1057, 1057, 1057, + 1057, 1057, 1057, 1058, 1058, 1058, 1058, 1058, 1058, 1058, + 1058, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1059, 1060, + 1060, 1060, 1060, 1060, 1060, 1060, 1060, 1061, 1061, 1061, + 1061, 1061, 1061, 1061, 1061, 1062, 1062, 1062, 1062, 1062, + 1062, 1062, 1062, 1063, 1063, 1063, 1063, 1063, 1063, 1063, + 1063, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1064, 1065, + 1065, 1065, 1065, 1065, 1065, 1065, 1065, 1066, 1066, 1066, + + 1066, 1066, 1066, 1066, 1066, 1067, 1067, 1067, 1067, 1067, + 1067, 1067, 1067, 1068, 1068, 1068, 1068, 1068, 1068, 1068, + 1068, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1069, 1070, + 1070, 1070, 1070, 1070, 1070, 1070, 1070, 1071, 1071, 1071, + 1071, 1071, 1071, 1071, 1071, 1072, 1072, 1072, 1072, 1072, + 1072, 1072, 1072, 1073, 1073, 1073, 1073, 1073, 1073, 1073, + 1073, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1074, 1075, + 1075, 1075, 1075, 1075, 1075, 1075, 1075, 1076, 1076, 1076, + 1076, 1076, 1076, 1076, 1076, 1077, 1077, 1077, 1077, 1077, + 1077, 1077, 1077, 1078, 1078, 1078, 1078, 1078, 1078, 1078, + + 1078, 1079, 1079, 1079, 1079, 1079, 1079, 1079, 1079, 1080, + 1080, 1080, 1080, 1080, 1080, 1080, 1080, 1081, 0, 0, + 1081, 1082, 1082, 1082, 1082, 1082, 1082, 1082, 1082, 1083, + 1083, 1083, 1083, 1083, 1083, 1083, 1083, 1084, 1084, 1084, + 1084, 1084, 1084, 1084, 1084, 1085, 1085, 1085, 1085, 1085, + 1085, 1085, 1085, 1086, 1086, 1086, 1086, 1086, 1086, 1086, + 1086, 1087, 1087, 1087, 1087, 1087, 1087, 1087, 1087, 1088, + 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1089, 1089, 1089, + 1089, 1089, 1089, 1089, 1089, 1090, 1090, 1090, 1090, 1090, + 1090, 1090, 1090, 1091, 1091, 1091, 1091, 1091, 1091, 1091, + + 1091, 1092, 1092, 1092, 1092, 1092, 1092, 1092, 1092, 1093, + 1093, 1093, 1093, 1093, 1093, 1093, 1093, 1094, 1094, 1094, + 1094, 1094, 1094, 1094, 1094, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1096, 1096, 1096, 1096, 1096, 1096, 1096, + 1096, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1098, + 1098, 1098, 1098, 1098, 1098, 1098, 1098, 1099, 1099, 1099, + 1099, 1099, 1099, 1099, 1099, 1100, 1100, 1100, 1100, 1100, + 1100, 1100, 1100, 1101, 1101, 1101, 1101, 1101, 1101, 1101, + 1101, 1102, 1102, 1102, 1102, 1102, 1102, 1102, 1102, 1103, + 1103, 1103, 1103, 1103, 1103, 1103, 1103, 1104, 1104, 1104, + + 1104, 1104, 1104, 1104, 1104, 1105, 1105, 1105, 1105, 1105, + 1105, 1105, 1105, 1106, 1106, 1106, 1106, 1106, 1106, 1106, + 1106, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1108, + 1108, 1108, 1108, 1108, 1108, 1108, 1108, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1110, 1110, 1110, 1110, 1110, + 1110, 1110, 1110, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1113, + 1113, 1113, 1113, 1113, 1113, 1113, 1113, 1114, 1114, 1114, + 1114, 1114, 1114, 1114, 1114, 1115, 1115, 1115, 1115, 1115, + 1115, 1115, 1115, 1116, 1116, 1116, 1116, 1116, 1116, 1116, + + 1116, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1117, 1118, + 1118, 1118, 1118, 1118, 1118, 1118, 1118, 1119, 1119, 1119, + 1119, 1119, 1119, 1119, 1119, 1120, 1120, 1120, 1120, 1120, + 1120, 1120, 1120, 1121, 1121, 1121, 1121, 1121, 1121, 1121, + 1121, 1122, 1122, 1122, 1122, 1122, 1122, 1122, 1122, 1123, + 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1124, 1124, 1124, + 1124, 1124, 1124, 1124, 1124, 1125, 1125, 1125, 1125, 1125, + 1125, 1125, 1125, 1126, 1126, 1126, 1126, 1126, 1126, 1126, + 1126, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1128, + 0, 0, 1128, 1129, 1129, 1129, 1129, 1129, 1129, 1129, + + 1129, 1130, 1130, 1130, 1130, 1130, 1130, 1130, 1130, 1131, + 1131, 1131, 1131, 1131, 1131, 1131, 1131, 1132, 1132, 1132, + 1132, 1132, 1132, 1132, 1132, 1133, 1133, 1133, 1133, 1133, + 1133, 1133, 1133, 1134, 1134, 1134, 1134, 1134, 1134, 1134, + 1134, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 1135, 1136, + 1136, 0, 1136, 1136, 1136, 1136, 1136, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, + + 974, 974, 974, 974, 974 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "vrmlLexer.lxx" +#define INITIAL 0 +/* +// Filename: vrmlLexer.lxx +// Created by: drose (01Oct04) +// +//////////////////////////////////////////////////////////////////// +// +// PANDA 3D SOFTWARE +// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved +// +// All use of this software is subject to the terms of the Panda 3d +// Software license. You should have received a copy of this license +// along with this source code; you will also find a current copy of +// the license at http://etc.cmu.edu/panda3d/docs/license/ . +// +// To contact the maintainers of this program write to +// panda3d-general@lists.sourceforge.net . +// +//////////////////////////////////////////////////////////////////// +*/ +/************************************************** + * VRML 2.0 Parser + * Copyright (C) 1996 Silicon Graphics, Inc. + * + * Author(s) : Gavin Bell + * Daniel Woods (first port) + ************************************************** + */ +#line 30 "vrmlLexer.lxx" +#include "pandatoolbase.h" + +#include "vrmlNode.h" +#include "vrmlParser.h" +#include "indent.h" +#include "notify.h" + +static int yyinput(void); // declared by flex. +extern "C" int vrmlyywrap(); + +//////////////////////////////////////////////////////////////////// +// Static variables +//////////////////////////////////////////////////////////////////// + +// We'll increment line_number and col_number as we parse the file, so +// that we can report the position of an error. +static int line_number = 0; +static int col_number = 0; + +// current_line holds as much of the current line as will fit. Its +// only purpose is for printing it out to report an error to the user. +static const int max_error_width = 1024; +static char current_line[max_error_width + 1]; + +static int error_count = 0; +static int warning_count = 0; + +// This is the pointer to the current input stream. +static istream *inp = NULL; + +// This is the name of the vrml file we're parsing. We keep it so we +// can print it out for error messages. +static string vrml_filename; + +int vrmlyy_flex_debug = 0; + +extern void vrmlyyerror(const string &); + + /* The YACC parser sets this to a token to direct the lexer */ + /* in cases where just syntax isn't enough: */ +int expectToken = 0; + + /* True when parsing a multiple-valued field: */ +static int parsing_mf = 0; + + /* These are used when parsing SFImage fields: */ +static int sfImageIntsParsed = 0; +static int sfImageIntsExpected = 0; + +// This is used while scanning a quoted string. +static string quoted_string; + +// And this keeps track of the currently-parsing array. +static MFArray *mfarray; + +void +vrml_init_lexer(istream &in, const string &filename) { + vrmlyy_flex_debug = 0; + inp = ∈ + vrml_filename = filename; + line_number = 0; + col_number = 0; + error_count = 0; + warning_count = 0; +} + +//////////////////////////////////////////////////////////////////// +// Internal support functions. +//////////////////////////////////////////////////////////////////// + +int +vrmlyywrap(void) { + return 1; +} + +void +vrmlyyerror(const string &msg) { + cerr << "\nError"; + if (!vrml_filename.empty()) { + cerr << " in " << vrml_filename; + } + cerr + << " at line " << line_number << ", column " << col_number << ":\n" + << current_line << "\n"; + indent(cerr, col_number-1) + << "^\n" << msg << "\n\n"; + + error_count++; +} + +void +vrmlyywarning(const string &msg) { + cerr << "\nWarning"; + if (!vrml_filename.empty()) { + cerr << " in " << vrml_filename; + } + cerr + << " at line " << line_number << ", column " << col_number << ":\n" + << current_line << "\n"; + indent(cerr, col_number-1) + << "^\n" << msg << "\n\n"; + + warning_count++; +} + +// Now define a function to take input from an istream instead of a +// stdio FILE pointer. This is flex-specific. +static void +input_chars(char *buffer, int &result, int max_size) { + nassertv(inp != NULL); + if (*inp) { + inp->read(buffer, max_size); + result = inp->gcount(); + if (result >= 0 && result < max_size) { + // Truncate at the end of the read. + buffer[result] = '\0'; + } + + if (line_number == 0) { + // This is a special case. If we are reading the very first bit + // from the stream, copy it into the current_line array. This + // is because the \n.* rule below, which fills current_line + // normally, doesn't catch the first line. + strncpy(current_line, vrmlyytext, max_error_width); + current_line[max_error_width] = '\0'; + line_number++; + col_number = 0; + + // Truncate it at the newline. + char *end = strchr(current_line, '\n'); + if (end != NULL) { + *end = '\0'; + } + } + + } else { + // End of file or I/O error. + result = 0; + } +} +#undef YY_INPUT +#define YY_INPUT(buffer, result, max_size) input_chars(buffer, result, max_size) + +int extract_int() { + return strtol(yytext, NULL, 0); +} + +double extract_float() { + return atof(yytext); +} + +void extract_vec(double vec[], int num_elements) { + char *p = yytext; + for (int i = 0; i < num_elements; i++) { + vec[i] = strtod(p, &p); + } +} + +/* Normal state: parsing nodes. The initial start state is used */ +/* only to recognize the VRML header. */ +#define NODE 1 + +/* Start tokens for all of the field types, */ +/* except for MFNode and SFNode, which are almost completely handled */ +/* by the parser: */ +#define SFB 2 +#define SFC 3 +#define SFF 4 +#define SFIMG 5 +#define SFI 6 +#define SFR 7 +#define SFS 8 +#define SFT 9 +#define SFV2 10 +#define SFV3 11 + +#define MFC 12 +#define MFF 13 +#define MFI 14 +#define MFR 15 +#define MFS 16 +#define MFV2 17 +#define MFV3 18 + +#define IN_SFS 19 +#define IN_MFS 20 +#define IN_SFIMG 21 + +/* Big hairy expression for floating point numbers: */ +/* Ints are decimal or hex (0x##): */ +/* Whitespace. Using this pattern can screw up currentLineNumber, */ +/* so it is only used wherever it is really convenient and it is */ +/* extremely unlikely that the user will put in a carriage return */ +/* (example: between the floats in an SFVec3f) */ +/* And the same pattern without the newline */ +/* Legal characters to start an identifier */ +/* Legal other characters in an identifier */ +/*idRestChar ([^\x00-\x20\x22\x23\x27\x2b-\x2e\x5b-\x5d\x7b\x7d])*/ +/* Allow hyphen (0x2d) in identifiers. */ +#line 2793 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 222 "vrmlLexer.lxx" + + + + /* Switch into a new start state if the parser */ + /* just told us that we've read a field name */ + /* and should expect a field value (or IS) */ + if (expectToken != 0) { + if (vrmlyy_flex_debug) + fprintf(stderr,"LEX--> Start State %d\n", expectToken); + + /* + * Annoying. This big switch is necessary because + * LEX wants to assign particular numbers to start + * tokens, and YACC wants to define all the tokens + * used, too. Sigh. + */ + switch(expectToken) { + case SFBOOL: BEGIN SFB; break; + case SFCOLOR: BEGIN SFC; break; + case SFFLOAT: BEGIN SFF; break; + case SFIMAGE: BEGIN SFIMG; break; + case SFINT32: BEGIN SFI; break; + case SFROTATION: BEGIN SFR; break; + case SFSTRING: BEGIN SFS; break; + case SFTIME: BEGIN SFT; break; + case SFVEC2F: BEGIN SFV2; break; + case SFVEC3F: BEGIN SFV3; break; + case MFCOLOR: BEGIN MFC; break; + case MFFLOAT: BEGIN MFF; break; + case MFINT32: BEGIN MFI; break; + case MFROTATION: BEGIN MFR; break; + case MFSTRING: BEGIN MFS; break; + case MFVEC2F: BEGIN MFV2; break; + case MFVEC3F: BEGIN MFV3; break; + + /* SFNode and MFNode are special. Here the lexer just returns */ + /* "marker tokens" so the parser knows what type of field is */ + /* being parsed; unlike the other fields, parsing of SFNode/MFNode */ + /* field happens in the parser. */ + case MFNODE: expectToken = 0; return MFNODE; + case SFNODE: expectToken = 0; return SFNODE; + + default: vrmlyyerror("ACK: Bad expectToken"); break; + } + } + + + /* This is more complicated than they really need to be because */ + /* I was ambitious and made the whitespace-matching rule aggressive */ +#line 2994 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 975 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 8258 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 271 "vrmlLexer.lxx" +{ + BEGIN NODE; +} + YY_BREAK +/* The lexer is in the NODE state when parsing nodes, either */ +/* top-level nodes in the .wrl file, in a prototype implementation, */ +/* or when parsing the contents of SFNode or MFNode fields. */ +case 2: +YY_RULE_SETUP +#line 278 "vrmlLexer.lxx" +{ return PROTO; } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 279 "vrmlLexer.lxx" +{ return EXTERNPROTO; } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 280 "vrmlLexer.lxx" +{ return DEF; } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 281 "vrmlLexer.lxx" +{ return USE; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 282 "vrmlLexer.lxx" +{ return TO; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 283 "vrmlLexer.lxx" +{ return IS; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 284 "vrmlLexer.lxx" +{ return ROUTE; } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 285 "vrmlLexer.lxx" +{ return SFN_NULL; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 286 "vrmlLexer.lxx" +{ return EVENTIN; } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 287 "vrmlLexer.lxx" +{ return EVENTOUT; } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 288 "vrmlLexer.lxx" +{ return FIELD; } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 289 "vrmlLexer.lxx" +{ return EXPOSEDFIELD; } + YY_BREAK +/* Legal identifiers: */ +case 14: +YY_RULE_SETUP +#line 292 "vrmlLexer.lxx" +{ + vrmlyylval.string = strdup(yytext); + return IDENTIFIER; +} + YY_BREAK +/* This hopefully won't bitch things too much. It's not legal for + an identifier to begin with a digit, but Form-Z writes out VRML + files that do. So we'll allow it. Hopefully the start states + will keep them sorted out. */ +case 15: +YY_RULE_SETUP +#line 300 "vrmlLexer.lxx" +{ + vrmlyylval.string = strdup(yytext); + return IDENTIFIER; +} + YY_BREAK +/* All fields may have an IS declaration: */ +case 16: +YY_RULE_SETUP +#line 306 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + yyless(0); +} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 312 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + yyless(0); /* put back the IS */ +} + YY_BREAK +/* All MF field types other than MFNode are completely parsed here */ +/* in the lexer, and one token is returned to the parser. They all */ +/* share the same rules for open and closing brackets: */ +case 18: +YY_RULE_SETUP +#line 321 "vrmlLexer.lxx" +{ + if (parsing_mf) vrmlyyerror("Double ["); + parsing_mf = 1; + mfarray = new MFArray; +} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 327 "vrmlLexer.lxx" +{ + if (!parsing_mf) vrmlyyerror("Unmatched ]"); + int fieldType = expectToken; + BEGIN NODE; + parsing_mf = 0; + expectToken = 0; + vrmlyylval.fv._mf = mfarray; + return fieldType; +} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 337 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._sfbool = true; + return SFBOOL; +} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 344 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._sfbool = false; + return SFBOOL; +} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 351 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._sfint32 = extract_int(); + return SFINT32; +} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 358 "vrmlLexer.lxx" +{ + VrmlFieldValue v; + v._sfint32 = extract_int(); + if (parsing_mf) { + mfarray->push_back(v); + } else { + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._mf = new MFArray; + vrmlyylval.fv._mf->push_back(v); + return MFINT32; + } +} + YY_BREAK +/* All the floating-point types are pretty similar: */ +case 24: +YY_RULE_SETUP +#line 373 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._sffloat = extract_float(); + return SFFLOAT; +} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 380 "vrmlLexer.lxx" +{ + VrmlFieldValue v; + v._sffloat = extract_float(); + if (parsing_mf) { + /* Add to array... */ + mfarray->push_back(v); + } else { + /* No open bracket means a single value: */ + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._mf = new MFArray; + vrmlyylval.fv._mf->push_back(v); + return MFFLOAT; + } +} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 396 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + extract_vec(vrmlyylval.fv._sfvec, 2); + return SFVEC2F; +} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 403 "vrmlLexer.lxx" +{ + VrmlFieldValue v; + extract_vec(v._sfvec, 2); + if (parsing_mf) { + mfarray->push_back(v); + } else { + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._mf = new MFArray; + vrmlyylval.fv._mf->push_back(v); + return MFVEC2F; + } +} + YY_BREAK +case 28: +YY_RULE_SETUP +#line 417 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + extract_vec(vrmlyylval.fv._sfvec, 3); + return SFVEC3F; +} + YY_BREAK +case 29: +YY_RULE_SETUP +#line 424 "vrmlLexer.lxx" +{ + VrmlFieldValue v; + extract_vec(v._sfvec, 3); + if (parsing_mf) { + mfarray->push_back(v); + } else { + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._mf = new MFArray; + vrmlyylval.fv._mf->push_back(v); + return MFVEC3F; + } +} + YY_BREAK +case 30: +YY_RULE_SETUP +#line 438 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + extract_vec(vrmlyylval.fv._sfvec, 4); + return SFROTATION; +} + YY_BREAK +case 31: +YY_RULE_SETUP +#line 445 "vrmlLexer.lxx" +{ + VrmlFieldValue v; + extract_vec(v._sfvec, 4); + if (parsing_mf) { + mfarray->push_back(v); + } else { + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._mf = new MFArray; + vrmlyylval.fv._mf->push_back(v); + return MFROTATION; + } +} + YY_BREAK +case 32: +YY_RULE_SETUP +#line 459 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + extract_vec(vrmlyylval.fv._sfvec, 3); + return SFCOLOR; +} + YY_BREAK +case 33: +YY_RULE_SETUP +#line 466 "vrmlLexer.lxx" +{ + VrmlFieldValue v; + extract_vec(v._sfvec, 3); + if (parsing_mf) { + mfarray->push_back(v); + } else { + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._mf = new MFArray; + vrmlyylval.fv._mf->push_back(v); + return MFCOLOR; + } +} + YY_BREAK +case 34: +YY_RULE_SETUP +#line 480 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._sffloat = extract_float(); + return SFTIME; +} + YY_BREAK +/* SFString/MFString */ +case 35: +YY_RULE_SETUP +#line 488 "vrmlLexer.lxx" +{ + BEGIN IN_SFS; + quoted_string = ""; +} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 493 "vrmlLexer.lxx" +{ + BEGIN IN_MFS; + quoted_string = ""; +} + YY_BREAK +/* Anything besides open-quote (or whitespace) is an error: */ +case 37: +YY_RULE_SETUP +#line 499 "vrmlLexer.lxx" +{ + vrmlyyerror("String missing open-quote"); + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._sfstring = strdup(""); + return SFSTRING; +} + YY_BREAK +/* Expect open-quote, open-bracket, or whitespace: */ +case 38: +YY_RULE_SETUP +#line 508 "vrmlLexer.lxx" +{ + vrmlyyerror("String missing open-quote"); + BEGIN NODE; + expectToken = 0; + return MFSTRING; +} + YY_BREAK +/* Backslashed-quotes are OK: */ +case 39: +YY_RULE_SETUP +#line 516 "vrmlLexer.lxx" +{ + quoted_string += '"'; +} + YY_BREAK +/* Gobble up anything besides quotes and newlines. */ +/* Newlines are legal in strings, but we exclude them here so */ +/* that line number are counted correctly by the catch-all newline */ +/* rule that applies to everything. */ +case 40: +YY_RULE_SETUP +#line 524 "vrmlLexer.lxx" +{ + quoted_string += yytext; +} + YY_BREAK +/* Quote ends the string: */ +case 41: +YY_RULE_SETUP +#line 529 "vrmlLexer.lxx" +{ + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._sfstring = strdup(quoted_string.c_str()); + return SFSTRING; +} + YY_BREAK +case 42: +YY_RULE_SETUP +#line 536 "vrmlLexer.lxx" +{ + VrmlFieldValue v; + v._sfstring = strdup(quoted_string.c_str()); + if (parsing_mf) { + BEGIN MFS; + mfarray->push_back(v); + quoted_string = ""; + } else { + BEGIN NODE; + expectToken = 0; + vrmlyylval.fv._mf = new MFArray; + vrmlyylval.fv._mf->push_back(v); + return MFSTRING; + } +} + YY_BREAK +/* SFImage: width height numComponents then width*height integers: */ +case 43: +YY_RULE_SETUP +#line 553 "vrmlLexer.lxx" +{ int w, h; + sscanf(yytext, "%d %d", &w, &h); + sfImageIntsExpected = 1+w*h; + sfImageIntsParsed = 0; + BEGIN IN_SFIMG; + } + YY_BREAK +case 44: +YY_RULE_SETUP +#line 559 "vrmlLexer.lxx" +{ ++sfImageIntsParsed; + if (sfImageIntsParsed == sfImageIntsExpected) { + BEGIN NODE; expectToken = 0; return SFIMAGE; + } + } + YY_BREAK +/* Whitespace and catch-all rules apply to all start states: */ +case 45: +YY_RULE_SETUP +#line 566 "vrmlLexer.lxx" +; + YY_BREAK +/* This is also whitespace, but we'll keep track of line number */ +/* to report in errors: */ +case 46: +YY_RULE_SETUP +#line 569 "vrmlLexer.lxx" +; + YY_BREAK +/* This catch-all rule catches anything not covered by any of */ +/* the above: */ +case 47: +YY_RULE_SETUP +#line 573 "vrmlLexer.lxx" +{ return yytext[0]; } + YY_BREAK +case 48: +YY_RULE_SETUP +#line 575 "vrmlLexer.lxx" +ECHO; + YY_BREAK +#line 3541 "lex.yy.c" +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(NODE): +case YY_STATE_EOF(SFB): +case YY_STATE_EOF(SFC): +case YY_STATE_EOF(SFF): +case YY_STATE_EOF(SFIMG): +case YY_STATE_EOF(SFI): +case YY_STATE_EOF(SFR): +case YY_STATE_EOF(SFS): +case YY_STATE_EOF(SFT): +case YY_STATE_EOF(SFV2): +case YY_STATE_EOF(SFV3): +case YY_STATE_EOF(MFC): +case YY_STATE_EOF(MFF): +case YY_STATE_EOF(MFI): +case YY_STATE_EOF(MFR): +case YY_STATE_EOF(MFS): +case YY_STATE_EOF(MFV2): +case YY_STATE_EOF(MFV3): +case YY_STATE_EOF(IN_SFS): +case YY_STATE_EOF(IN_MFS): +case YY_STATE_EOF(IN_SFIMG): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 975 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 975 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 974); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 575 "vrmlLexer.lxx" diff --git a/pandatool/src/vrml/vrmlParser.cxx.prebuilt b/pandatool/src/vrml/vrmlParser.cxx.prebuilt new file mode 100644 index 0000000000..d385914879 --- /dev/null +++ b/pandatool/src/vrml/vrmlParser.cxx.prebuilt @@ -0,0 +1,1761 @@ +/* A Bison parser, made from vrmlParser.yxx + by GNU bison 1.35. */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define yyparse vrmlyyparse +#define yylex vrmlyylex +#define yyerror vrmlyyerror +#define yylval vrmlyylval +#define yychar vrmlyychar +#define yydebug vrmlyydebug +#define yynerrs vrmlyynerrs +# define IDENTIFIER 257 +# define DEF 258 +# define USE 259 +# define PROTO 260 +# define EXTERNPROTO 261 +# define TO 262 +# define IS 263 +# define ROUTE 264 +# define SFN_NULL 265 +# define EVENTIN 266 +# define EVENTOUT 267 +# define FIELD 268 +# define EXPOSEDFIELD 269 +# define SFBOOL 270 +# define SFCOLOR 271 +# define SFFLOAT 272 +# define SFIMAGE 273 +# define SFINT32 274 +# define SFNODE 275 +# define SFROTATION 276 +# define SFSTRING 277 +# define SFTIME 278 +# define SFVEC2F 279 +# define SFVEC3F 280 +# define MFCOLOR 281 +# define MFFLOAT 282 +# define MFINT32 283 +# define MFROTATION 284 +# define MFSTRING 285 +# define MFVEC2F 286 +# define MFVEC3F 287 +# define MFNODE 288 + +#line 27 "vrmlParser.yxx" + + +// +// Parser for VRML 2.0 files. +// This is a minimal parser that does NOT generate an in-memory scene graph. +// + +// The original parser was developed on a Windows 95 PC with +// Borland's C++ 5.0 development tools. This was then ported +// to a Windows 95 PC with Microsoft's MSDEV C++ 4.0 development +// tools. The port introduced the ifdef's for +// USING_BORLAND_CPP_5 : since this provides a "std namespace", +// TWO_ARGUMENTS_FOR_STL_STACK : STL is a moving target. The stack template +// class takes either one or two arguments. + +#include "pandatoolbase.h" +#include "vrmlLexerDefs.h" +#include "vrmlNodeType.h" +#include "vrmlNode.h" +#include "notify.h" +#include "plist.h" +#include + +//#define YYDEBUG 1 + +// Currently-being-define proto. Prototypes may be nested, so a stack +// is needed: + +stack< VrmlNodeType*, plist > currentProtoStack; + +// This is used to keep track of which field in which type of node is being +// parsed. Field are nested (nodes are contained inside MFNode/SFNode fields) +// so a stack of these is needed: +typedef struct { + const VrmlNodeType *nodeType; + const char *fieldName; + const VrmlNodeType::NameTypeRec *typeRec; +} FieldRec; + +stack< FieldRec*, plist > currentField; + +// Similarly for the node entries (which contain the actual values for +// the fields as they are encountered): + +stack< VrmlNode*, plist > currentNode; + +// This is used when the parser knows what kind of token it expects +// to get next-- used when parsing field values (whose types are declared +// and read by the parser) and at certain other places: +extern int expectToken; + +// This is where we store the parsed scene. +VrmlScene *parsed_scene = NULL; + +// Some helper routines defined below: +static void beginProto(const char *); +static void endProto(); +int addField(const char *type, const char *name, const VrmlFieldValue *dflt = NULL); +int addEventIn(const char *type, const char *name, const VrmlFieldValue *dflt = NULL); +int addEventOut(const char *type, const char *name, const VrmlFieldValue *dflt = NULL); +int addExposedField(const char *type, const char *name, const VrmlFieldValue *dflt = NULL); +int add(void (VrmlNodeType::*func)(const char *, int, const VrmlFieldValue *), + const char *typeString, const char *name, + const VrmlFieldValue *dflt); +int fieldType(const char *type); +void enterNode(const char *); +VrmlNode *exitNode(); +void inScript(); +void enterField(const char *); +void storeField(const VrmlFieldValue &value); +void exitField(); +void expect(int type); + +extern void vrmlyyerror(const string &); + +//////////////////////////////////////////////////////////////////// +// Defining the interface to the parser. +//////////////////////////////////////////////////////////////////// + +void +vrml_init_parser(istream &in, const string &filename) { + //yydebug = 0; + vrml_init_lexer(in, filename); +} + +void +vrml_cleanup_parser() { +} + + +#line 118 "vrmlParser.yxx" +#ifndef YYSTYPE +typedef union { + char *string; + VrmlFieldValue fv; + VrmlNode *node; + MFArray *mfarray; + SFNodeRef nodeRef; + VrmlScene *scene; +} yystype; +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 +#endif +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + + + +#define YYFINAL 125 +#define YYFLAG -32768 +#define YYNTBASE 40 + +/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ +#define YYTRANSLATE(x) ((unsigned)(x) <= 288 ? yytranslate[x] : 65) + +/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ +static const char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 39, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 35, 2, 36, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 37, 2, 38, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34 +}; + +#if YYDEBUG +static const short yyprhs[] = +{ + 0, 0, 2, 3, 6, 9, 12, 14, 18, 21, + 23, 25, 26, 36, 37, 38, 47, 48, 51, 55, + 59, 60, 66, 67, 73, 74, 77, 81, 85, 89, + 93, 102, 103, 109, 110, 113, 114, 118, 120, 122, + 126, 130, 131, 137, 143, 149, 151, 153, 155, 157, + 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, + 179, 181, 183, 186, 189, 192, 195, 199, 201, 202 +}; +static const short yyrhs[] = +{ + 41, 0, 0, 41, 42, 0, 41, 43, 0, 41, + 55, 0, 56, 0, 4, 3, 56, 0, 5, 3, + 0, 44, 0, 46, 0, 0, 6, 3, 45, 35, + 49, 36, 37, 41, 38, 0, 0, 0, 7, 3, + 47, 35, 53, 36, 48, 62, 0, 0, 49, 50, + 0, 12, 3, 3, 0, 13, 3, 3, 0, 0, + 14, 3, 3, 51, 62, 0, 0, 15, 3, 3, + 52, 62, 0, 0, 53, 54, 0, 12, 3, 3, + 0, 13, 3, 3, 0, 14, 3, 3, 0, 15, + 3, 3, 0, 10, 3, 39, 3, 8, 3, 39, + 3, 0, 0, 3, 57, 37, 58, 38, 0, 0, + 58, 59, 0, 0, 3, 60, 62, 0, 55, 0, + 43, 0, 12, 3, 3, 0, 13, 3, 3, 0, + 0, 14, 3, 3, 61, 62, 0, 12, 3, 3, + 9, 3, 0, 13, 3, 3, 9, 3, 0, 16, + 0, 17, 0, 27, 0, 18, 0, 28, 0, 19, + 0, 20, 0, 29, 0, 22, 0, 30, 0, 23, + 0, 31, 0, 24, 0, 25, 0, 32, 0, 26, + 0, 33, 0, 21, 42, 0, 21, 11, 0, 34, + 63, 0, 9, 3, 0, 35, 64, 36, 0, 42, + 0, 0, 64, 42, 0 +}; + +#endif + +#if YYDEBUG +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const short yyrline[] = +{ + 0, 149, 155, 160, 167, 168, 171, 178, 184, 192, + 194, 197, 197, 203, 203, 203, 209, 211, 214, 217, + 219, 219, 230, 230, 243, 245, 248, 251, 253, 255, + 259, 264, 264, 269, 271, 274, 274, 282, 283, 286, + 287, 288, 288, 292, 294, 298, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 317, 318, 324, 325, 328, 333, 342, 347 +}; +#endif + + +#if (YYDEBUG) || defined YYERROR_VERBOSE + +/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ +static const char *const yytname[] = +{ + "$", "error", "$undefined.", "IDENTIFIER", "DEF", "USE", "PROTO", + "EXTERNPROTO", "TO", "IS", "ROUTE", "SFN_NULL", "EVENTIN", "EVENTOUT", + "FIELD", "EXPOSEDFIELD", "SFBOOL", "SFCOLOR", "SFFLOAT", "SFIMAGE", + "SFINT32", "SFNODE", "SFROTATION", "SFSTRING", "SFTIME", "SFVEC2F", + "SFVEC3F", "MFCOLOR", "MFFLOAT", "MFINT32", "MFROTATION", "MFSTRING", + "MFVEC2F", "MFVEC3F", "MFNODE", "'['", "']'", "'{'", "'}'", "'.'", + "vrmlscene", "declarations", "nodeDeclaration", "protoDeclaration", + "proto", "@1", "externproto", "@2", "@3", "interfaceDeclarations", + "interfaceDeclaration", "@4", "@5", "externInterfaceDeclarations", + "externInterfaceDeclaration", "routeDeclaration", "node", "@6", + "nodeGuts", "nodeGut", "@7", "@8", "fieldValue", "mfnodeValue", "nodes", 0 +}; +#endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const short yyr1[] = +{ + 0, 40, 41, 41, 41, 41, 42, 42, 42, 43, + 43, 45, 44, 47, 48, 46, 49, 49, 50, 50, + 51, 50, 52, 50, 53, 53, 54, 54, 54, 54, + 55, 57, 56, 58, 58, 60, 59, 59, 59, 59, + 59, 61, 59, 59, 59, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, + 62, 62, 62, 62, 62, 62, 63, 63, 64, 64 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const short yyr2[] = +{ + 0, 1, 0, 2, 2, 2, 1, 3, 2, 1, + 1, 0, 9, 0, 0, 8, 0, 2, 3, 3, + 0, 5, 0, 5, 0, 2, 3, 3, 3, 3, + 8, 0, 5, 0, 2, 0, 3, 1, 1, 3, + 3, 0, 5, 5, 5, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 2, 2, 2, 3, 1, 0, 2 +}; + +/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE + doesn't specify something else to do. Zero means the default is an + error. */ +static const short yydefact[] = +{ + 2, 1, 31, 0, 0, 0, 0, 0, 3, 4, + 9, 10, 5, 6, 0, 0, 8, 11, 13, 0, + 33, 7, 0, 0, 0, 0, 16, 24, 0, 35, + 0, 0, 0, 32, 38, 37, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, + 0, 0, 0, 0, 14, 25, 0, 0, 45, 46, + 48, 50, 51, 0, 53, 55, 57, 58, 60, 47, + 49, 52, 54, 56, 59, 61, 0, 36, 39, 40, + 41, 0, 0, 0, 0, 2, 0, 0, 0, 0, + 0, 0, 65, 63, 62, 68, 67, 64, 0, 0, + 0, 18, 19, 20, 22, 0, 26, 27, 28, 29, + 15, 30, 0, 43, 44, 42, 0, 0, 12, 66, + 69, 21, 23, 0, 0, 0 +}; + +static const short yydefgoto[] = +{ + 123, 1, 8, 9, 10, 22, 11, 23, 90, 37, + 49, 116, 117, 38, 55, 12, 13, 14, 25, 36, + 40, 100, 77, 97, 112 +}; + +static const short yypact[] = +{ + -32768, 79,-32768, -1, 0, 3, 4, 6,-32768,-32768, + -32768,-32768,-32768,-32768, -23, 18,-32768,-32768,-32768, -10, + -32768,-32768, 5, 7, 32, -2,-32768,-32768, 33,-32768, + 40, 41, 45,-32768,-32768,-32768,-32768, 19, 66, 48, + 43, 50, 51, 54, 84, 85, 87, 88, 55,-32768, + 90, 91, 92, 93,-32768,-32768, 58, 95,-32768,-32768, + -32768,-32768,-32768, 34,-32768,-32768,-32768,-32768,-32768,-32768, + -32768,-32768,-32768,-32768,-32768,-32768, 23,-32768, 94, 96, + -32768, 97, 98, 101, 103,-32768, 104, 105, 106, 107, + 43, 108,-32768,-32768,-32768,-32768,-32768,-32768, 109, 110, + 43,-32768,-32768,-32768,-32768, 12,-32768,-32768,-32768,-32768, + -32768,-32768, 20,-32768,-32768,-32768, 43, 43,-32768,-32768, + -32768,-32768,-32768, 99, 114,-32768 +}; + +static const short yypgoto[] = +{ + -32768, 30, -63, 100,-32768,-32768,-32768,-32768,-32768,-32768, + -32768,-32768,-32768,-32768,-32768, 102, 111,-32768,-32768,-32768, + -32768,-32768, -70,-32768,-32768 +}; + + +#define YYLAST 127 + + +static const short yytable[] = +{ + 94, 29, 15, 16, 5, 6, 17, 18, 7, 19, + 30, 31, 32, 96, 20, 2, 3, 4, 5, 6, + 110, 2, 7, 2, 3, 4, 2, 3, 4, 24, + 115, 44, 45, 46, 47, 28, 33, 2, 3, 4, + 26, 39, 27, 41, 42, 93, 121, 122, 43, 120, + 118, 56, 57, 78, 79, 48, 119, 80, 95, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 50, 51, + 52, 53, 2, 3, 4, 5, 6, 81, 82, 7, + 83, 84, 85, 86, 87, 88, 89, 91, 92, 124, + 101, 102, 54, 98, 103, 99, 104, 106, 107, 108, + 109, 111, 113, 114, 125, 105, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 34, 21, 35 +}; + +static const short yycheck[] = +{ + 63, 3, 3, 3, 6, 7, 3, 3, 10, 3, + 12, 13, 14, 76, 37, 3, 4, 5, 6, 7, + 90, 3, 10, 3, 4, 5, 3, 4, 5, 39, + 100, 12, 13, 14, 15, 3, 38, 3, 4, 5, + 35, 8, 35, 3, 3, 11, 116, 117, 3, 112, + 38, 3, 9, 3, 3, 36, 36, 3, 35, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 12, 13, + 14, 15, 3, 4, 5, 6, 7, 3, 3, 10, + 3, 3, 37, 3, 3, 3, 3, 39, 3, 0, + 3, 3, 36, 9, 3, 9, 3, 3, 3, 3, + 3, 3, 3, 3, 0, 85, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 25, 15, 25 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/bison/bison.simple" + +/* Skeleton output parser for bison, + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software + Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser when + the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; +# if YYLSP_NEEDED + YYLTYPE yyls; +# endif +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# if YYLSP_NEEDED +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAX) +# else +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) +# endif + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). + + When YYLLOC_DEFAULT is run, CURRENT is set the location of the + first token. By default, to implement support for ranges, extend + its range to the last symbol. */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#if YYPURE +# if YYLSP_NEEDED +# ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) +# else +# define YYLEX yylex (&yylval, &yylloc) +# endif +# else /* !YYLSP_NEEDED */ +# ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +# else +# define YYLEX yylex (&yylval) +# endif +# endif /* !YYLSP_NEEDED */ +#else /* !YYPURE */ +# define YYLEX yylex () +#endif /* !YYPURE */ + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + +#ifdef YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif +#endif + +#line 315 "/usr/share/bison/bison.simple" + + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +# ifdef YYPARSE_PARAM +int yyparse (void *); +# else +int yyparse (void); +# endif +#endif + +/* YY_DECL_VARIABLES -- depending whether we use a pure parser, + variables are global, or local to YYPARSE. */ + +#define YY_DECL_NON_LSP_VARIABLES \ +/* The lookahead symbol. */ \ +int yychar; \ + \ +/* The semantic value of the lookahead symbol. */ \ +YYSTYPE yylval; \ + \ +/* Number of parse errors so far. */ \ +int yynerrs; + +#if YYLSP_NEEDED +# define YY_DECL_VARIABLES \ +YY_DECL_NON_LSP_VARIABLES \ + \ +/* Location data for the lookahead symbol. */ \ +YYLTYPE yylloc; +#else +# define YY_DECL_VARIABLES \ +YY_DECL_NON_LSP_VARIABLES +#endif + + +/* If nonreentrant, generate the variables here. */ + +#if !YYPURE +YY_DECL_VARIABLES +#endif /* !YYPURE */ + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + /* If reentrant, generate the variables here. */ +#if YYPURE + YY_DECL_VARIABLES +#endif /* !YYPURE */ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + +#if YYLSP_NEEDED + /* The location stack. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; +#endif + +#if YYLSP_NEEDED +# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +# define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + YYSIZE_T yystacksize = YYINITDEPTH; + + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; +#if YYLSP_NEEDED + YYLTYPE yyloc; +#endif + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; +#if YYLSP_NEEDED + yylsp = yyls; +#endif + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. */ +# if YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yyls1, yysize * sizeof (*yylsp), + &yystacksize); + yyls = yyls1; +# else + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); +# endif + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + goto yyoverflowlab; + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); +# if YYLSP_NEEDED + YYSTACK_RELOCATE (yyls); +# endif +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; +#if YYLSP_NEEDED + yylsp = yyls + yysize - 1; +#endif + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yychar1 = YYTRANSLATE (yychar); + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + YYFPRINTF (stderr, "Next token is %d (%s", + yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise + meaning of a token, for further debugging info. */ +# ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +# endif + YYFPRINTF (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#if YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to the semantic value of + the lookahead token. This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + +#if YYLSP_NEEDED + /* Similarly for the default location. Let the user run additional + commands if for instance locations are ranges. */ + yyloc = yylsp[1-yylen]; + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); +#endif + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + int yyi; + + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + switch (yyn) { + +case 1: +#line 150 "vrmlParser.yxx" +{ + parsed_scene = yyvsp[0].scene; +} + break; +case 2: +#line 157 "vrmlParser.yxx" +{ + yyval.scene = new VrmlScene; +} + break; +case 3: +#line 161 "vrmlParser.yxx" +{ + Declaration d; + d._node = yyvsp[0].nodeRef; + yyvsp[-1].scene->push_back(d); + yyval.scene = yyvsp[-1].scene; +} + break; +case 6: +#line 173 "vrmlParser.yxx" +{ + yyval.nodeRef._p = yyvsp[0].node; + yyval.nodeRef._type = SFNodeRef::T_unnamed; + yyval.nodeRef._name = NULL; +} + break; +case 7: +#line 179 "vrmlParser.yxx" +{ + yyval.nodeRef._p = yyvsp[0].node; + yyval.nodeRef._type = SFNodeRef::T_def; + yyval.nodeRef._name = yyvsp[-1].string; +} + break; +case 8: +#line 185 "vrmlParser.yxx" +{ + yyval.nodeRef._p = NULL; + yyval.nodeRef._type = SFNodeRef::T_use; + yyval.nodeRef._name = yyvsp[0].string; +} + break; +case 11: +#line 198 "vrmlParser.yxx" +{ beginProto(yyvsp[0].string); } + break; +case 12: +#line 200 "vrmlParser.yxx" +{ endProto(); free(yyvsp[-7].string);} + break; +case 13: +#line 204 "vrmlParser.yxx" +{ beginProto(yyvsp[0].string); } + break; +case 14: +#line 206 "vrmlParser.yxx" +{ expect(MFSTRING); } + break; +case 15: +#line 207 "vrmlParser.yxx" +{ endProto(); free(yyvsp[-6].string); } + break; +case 18: +#line 215 "vrmlParser.yxx" +{ addEventIn(yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 19: +#line 217 "vrmlParser.yxx" +{ addEventOut(yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 20: +#line 220 "vrmlParser.yxx" +{ + int type = fieldType(yyvsp[-1].string); + expect(type); +} + break; +case 21: +#line 225 "vrmlParser.yxx" +{ + addField(yyvsp[-3].string, yyvsp[-2].string, &(yyvsp[0].fv)); + free(yyvsp[-3].string); + free(yyvsp[-2].string); +} + break; +case 22: +#line 231 "vrmlParser.yxx" +{ + int type = fieldType(yyvsp[-1].string); + expect(type); +} + break; +case 23: +#line 236 "vrmlParser.yxx" +{ + addExposedField(yyvsp[-3].string, yyvsp[-2].string, &(yyvsp[0].fv)); + free(yyvsp[-3].string); + free(yyvsp[-2].string); +} + break; +case 26: +#line 249 "vrmlParser.yxx" +{ addEventIn(yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 27: +#line 251 "vrmlParser.yxx" +{ addEventOut(yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 28: +#line 253 "vrmlParser.yxx" +{ addField(yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 29: +#line 255 "vrmlParser.yxx" +{ addExposedField(yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 30: +#line 261 "vrmlParser.yxx" +{ free(yyvsp[-6].string); free(yyvsp[-4].string); free(yyvsp[-2].string); free(yyvsp[0].string); } + break; +case 31: +#line 265 "vrmlParser.yxx" +{ enterNode(yyvsp[0].string); } + break; +case 32: +#line 266 "vrmlParser.yxx" +{ yyval.node = exitNode(); free(yyvsp[-4].string);} + break; +case 35: +#line 275 "vrmlParser.yxx" +{ enterField(yyvsp[0].string); } + break; +case 36: +#line 277 "vrmlParser.yxx" +{ + storeField(yyvsp[0].fv); + exitField(); + free(yyvsp[-2].string); +} + break; +case 39: +#line 286 "vrmlParser.yxx" +{ inScript(); free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 40: +#line 287 "vrmlParser.yxx" +{ inScript(); free(yyvsp[-1].string); free(yyvsp[0].string); } + break; +case 41: +#line 288 "vrmlParser.yxx" +{ inScript(); + int type = fieldType(yyvsp[-1].string); + expect(type); } + break; +case 42: +#line 291 "vrmlParser.yxx" +{ free(yyvsp[-3].string); free(yyvsp[-2].string); } + break; +case 43: +#line 293 "vrmlParser.yxx" +{ inScript(); free(yyvsp[-3].string); free(yyvsp[-2].string); free(yyvsp[0].string); } + break; +case 44: +#line 295 "vrmlParser.yxx" +{ inScript(); free(yyvsp[-3].string); free(yyvsp[-2].string); free(yyvsp[0].string); } + break; +case 62: +#line 317 "vrmlParser.yxx" +{ yyval.fv._sfnode = yyvsp[0].nodeRef; } + break; +case 63: +#line 319 "vrmlParser.yxx" +{ + yyval.fv._sfnode._p = NULL; + yyval.fv._sfnode._type = SFNodeRef::T_null; + yyval.fv._sfnode._name = NULL; +} + break; +case 64: +#line 324 "vrmlParser.yxx" +{ yyval.fv._mf = yyvsp[0].mfarray; } + break; +case 65: +#line 325 "vrmlParser.yxx" +{ free(yyvsp[0].string); } + break; +case 66: +#line 330 "vrmlParser.yxx" +{ + yyval.mfarray = yyvsp[-1].mfarray; +} + break; +case 67: +#line 334 "vrmlParser.yxx" +{ + yyval.mfarray = new MFArray; + VrmlFieldValue v; + v._sfnode = yyvsp[0].nodeRef; + yyval.mfarray->push_back(v); +} + break; +case 68: +#line 344 "vrmlParser.yxx" +{ + yyval.mfarray = new MFArray; +} + break; +case 69: +#line 348 "vrmlParser.yxx" +{ + VrmlFieldValue v; + v._sfnode = yyvsp[0].nodeRef; + yyvsp[-1].mfarray->push_back(v); + yyval.mfarray = yyvsp[-1].mfarray; +} + break; +} + +#line 705 "/usr/share/bison/bison.simple" + + + yyvsp -= yylen; + yyssp -= yylen; +#if YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; +#if YYLSP_NEEDED + *++yylsp = yyloc; +#endif + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); + + if (yycount < 5) + { + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx) + { + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("parse error; also virtual memory exhausted"); + } + else +#endif /* defined (YYERROR_VERBOSE) */ + yyerror ("parse error"); + } + goto yyerrlab1; + + +/*--------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action | +`--------------------------------------------------*/ +yyerrlab1: + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + + +/*-------------------------------------------------------------------. +| yyerrdefault -- current state does not do anything special for the | +| error token. | +`-------------------------------------------------------------------*/ +yyerrdefault: +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + + /* If its default is to accept any token, ok. Otherwise pop it. */ + yyn = yydefact[yystate]; + if (yyn) + goto yydefault; +#endif + + +/*---------------------------------------------------------------. +| yyerrpop -- pop the current state because it cannot handle the | +| error token | +`---------------------------------------------------------------*/ +yyerrpop: + if (yyssp == yyss) + YYABORT; + yyvsp--; + yystate = *--yyssp; +#if YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + +/*--------------. +| yyerrhandle. | +`--------------*/ +yyerrhandle: + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; +#if YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +/*---------------------------------------------. +| yyoverflowab -- parser overflow comes here. | +`---------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} +#line 356 "vrmlParser.yxx" + + +static void +beginProto(const char *protoName) +{ + // Any protos in the implementation are in a local namespace: + VrmlNodeType::pushNameSpace(); + + VrmlNodeType *t = new VrmlNodeType(protoName); + currentProtoStack.push(t); +} + +static void +endProto() +{ + // Make any protos defined in implementation unavailable: + VrmlNodeType::popNameSpace(); + + // Add this proto definition: + if (currentProtoStack.empty()) { + cerr << "Error: Empty PROTO stack!\n"; + } + else { + VrmlNodeType *t = currentProtoStack.top(); + currentProtoStack.pop(); + VrmlNodeType::addToNameSpace(t); + } +} + +int +addField(const char *type, const char *name, + const VrmlFieldValue *dflt) +{ + return add(&VrmlNodeType::addField, type, name, dflt); +} + +int +addEventIn(const char *type, const char *name, + const VrmlFieldValue *dflt) +{ + return add(&VrmlNodeType::addEventIn, type, name, dflt); +} +int +addEventOut(const char *type, const char *name, + const VrmlFieldValue *dflt) +{ + return add(&VrmlNodeType::addEventOut, type, name, dflt); +} +int +addExposedField(const char *type, const char *name, + const VrmlFieldValue *dflt) +{ + return add(&VrmlNodeType::addExposedField, type, name, dflt); +} + +int +add(void (VrmlNodeType::*func)(const char *, int, const VrmlFieldValue *), + const char *typeString, const char *name, + const VrmlFieldValue *dflt) +{ + int type = fieldType(typeString); + + if (type == 0) { + cerr << "Error: invalid field type: " << type << "\n"; + } + + // Need to add support for Script nodes: + // if (inScript) ... ??? + + if (currentProtoStack.empty()) { + cerr << "Error: declaration outside of prototype\n"; + return 0; + } + VrmlNodeType *t = currentProtoStack.top(); + (t->*func)(name, type, dflt); + + return type; +} + +int +fieldType(const char *type) +{ + if (strcmp(type, "SFBool") == 0) return SFBOOL; + if (strcmp(type, "SFColor") == 0) return SFCOLOR; + if (strcmp(type, "SFFloat") == 0) return SFFLOAT; + if (strcmp(type, "SFImage") == 0) return SFIMAGE; + if (strcmp(type, "SFInt32") == 0) return SFINT32; + if (strcmp(type, "SFNode") == 0) return SFNODE; + if (strcmp(type, "SFRotation") == 0) return SFROTATION; + if (strcmp(type, "SFString") == 0) return SFSTRING; + if (strcmp(type, "SFTime") == 0) return SFTIME; + if (strcmp(type, "SFVec2f") == 0) return SFVEC2F; + if (strcmp(type, "SFVec3f") == 0) return SFVEC3F; + if (strcmp(type, "MFColor") == 0) return MFCOLOR; + if (strcmp(type, "MFFloat") == 0) return MFFLOAT; + if (strcmp(type, "MFInt32") == 0) return MFINT32; + if (strcmp(type, "MFNode") == 0) return MFNODE; + if (strcmp(type, "MFRotation") == 0) return MFROTATION; + if (strcmp(type, "MFString") == 0) return MFSTRING; + if (strcmp(type, "MFVec2f") == 0) return MFVEC2F; + if (strcmp(type, "MFVec3f") == 0) return MFVEC3F; + + cerr << "Illegal field type: " << type << "\n"; + + return 0; +} + +void +enterNode(const char *nodeType) +{ + const VrmlNodeType *t = VrmlNodeType::find(nodeType); + if (t == NULL) { + char tmp[1000]; + sprintf(tmp, "Unknown node type '%s'", nodeType); + vrmlyyerror(tmp); + } + FieldRec *fr = new FieldRec; + fr->nodeType = t; + fr->fieldName = NULL; + fr->typeRec = NULL; + currentField.push(fr); + + VrmlNode *node = new VrmlNode(t); + currentNode.push(node); +} + +VrmlNode * +exitNode() +{ + FieldRec *fr = currentField.top(); + nassertr(fr != NULL, NULL); + currentField.pop(); + + VrmlNode *node = currentNode.top(); + nassertr(node != NULL, NULL); + currentNode.pop(); + + // cerr << "Just defined node:\n" << *node << "\n\n"; + + delete fr; + return node; +} + +void +inScript() +{ + FieldRec *fr = currentField.top(); + if (fr->nodeType == NULL || + strcmp(fr->nodeType->getName(), "Script") != 0) { + vrmlyyerror("interface declaration outside of Script or prototype"); + } +} + +void +enterField(const char *fieldName) +{ + FieldRec *fr = currentField.top(); + nassertv(fr != NULL); + + fr->fieldName = fieldName; + fr->typeRec = NULL; + if (fr->nodeType != NULL) { + // enterField is called when parsing eventIn and eventOut IS + // declarations, in which case we don't need to do anything special-- + // the IS IDENTIFIER will be returned from the lexer normally. + if (fr->nodeType->hasEventIn(fieldName) || + fr->nodeType->hasEventOut(fieldName)) + return; + + const VrmlNodeType::NameTypeRec *typeRec = + fr->nodeType->hasField(fieldName); + if (typeRec != NULL) { + fr->typeRec = typeRec; + // Let the lexer know what field type to expect: + expect(typeRec->type); + } + else { + cerr << "Error: Nodes of type " << fr->nodeType->getName() << + " do not have fields/eventIn/eventOut named " << + fieldName << "\n"; + // expect(ANY_FIELD); + } + } + // else expect(ANY_FIELD); +} + +void +storeField(const VrmlFieldValue &value) { + FieldRec *fr = currentField.top(); + nassertv(fr != NULL); + + VrmlNode *node = currentNode.top(); + nassertv(node != NULL); + + if (fr->typeRec != NULL) { + node->_fields.push_back(VrmlNode::Field(fr->typeRec, value)); + } +} + +void +exitField() +{ + FieldRec *fr = currentField.top(); + nassertv(fr != NULL); + + fr->fieldName = NULL; + fr->typeRec = NULL; +} + +void +expect(int type) +{ + expectToken = type; +} + diff --git a/pandatool/src/vrml/vrmlParser.h.prebuilt b/pandatool/src/vrml/vrmlParser.h.prebuilt new file mode 100644 index 0000000000..ee0e5475a5 --- /dev/null +++ b/pandatool/src/vrml/vrmlParser.h.prebuilt @@ -0,0 +1,52 @@ +#ifndef BISON_Y_TAB_H +# define BISON_Y_TAB_H + +#ifndef YYSTYPE +typedef union { + char *string; + VrmlFieldValue fv; + VrmlNode *node; + MFArray *mfarray; + SFNodeRef nodeRef; + VrmlScene *scene; +} yystype; +# define YYSTYPE yystype +# define YYSTYPE_IS_TRIVIAL 1 +#endif +# define IDENTIFIER 257 +# define DEF 258 +# define USE 259 +# define PROTO 260 +# define EXTERNPROTO 261 +# define TO 262 +# define IS 263 +# define ROUTE 264 +# define SFN_NULL 265 +# define EVENTIN 266 +# define EVENTOUT 267 +# define FIELD 268 +# define EXPOSEDFIELD 269 +# define SFBOOL 270 +# define SFCOLOR 271 +# define SFFLOAT 272 +# define SFIMAGE 273 +# define SFINT32 274 +# define SFNODE 275 +# define SFROTATION 276 +# define SFSTRING 277 +# define SFTIME 278 +# define SFVEC2F 279 +# define SFVEC3F 280 +# define MFCOLOR 281 +# define MFFLOAT 282 +# define MFINT32 283 +# define MFROTATION 284 +# define MFSTRING 285 +# define MFVEC2F 286 +# define MFVEC3F 287 +# define MFNODE 288 + + +extern YYSTYPE vrmlyylval; + +#endif /* not BISON_Y_TAB_H */ diff --git a/pandatool/src/xfile/xLexer.cxx.prebuilt b/pandatool/src/xfile/xLexer.cxx.prebuilt new file mode 100644 index 0000000000..9b9a897691 --- /dev/null +++ b/pandatool/src/xfile/xLexer.cxx.prebuilt @@ -0,0 +1,2194 @@ +#define yy_create_buffer xyy_create_buffer +#define yy_delete_buffer xyy_delete_buffer +#define yy_scan_buffer xyy_scan_buffer +#define yy_scan_string xyy_scan_string +#define yy_scan_bytes xyy_scan_bytes +#define yy_flex_debug xyy_flex_debug +#define yy_init_buffer xyy_init_buffer +#define yy_flush_buffer xyy_flush_buffer +#define yy_load_buffer_state xyy_load_buffer_state +#define yy_switch_to_buffer xyy_switch_to_buffer +#define yyin xyyin +#define yyleng xyyleng +#define yylex xyylex +#define yyout xyyout +#define yyrestart xyyrestart +#define yytext xyytext +#define yywrap xyywrap + +#line 20 "lex.yy.c" +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header$ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 26 +#define YY_END_OF_BUFFER 27 +static yyconst short int yy_accept[99] = + { 0, + 0, 0, 27, 25, 2, 1, 21, 4, 22, 25, + 24, 25, 25, 18, 18, 23, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 1, 4, 0, 18, + 24, 18, 0, 20, 3, 20, 19, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 17, + 0, 3, 19, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 0, 20, 24, 6, 7, + 24, 24, 24, 24, 24, 24, 24, 24, 16, 5, + 24, 24, 10, 11, 24, 24, 14, 24, 24, 9, + 12, 24, 24, 8, 24, 15, 13, 0 + + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 4, 5, 1, 1, 1, 6, 1, + 1, 1, 7, 1, 8, 9, 10, 11, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 1, 1, 13, + 1, 1, 1, 1, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 14, 14, 24, 25, 26, 27, 28, + 14, 29, 30, 31, 32, 14, 33, 34, 35, 14, + 1, 1, 1, 1, 14, 1, 15, 16, 17, 18, + + 19, 20, 21, 22, 23, 14, 14, 24, 25, 26, + 27, 28, 14, 29, 30, 31, 32, 14, 33, 34, + 35, 14, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[36] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 3, 3, 1, + 4, 4, 1, 3, 4, 4, 4, 4, 4, 4, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3 + } ; + +static yyconst short int yy_base[104] = + { 0, + 0, 0, 207, 208, 208, 0, 208, 0, 208, 27, + 31, 35, 196, 39, 43, 208, 196, 28, 32, 36, + 44, 40, 47, 50, 53, 54, 0, 0, 49, 63, + 195, 71, 194, 73, 0, 75, 0, 59, 67, 80, + 81, 82, 84, 88, 87, 92, 91, 95, 90, 208, + 95, 0, 0, 111, 112, 96, 99, 113, 101, 118, + 100, 115, 123, 125, 126, 125, 128, 132, 191, 185, + 136, 137, 138, 139, 140, 141, 142, 145, 181, 178, + 143, 144, 175, 174, 153, 149, 173, 159, 164, 172, + 171, 148, 167, 166, 169, 151, 146, 208, 188, 192, + + 194, 198, 61 + } ; + +static yyconst short int yy_def[104] = + { 0, + 98, 1, 98, 98, 98, 99, 98, 100, 98, 98, + 101, 98, 98, 98, 98, 98, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 99, 100, 98, 98, + 101, 101, 98, 98, 102, 98, 103, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 101, 98, + 98, 102, 103, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 98, 98, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 101, 101, 101, + 101, 101, 101, 101, 101, 101, 101, 0, 98, 98, + + 98, 98, 98 + } ; + +static yyconst short int yy_nxt[244] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 17, 22, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 23, + 24, 25, 26, 17, 17, 29, 98, 30, 30, 29, + 98, 32, 32, 33, 98, 34, 34, 36, 98, 30, + 30, 36, 98, 30, 30, 98, 38, 40, 98, 34, + 34, 98, 98, 44, 53, 41, 39, 98, 46, 47, + 42, 36, 37, 30, 30, 98, 43, 45, 48, 36, + 49, 32, 32, 34, 34, 34, 34, 54, 98, 98, + 98, 51, 98, 51, 56, 98, 98, 55, 98, 98, + + 98, 66, 66, 98, 98, 67, 67, 98, 98, 98, + 59, 57, 63, 58, 60, 61, 62, 64, 65, 98, + 98, 98, 75, 98, 70, 68, 98, 71, 72, 73, + 69, 98, 74, 98, 98, 67, 67, 77, 67, 67, + 98, 78, 76, 79, 98, 98, 98, 98, 98, 98, + 98, 98, 98, 98, 98, 83, 98, 98, 81, 98, + 82, 98, 90, 92, 86, 85, 80, 98, 89, 84, + 87, 88, 98, 91, 98, 98, 93, 98, 95, 98, + 98, 98, 98, 98, 94, 96, 98, 97, 27, 98, + 27, 27, 28, 98, 28, 28, 31, 31, 52, 98, + + 52, 52, 50, 98, 98, 35, 98, 3, 98, 98, + 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, + 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, + 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, + 98, 98, 98 + } ; + +static yyconst short int yy_chk[244] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 10, 18, 10, 10, 11, + 19, 11, 11, 12, 20, 12, 12, 14, 22, 14, + 14, 15, 21, 15, 15, 23, 18, 20, 24, 29, + 29, 25, 26, 22, 103, 20, 19, 38, 24, 25, + 21, 30, 14, 30, 30, 39, 21, 23, 25, 32, + 26, 32, 32, 34, 34, 36, 36, 38, 40, 41, + 42, 34, 43, 36, 40, 45, 44, 39, 49, 47, + + 46, 51, 51, 48, 56, 51, 51, 57, 61, 59, + 43, 41, 47, 42, 44, 45, 46, 48, 49, 54, + 55, 58, 61, 62, 56, 54, 60, 57, 58, 59, + 55, 63, 60, 64, 65, 66, 66, 63, 67, 67, + 68, 64, 62, 65, 71, 72, 73, 74, 75, 76, + 77, 81, 82, 78, 97, 73, 92, 86, 71, 96, + 72, 85, 82, 86, 76, 75, 68, 88, 81, 74, + 77, 78, 89, 85, 94, 93, 88, 95, 92, 91, + 90, 87, 84, 83, 89, 93, 80, 95, 99, 79, + 99, 99, 100, 70, 100, 100, 101, 101, 102, 69, + + 102, 102, 33, 31, 17, 13, 3, 98, 98, 98, + 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, + 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, + 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, + 98, 98, 98 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "xLexer.lxx" +#define INITIAL 0 +/* +// Filename: xLexer.lxx +// Created by: drose (03Oct04) +// +//////////////////////////////////////////////////////////////////// +*/ +#line 9 "xLexer.lxx" +#include "xLexerDefs.h" +#include "xParserDefs.h" +#include "xParser.h" +#include "indent.h" +#include "notify.h" + +static int yyinput(void); // declared by flex. +extern "C" int xyywrap(); + +//////////////////////////////////////////////////////////////////// +// Static variables +//////////////////////////////////////////////////////////////////// + +// We'll increment line_number and col_number as we parse the file, so +// that we can report the position of an error. +static int line_number = 0; +static int col_number = 0; + +// current_line holds as much of the current line as will fit. Its +// only purpose is for printing it out to report an error to the user. +static const int max_error_width = 1024; +static char current_line[max_error_width + 1]; + +static int error_count = 0; +static int warning_count = 0; + +// This is the pointer to the current input stream. +static istream *inp = NULL; + +// This is the name of the x file we're parsing. We keep it so we +// can print it out for error messages. +static string x_filename; + + +//////////////////////////////////////////////////////////////////// +// Defining the interface to the lexer. +//////////////////////////////////////////////////////////////////// + +void +x_init_lexer(istream &in, const string &filename) { + inp = ∈ + x_filename = filename; + line_number = 0; + col_number = 0; + error_count = 0; + warning_count = 0; +} + +int +x_error_count() { + return error_count; +} + +int +x_warning_count() { + return warning_count; +} + + +//////////////////////////////////////////////////////////////////// +// Internal support functions. +//////////////////////////////////////////////////////////////////// + +int +xyywrap(void) { + return 1; +} + +void +xyyerror(const string &msg) { + cerr << "\nError"; + if (!x_filename.empty()) { + cerr << " in " << x_filename; + } + cerr + << " at line " << line_number << ", column " << col_number << ":\n" + << current_line << "\n"; + indent(cerr, col_number-1) + << "^\n" << msg << "\n\n"; + + error_count++; +} + +void +xyywarning(const string &msg) { + cerr << "\nWarning"; + if (!x_filename.empty()) { + cerr << " in " << x_filename; + } + cerr + << " at line " << line_number << ", column " << col_number << ":\n" + << current_line << "\n"; + indent(cerr, col_number-1) + << "^\n" << msg << "\n\n"; + + warning_count++; +} + +// Now define a function to take input from an istream instead of a +// stdio FILE pointer. This is flex-specific. +static void +input_chars(char *buffer, int &result, int max_size) { + nassertv(inp != NULL); + if (*inp) { + inp->read(buffer, max_size); + result = inp->gcount(); + if (result >= 0 && result < max_size) { + // Truncate at the end of the read. + buffer[result] = '\0'; + } + + if (line_number == 0) { + // This is a special case. If we are reading the very first bit + // from the stream, copy it into the current_line array. This + // is because the \n.* rule below, which fills current_line + // normally, doesn't catch the first line. + strncpy(current_line, xyytext, max_error_width); + current_line[max_error_width] = '\0'; + line_number++; + col_number = 0; + + // Truncate it at the newline. + char *end = strchr(current_line, '\n'); + if (end != NULL) { + *end = '\0'; + } + } + + } else { + // End of file or I/O error. + result = 0; + } +} +#undef YY_INPUT +#define YY_INPUT(buffer, result, max_size) input_chars(buffer, result, max_size) + +// read_char reads and returns a single character, incrementing the +// supplied line and column numbers as appropriate. A convenience +// function for the scanning functions below. +static int +read_char(int &line, int &col) { + int c = yyinput(); + if (c == '\n') { + line++; + col = 0; + } else { + col++; + } + return c; +} + +// scan_quoted_string reads a string delimited by quotation marks and +// returns it. +static string +scan_quoted_string(char quote_mark) { + string result; + + // We don't touch the current line number and column number during + // scanning, so that if we detect an error while scanning the string + // (e.g. an unterminated string), we'll report the error as + // occurring at the start of the string, not at the end--somewhat + // more convenient for the user. + + // Instead of adjusting the global line_number and col_number + // variables, we'll operate on our own local variables for the + // interim. + int line = line_number; + int col = col_number; + + int c; + c = read_char(line, col); + while (c != quote_mark && c != EOF) { + // A newline is not allowed within a string unless it is escaped. + if (c == '\n') { + c = EOF; + break; + + } else if (c == '\\') { + // Backslash escapes the following character. We also respect + // some C conventions. + c = read_char(line, col); + switch (c) { + case 'a': + result += '\a'; + c = read_char(line, col); + break; + + case 'n': + result += '\n'; + c = read_char(line, col); + break; + + case 'r': + result += '\r'; + c = read_char(line, col); + break; + + case 't': + result += '\t'; + c = read_char(line, col); + break; + + case 'x': + { + int hex = 0; + c = read_char(line, col); + for (int i = 0; i < 2 && isxdigit(c); i++) { + hex = hex * 16 + (isdigit(c) ? c - '0' : tolower(c) - 'a' + 10); + c = read_char(line, col); + } + + result += hex; + } + break; + + case '0': + { + int oct = 0; + c = read_char(line, col); + for (int i = 0; i < 3 && (c >= '0' && c < '7'); i++) { + oct = oct * 8 + (c - '0'); + c = read_char(line, col); + } + + result += oct; + } + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + int dec = 0; + c = read_char(line, col); + for (int i = 0; i < 3 && isdigit(c); i++) { + dec = dec * 10 + (c - '0'); + c = read_char(line, col); + } + + result += dec; + } + break; + + case EOF: + break; + + default: + result += c; + c = read_char(line, col); + } + + } else { + result += c; + c = read_char(line, col); + } + } + + if (c == EOF) { + xyyerror("This quotation mark is unterminated."); + } + + line_number = line; + col_number = col; + + return result; +} + +// scan_guid_string reads a string of hexadecimal digits delimited by +// angle brackets and returns the corresponding string. +static string +scan_guid_string() { + // We don't touch the current line number and column number during + // scanning, so that if we detect an error while scanning the string + // (e.g. an unterminated string), we'll report the error as + // occurring at the start of the string, not at the end--somewhat + // more convenient for the user. + + // Instead of adjusting the global line_number and col_number + // variables, we'll operate on our own local variables for the + // interim. + int line = line_number; + int col = col_number; + + int num_digits = 0; + int num_hyphens = 0; + + string result; + + int c; + c = read_char(line, col); + while (c != '>' && c != EOF) { + if (isxdigit(c)) { + num_digits++; + + } else if (c == '-') { + num_hyphens++; + + } else { + line_number = line; + col_number = col; + xyyerror("Invalid character in GUID."); + return string(); + } + + result += c; + + c = read_char(line, col); + } + + if (c == EOF) { + xyyerror("This GUID string is unterminated."); + return string(); + + } else if (num_digits != 32) { + xyyerror("Incorrect number of hex digits in GUID."); + return string(); + + } else if (num_hyphens != 4) { + xyyerror("Incorrect number of hyphens in GUID."); + return string(); + } + + line_number = line; + col_number = col; + + return result; +} + + + +// accept() is called below as each piece is pulled off and +// accepted by the lexer; it increments the current column number. +inline void accept() { + col_number += yyleng; +} + +#line 818 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp = NULL, *yy_bp = NULL; + register int yy_act; + +#line 357 "xLexer.lxx" + + + + + +#line 975 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 99 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 208 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 362 "xLexer.lxx" +{ + // New line. Save a copy of the line so we can print it out for the + // benefit of the user in case we get an error. + + strncpy(current_line, xyytext+1, max_error_width); + current_line[max_error_width] = '\0'; + line_number++; + col_number=0; + + // Return the whole line to the lexer, except the newline character, + // which we eat. + yyless(1); +} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 376 "xLexer.lxx" +{ + // Eat whitespace. + accept(); +} + YY_BREAK +case 3: +YY_RULE_SETUP +#line 381 "xLexer.lxx" +{ + // Eat C++-style comments. + accept(); +} + YY_BREAK +case 4: +YY_RULE_SETUP +#line 386 "xLexer.lxx" +{ + // Eat sh-style comments. + accept(); +} + YY_BREAK +case 5: +YY_RULE_SETUP +#line 392 "xLexer.lxx" +{ + accept(); + return KW_ARRAY; +} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 397 "xLexer.lxx" +{ + accept(); + return KW_BYTE; +} + YY_BREAK +case 7: +YY_RULE_SETUP +#line 402 "xLexer.lxx" +{ + accept(); + return KW_CHAR; +} + YY_BREAK +case 8: +YY_RULE_SETUP +#line 407 "xLexer.lxx" +{ + accept(); + return KW_CSTRING; +} + YY_BREAK +case 9: +YY_RULE_SETUP +#line 412 "xLexer.lxx" +{ + accept(); + return KW_DOUBLE; +} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 417 "xLexer.lxx" +{ + accept(); + return KW_DWORD; +} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 422 "xLexer.lxx" +{ + accept(); + return KW_FLOAT; +} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 427 "xLexer.lxx" +{ + accept(); + return KW_STRING; +} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 432 "xLexer.lxx" +{ + accept(); + return KW_TEMPLATE; +} + YY_BREAK +case 14: +YY_RULE_SETUP +#line 437 "xLexer.lxx" +{ + accept(); + return KW_UCHAR; +} + YY_BREAK +case 15: +YY_RULE_SETUP +#line 442 "xLexer.lxx" +{ + accept(); + return KW_UNICODE; +} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 447 "xLexer.lxx" +{ + accept(); + return KW_WORD; +} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 452 "xLexer.lxx" +{ + accept(); + return ELLIPSIS; +} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 457 "xLexer.lxx" +{ + // A signed or unsigned integer number. + accept(); + xyylval.u.s_int = atol(xyytext); + xyylval.str = yytext; + + return INTEGER; +} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 466 "xLexer.lxx" +{ + // A hexadecimal integer number. + accept(); + + // As above, we'll decode the hex string by hand. + xyylval.str = xyytext; + xyylval.u.s_int = 0; + const char *p = xyytext + 2; + while (*p != '\0') { + int next_value = xyylval.u.s_int * 16; + if (next_value < xyylval.u.s_int) { + xyyerror("Number out of range."); + xyylval.u.s_int = 1; + return INTEGER; + } + + if (isalpha(*p)) { + xyylval.u.s_int = next_value + (tolower(*p) - 'a' + 10); + } else { + xyylval.u.s_int = next_value + (*p - '0'); + } + ++p; + } + + return INTEGER; +} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 493 "xLexer.lxx" +{ + // A floating-point number. + accept(); + xyylval.u.real = atof(xyytext); + xyylval.str = xyytext; + return REAL; +} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 501 "xLexer.lxx" +{ + // Quoted string. + accept(); + xyylval.str = scan_quoted_string('"'); + return STRING; +} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 508 "xLexer.lxx" +{ + // Single-quoted string. + accept(); + xyylval.str = scan_quoted_string('\''); + return STRING; +} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 515 "xLexer.lxx" +{ + // Long GUID string. + accept(); + xyylval.str = scan_guid_string(); + + if (!xyylval.guid.parse_string(xyylval.str)) { + xyyerror("Malformed GUID."); + } + + return WINDOWS_GUID; +} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 527 "xLexer.lxx" +{ + // Identifier. + accept(); + xyylval.str = xyytext; + return IDENTIFIER; +} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 535 "xLexer.lxx" +{ + // Send any other printable character as itself. + accept(); + return xyytext[0]; +} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 541 "xLexer.lxx" +ECHO; + YY_BREAK +#line 1315 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 99 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 99 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 98); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 541 "xLexer.lxx" diff --git a/pandatool/src/xfile/xParser.cxx.prebuilt b/pandatool/src/xfile/xParser.cxx.prebuilt new file mode 100644 index 0000000000..ab93021f8c --- /dev/null +++ b/pandatool/src/xfile/xParser.cxx.prebuilt @@ -0,0 +1,1383 @@ +/* A Bison parser, made from xParser.yxx + by GNU bison 1.35. */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define yyparse xyyparse +#define yylex xyylex +#define yyerror xyyerror +#define yylval xyylval +#define yychar xyychar +#define yydebug xyydebug +#define yynerrs xyynerrs +# define INTEGER 257 +# define REAL 258 +# define STRING 259 +# define IDENTIFIER 260 +# define WINDOWS_GUID 261 +# define KW_ARRAY 262 +# define KW_BYTE 263 +# define KW_CHAR 264 +# define KW_CSTRING 265 +# define KW_DOUBLE 266 +# define KW_DWORD 267 +# define KW_FLOAT 268 +# define KW_STRING 269 +# define KW_TEMPLATE 270 +# define KW_UCHAR 271 +# define KW_UNICODE 272 +# define KW_WORD 273 +# define ELLIPSIS 274 + +#line 6 "xParser.yxx" + +#include "xLexerDefs.h" +#include "xParserDefs.h" +#include "xFile.h" +#include "xFileTemplate.h" +#include "xFileDataDef.h" +#include "xFileArrayDef.h" +#include "dcast.h" + +// Because our token type contains objects of type string, which +// require correct copy construction (and not simply memcpying), we +// cannot use bison's built-in auto-stack-grow feature. As an easy +// solution, we ensure here that we have enough yacc stack to start +// with, and that it doesn't ever try to grow. +#define YYINITDEPTH 1000 +#define YYMAXDEPTH 1000 + +static XFile *x_file = (XFile *)NULL; +static XFileNode *current_node = (XFileNode *)NULL; +static XFileDataDef *current_data_def = (XFileDataDef *)NULL; + +//////////////////////////////////////////////////////////////////// +// Defining the interface to the parser. +//////////////////////////////////////////////////////////////////// + +void +x_init_parser(istream &in, const string &filename, XFile &file) { + x_file = &file; + current_node = &file; + x_init_lexer(in, filename); +} + +void +x_cleanup_parser() { + x_file = (XFile *)NULL; + current_node = (XFileNode *)NULL; +} + +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + + + +#define YYFINAL 84 +#define YYFLAG -32768 +#define YYNTBASE 27 + +/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ +#define YYTRANSLATE(x) ((unsigned)(x) <= 274 ? yytranslate[x] : 46) + +/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ +static const char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 26, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 23, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 24, 2, 25, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 21, 2, 22, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20 +}; + +#if YYDEBUG +static const short yyprhs[] = +{ + 0, 0, 2, 5, 8, 9, 18, 20, 24, 26, + 27, 32, 35, 38, 41, 44, 47, 50, 53, 56, + 59, 62, 65, 67, 70, 74, 78, 80, 84, 88, + 91, 96, 97, 104, 106, 109, 111, 113, 115, 117, + 119, 121, 123, 127, 129, 131, 133, 135 +}; +static const short yyrhs[] = +{ + 45, 0, 27, 28, 0, 27, 38, 0, 0, 16, + 6, 21, 7, 29, 30, 36, 22, 0, 45, 0, + 30, 31, 23, 0, 33, 0, 0, 8, 33, 32, + 34, 0, 19, 43, 0, 13, 43, 0, 14, 43, + 0, 12, 43, 0, 10, 43, 0, 17, 43, 0, + 9, 43, 0, 15, 43, 0, 11, 43, 0, 18, + 43, 0, 6, 43, 0, 35, 0, 34, 35, 0, + 24, 3, 25, 0, 24, 6, 25, 0, 45, 0, + 24, 20, 25, 0, 24, 37, 25, 0, 6, 44, + 0, 37, 26, 6, 44, 0, 0, 6, 43, 21, + 39, 40, 22, 0, 45, 0, 40, 41, 0, 38, + 0, 42, 0, 3, 0, 4, 0, 5, 0, 23, + 0, 26, 0, 21, 6, 22, 0, 45, 0, 6, + 0, 45, 0, 7, 0, 0 +}; + +#endif + +#if YYDEBUG +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const short yyrline[] = +{ + 0, 72, 74, 75, 78, 78, 93, 95, 98, 103, + 103, 111, 116, 120, 124, 128, 132, 136, 140, 144, + 148, 152, 158, 160, 163, 168, 179, 181, 182, 185, + 189, 194, 194, 204, 206, 209, 213, 216, 219, 222, + 225, 228, 233, 237, 242, 245, 250, 253 +}; +#endif + + +#if (YYDEBUG) || defined YYERROR_VERBOSE + +/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ +static const char *const yytname[] = +{ + "$", "error", "$undefined.", "INTEGER", "REAL", "STRING", "IDENTIFIER", + "WINDOWS_GUID", "KW_ARRAY", "KW_BYTE", "KW_CHAR", "KW_CSTRING", + "KW_DOUBLE", "KW_DWORD", "KW_FLOAT", "KW_STRING", "KW_TEMPLATE", + "KW_UCHAR", "KW_UNICODE", "KW_WORD", "ELLIPSIS", "'{'", "'}'", "';'", + "'['", "']'", "','", "xfile", "xtemplate", "@1", "template_members", + "template_member", "@2", "data_def", "array_dimensions", "array_level", + "template_restrictions", "template_list", "data_object", "@3", + "data_object_members", "data_object_member", "data_reference", + "optional_identifier", "optional_guid", "empty", 0 +}; +#endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const short yyr1[] = +{ + 0, 27, 27, 27, 29, 28, 30, 30, 31, 32, + 31, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 33, 33, 34, 34, 35, 35, 36, 36, 36, 37, + 37, 39, 38, 40, 40, 41, 41, 41, 41, 41, + 41, 41, 42, 43, 43, 44, 44, 45 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const short yyr2[] = +{ + 0, 1, 2, 2, 0, 8, 1, 3, 1, 0, + 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 1, 2, 3, 3, 1, 3, 3, 2, + 4, 0, 6, 1, 2, 1, 1, 1, 1, 1, + 1, 1, 3, 1, 1, 1, 1, 0 +}; + +/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE + doesn't specify something else to do. Zero means the default is an + error. */ +static const short yydefact[] = +{ + 47, 0, 1, 47, 0, 2, 3, 44, 0, 43, + 0, 31, 0, 47, 4, 0, 33, 47, 37, 38, + 39, 0, 32, 40, 41, 35, 34, 36, 47, 6, + 0, 47, 0, 47, 47, 47, 47, 47, 47, 47, + 47, 47, 47, 0, 0, 8, 0, 26, 42, 21, + 9, 17, 15, 19, 14, 12, 13, 18, 16, 20, + 11, 47, 0, 0, 7, 5, 0, 46, 29, 45, + 27, 28, 0, 0, 10, 22, 47, 0, 0, 23, + 30, 24, 25, 0, 0 +}; + +static const short yydefgoto[] = +{ + 1, 5, 17, 28, 44, 66, 45, 74, 75, 46, + 63, 6, 13, 15, 26, 27, 8, 68, 9 +}; + +static const short yypact[] = +{ + -32768, 6,-32768, 1, 8,-32768,-32768,-32768, -6,-32768, + -5,-32768, 11,-32768,-32768, -2,-32768,-32768,-32768,-32768, + -32768, 19,-32768,-32768,-32768,-32768,-32768,-32768, 21,-32768, + 4, 1, 37, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 3, 14,-32768, 20,-32768,-32768,-32768, + -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + -32768, 34, 28, -15,-32768,-32768, 33,-32768,-32768,-32768, + -32768,-32768, 38, 2, 33,-32768, 34, 47, 48,-32768, + -32768,-32768,-32768, 58,-32768 +}; + +static const short yypgoto[] = +{ + -32768,-32768,-32768,-32768,-32768,-32768, 27,-32768, 5,-32768, + -32768, 59,-32768,-32768,-32768,-32768, 29, -1, 0 +}; + + +#define YYLAST 79 + + +static const short yytable[] = +{ + 2, 18, 19, 20, 3, 77, 83, 7, 78, 61, + 71, 72, 3, 16, 10, 11, 12, 29, 14, 21, + 22, 23, 4, 62, 24, 30, 48, 31, 47, 32, + 33, 34, 35, 36, 37, 38, 39, 64, 40, 41, + 42, 67, 65, 31, 76, 43, 33, 34, 35, 36, + 37, 38, 39, 70, 40, 41, 42, 73, 84, 50, + 49, 69, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 81, 82, 25, 80, 69, 0, 0, 79 +}; + +static const short yycheck[] = +{ + 0, 3, 4, 5, 6, 3, 0, 6, 6, 6, + 25, 26, 6, 13, 6, 21, 21, 17, 7, 21, + 22, 23, 16, 20, 26, 6, 22, 6, 28, 8, + 9, 10, 11, 12, 13, 14, 15, 23, 17, 18, + 19, 7, 22, 6, 6, 24, 9, 10, 11, 12, + 13, 14, 15, 25, 17, 18, 19, 24, 0, 32, + 31, 61, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 25, 25, 15, 76, 76, -1, -1, 74 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/bison/bison.simple" + +/* Skeleton output parser for bison, + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software + Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser when + the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# else +# ifndef YYSTACK_USE_ALLOCA +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC malloc +# define YYSTACK_FREE free +# endif +#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short yyss; + YYSTYPE yyvs; +# if YYLSP_NEEDED + YYLTYPE yyls; +# endif +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# if YYLSP_NEEDED +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + + 2 * YYSTACK_GAP_MAX) +# else +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAX) +# endif + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up"); \ + YYERROR; \ + } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Compute the default location (before the actions + are run). + + When YYLLOC_DEFAULT is run, CURRENT is set the location of the + first token. By default, to implement support for ranges, extend + its range to the last symbol. */ + +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#if YYPURE +# if YYLSP_NEEDED +# ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) +# else +# define YYLEX yylex (&yylval, &yylloc) +# endif +# else /* !YYLSP_NEEDED */ +# ifdef YYLEX_PARAM +# define YYLEX yylex (&yylval, YYLEX_PARAM) +# else +# define YYLEX yylex (&yylval) +# endif +# endif /* !YYLSP_NEEDED */ +#else /* !YYPURE */ +# define YYLEX yylex () +#endif /* !YYPURE */ + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +#endif /* !YYDEBUG */ + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#if YYMAXDEPTH == 0 +# undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + +#ifdef YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif +#endif + +#line 315 "/usr/share/bison/bison.simple" + + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +# define YYPARSE_PARAM_DECL +# else +# define YYPARSE_PARAM_ARG YYPARSE_PARAM +# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +# endif +#else /* !YYPARSE_PARAM */ +# define YYPARSE_PARAM_ARG +# define YYPARSE_PARAM_DECL +#endif /* !YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +# ifdef YYPARSE_PARAM +int yyparse (void *); +# else +int yyparse (void); +# endif +#endif + +/* YY_DECL_VARIABLES -- depending whether we use a pure parser, + variables are global, or local to YYPARSE. */ + +#define YY_DECL_NON_LSP_VARIABLES \ +/* The lookahead symbol. */ \ +int yychar; \ + \ +/* The semantic value of the lookahead symbol. */ \ +YYSTYPE yylval; \ + \ +/* Number of parse errors so far. */ \ +int yynerrs; + +#if YYLSP_NEEDED +# define YY_DECL_VARIABLES \ +YY_DECL_NON_LSP_VARIABLES \ + \ +/* Location data for the lookahead symbol. */ \ +YYLTYPE yylloc; +#else +# define YY_DECL_VARIABLES \ +YY_DECL_NON_LSP_VARIABLES +#endif + + +/* If nonreentrant, generate the variables here. */ + +#if !YYPURE +YY_DECL_VARIABLES +#endif /* !YYPURE */ + +int +yyparse (YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + /* If reentrant, generate the variables here. */ +#if YYPURE + YY_DECL_VARIABLES +#endif /* !YYPURE */ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Lookahead token as an internal (translated) token number. */ + int yychar1 = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short yyssa[YYINITDEPTH]; + short *yyss = yyssa; + register short *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + +#if YYLSP_NEEDED + /* The location stack. */ + YYLTYPE yylsa[YYINITDEPTH]; + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; +#endif + +#if YYLSP_NEEDED +# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +# define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + YYSIZE_T yystacksize = YYINITDEPTH; + + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; +#if YYLSP_NEEDED + YYLTYPE yyloc; +#endif + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; +#if YYLSP_NEEDED + yylsp = yyls; +#endif + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. */ +# if YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yyls1, yysize * sizeof (*yylsp), + &yystacksize); + yyls = yyls1; +# else + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + &yystacksize); +# endif + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + goto yyoverflowlab; + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; + + { + short *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); +# if YYLSP_NEEDED + YYSTACK_RELOCATE (yyls); +# endif +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; +#if YYLSP_NEEDED + yylsp = yyls + yysize - 1; +#endif + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yychar1 = YYTRANSLATE (yychar); + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables + which are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + YYFPRINTF (stderr, "Next token is %d (%s", + yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise + meaning of a token, for further debugging info. */ +# ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +# endif + YYFPRINTF (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + YYDPRINTF ((stderr, "Shifting token %d (%s), ", + yychar, yytname[yychar1])); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#if YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to the semantic value of + the lookahead token. This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + +#if YYLSP_NEEDED + /* Similarly for the default location. Let the user run additional + commands if for instance locations are ranges. */ + yyloc = yylsp[1-yylen]; + YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); +#endif + +#if YYDEBUG + /* We have to keep this `#if YYDEBUG', since we use variables which + are defined only if `YYDEBUG' is set. */ + if (yydebug) + { + int yyi; + + YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) + YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); + YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + switch (yyn) { + +case 4: +#line 80 "xParser.yxx" +{ + yyval.u.node = current_node; + XFileTemplate *templ = new XFileTemplate(yyvsp[-2].str, yyvsp[0].guid); + current_node->add_child(templ); + current_node = templ; +} + break; +case 5: +#line 87 "xParser.yxx" +{ + yyval.u.node = current_node; + current_node = yyvsp[-3].u.node; +} + break; +case 8: +#line 100 "xParser.yxx" +{ + current_node->add_child(yyvsp[0].u.data_def); +} + break; +case 9: +#line 104 "xParser.yxx" +{ + current_node->add_child(yyvsp[0].u.data_def); + current_data_def = yyvsp[0].u.data_def; +} + break; +case 11: +#line 113 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_word, yyvsp[0].str); +} + break; +case 12: +#line 117 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_dword, yyvsp[0].str); +} + break; +case 13: +#line 121 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_float, yyvsp[0].str); +} + break; +case 14: +#line 125 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_double, yyvsp[0].str); +} + break; +case 15: +#line 129 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_char, yyvsp[0].str); +} + break; +case 16: +#line 133 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_uchar, yyvsp[0].str); +} + break; +case 17: +#line 137 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_byte, yyvsp[0].str); +} + break; +case 18: +#line 141 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_string, yyvsp[0].str); +} + break; +case 19: +#line 145 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_cstring, yyvsp[0].str); +} + break; +case 20: +#line 149 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_unicode, yyvsp[0].str); +} + break; +case 21: +#line 153 "xParser.yxx" +{ + yyval.u.data_def = new XFileDataDef(XFileDataDef::T_word, yyvsp[0].str); +} + break; +case 24: +#line 165 "xParser.yxx" +{ + current_data_def->add_array_def(XFileArrayDef(yyvsp[-1].u.s_int)); +} + break; +case 25: +#line 169 "xParser.yxx" +{ + XFileNode *data_def = current_node->find_child(yyvsp[-1].str); + if (data_def == (XFileNode *)NULL) { + yyerror("Unknown identifier: " + yyvsp[-1].str); + } else { + current_data_def->add_array_def(XFileArrayDef(DCAST(XFileDataDef, data_def))); + } +} + break; +case 29: +#line 187 "xParser.yxx" +{ +} + break; +case 30: +#line 190 "xParser.yxx" +{ +} + break; +case 31: +#line 196 "xParser.yxx" +{ +} + break; +case 32: +#line 199 "xParser.yxx" +{ +} + break; +case 35: +#line 211 "xParser.yxx" +{ +} + break; +case 36: +#line 214 "xParser.yxx" +{ +} + break; +case 37: +#line 217 "xParser.yxx" +{ +} + break; +case 38: +#line 220 "xParser.yxx" +{ +} + break; +case 39: +#line 223 "xParser.yxx" +{ +} + break; +case 40: +#line 226 "xParser.yxx" +{ +} + break; +case 41: +#line 229 "xParser.yxx" +{ +} + break; +case 43: +#line 239 "xParser.yxx" +{ + yyval.str = string(); +} + break; +case 45: +#line 247 "xParser.yxx" +{ + yyval.guid = WindowsGuid(); +} + break; +} + +#line 705 "/usr/share/bison/bison.simple" + + + yyvsp -= yylen; + yyssp -= yylen; +#if YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; +#if YYLSP_NEEDED + *++yylsp = yyloc; +#endif + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + char *yymsg; + int yyx, yycount; + + yycount = 0; + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) + if (yycheck[yyx + yyn] == yyx) + yysize += yystrlen (yytname[yyx]) + 15, yycount++; + yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); + + if (yycount < 5) + { + yycount = 0; + for (yyx = yyn < 0 ? -yyn : 0; + yyx < (int) (sizeof (yytname) / sizeof (char *)); + yyx++) + if (yycheck[yyx + yyn] == yyx) + { + const char *yyq = ! yycount ? ", expecting " : " or "; + yyp = yystpcpy (yyp, yyq); + yyp = yystpcpy (yyp, yytname[yyx]); + yycount++; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("parse error; also virtual memory exhausted"); + } + else +#endif /* defined (YYERROR_VERBOSE) */ + yyerror ("parse error"); + } + goto yyerrlab1; + + +/*--------------------------------------------------. +| yyerrlab1 -- error raised explicitly by an action | +`--------------------------------------------------*/ +yyerrlab1: + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", + yychar, yytname[yychar1])); + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + + +/*-------------------------------------------------------------------. +| yyerrdefault -- current state does not do anything special for the | +| error token. | +`-------------------------------------------------------------------*/ +yyerrdefault: +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + + /* If its default is to accept any token, ok. Otherwise pop it. */ + yyn = yydefact[yystate]; + if (yyn) + goto yydefault; +#endif + + +/*---------------------------------------------------------------. +| yyerrpop -- pop the current state because it cannot handle the | +| error token | +`---------------------------------------------------------------*/ +yyerrpop: + if (yyssp == yyss) + YYABORT; + yyvsp--; + yystate = *--yyssp; +#if YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } +#endif + +/*--------------. +| yyerrhandle. | +`--------------*/ +yyerrhandle: + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + + YYDPRINTF ((stderr, "Shifting error token, ")); + + *++yyvsp = yylval; +#if YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturn; + +/*---------------------------------------------. +| yyoverflowab -- parser overflow comes here. | +`---------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} +#line 256 "xParser.yxx" diff --git a/pandatool/src/xfile/xParser.h.prebuilt b/pandatool/src/xfile/xParser.h.prebuilt new file mode 100644 index 0000000000..3b6f0736a0 --- /dev/null +++ b/pandatool/src/xfile/xParser.h.prebuilt @@ -0,0 +1,26 @@ +#ifndef BISON_Y_TAB_H +# define BISON_Y_TAB_H + +# define INTEGER 257 +# define REAL 258 +# define STRING 259 +# define IDENTIFIER 260 +# define WINDOWS_GUID 261 +# define KW_ARRAY 262 +# define KW_BYTE 263 +# define KW_CHAR 264 +# define KW_CSTRING 265 +# define KW_DOUBLE 266 +# define KW_DWORD 267 +# define KW_FLOAT 268 +# define KW_STRING 269 +# define KW_TEMPLATE 270 +# define KW_UCHAR 271 +# define KW_UNICODE 272 +# define KW_WORD 273 +# define ELLIPSIS 274 + + +extern YYSTYPE xyylval; + +#endif /* not BISON_Y_TAB_H */