src/ftacmp/schemalexer.cc

   1 #define yy_create_buffer SchemaParser_create_buffer
   2 #define yy_delete_buffer SchemaParser_delete_buffer
   3 #define yy_scan_buffer SchemaParser_scan_buffer
   4 #define yy_scan_string SchemaParser_scan_string
   5 #define yy_scan_bytes SchemaParser_scan_bytes
   6 #define yy_flex_debug SchemaParser_flex_debug
   7 #define yy_init_buffer SchemaParser_init_buffer
   8 #define yy_flush_buffer SchemaParser_flush_buffer
   9 #define yy_load_buffer_state SchemaParser_load_buffer_state
  10 #define yy_switch_to_buffer SchemaParser_switch_to_buffer
  11 #define yyin SchemaParserin
  12 #define yyleng SchemaParserleng
  13 #define yylex SchemaParserlex
  14 #define yyout SchemaParserout
  15 #define yyrestart SchemaParserrestart
  16 #define yytext SchemaParsertext
  17 #define yywrap SchemaParserwrap
  18
  19 #line 20 "schemalexer.cc"
  20 /* A lexical scanner generated by flex */
  21
  22 /* Scanner skeleton version:
  23  * $Header: /cvsroot/gscpv4/src/ftacmp/schemalexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $
  24  */
  25
  26 #define FLEX_SCANNER
  27 #define YY_FLEX_MAJOR_VERSION 2
  28 #define YY_FLEX_MINOR_VERSION 5
  29
  30 #include <stdio.h>
  31
  32
  33 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  34 #ifdef c_plusplus
  35 #ifndef __cplusplus
  36 #define __cplusplus
  37 #endif
  38 #endif
  39
  40
  41 #ifdef __cplusplus
  42
  43 #include <stdlib.h>
  44 #include <unistd.h>
  45
  46 /* Use prototypes in function declarations. */
  47 #define YY_USE_PROTOS
  48
  49 /* The "const" storage-class-modifier is valid. */
  50 #define YY_USE_CONST
  51
  52 #else   /* ! __cplusplus */
  53
  54 #if __STDC__
  55
  56 #define YY_USE_PROTOS
  57 #define YY_USE_CONST
  58
  59 #endif  /* __STDC__ */
  60 #endif  /* ! __cplusplus */
  61
  62 #ifdef __TURBOC__
  63  #pragma warn -rch
  64  #pragma warn -use
  65 #include <io.h>
  66 #include <stdlib.h>
  67 #define YY_USE_CONST
  68 #define YY_USE_PROTOS
  69 #endif
  70
  71 #ifdef YY_USE_CONST
  72 #define yyconst const
  73 #else
  74 #define yyconst
  75 #endif
  76
  77
  78 #ifdef YY_USE_PROTOS
  79 #define YY_PROTO(proto) proto
  80 #else
  81 #define YY_PROTO(proto) ()
  82 #endif
  83
  84 /* Returned upon end-of-file. */
  85 #define YY_NULL 0
  86
  87 /* Promotes a possibly negative, possibly signed char to an unsigned
  88  * integer for use as an array index.  If the signed char is negative,
  89  * we want to instead treat it as an 8-bit unsigned char, hence the
  90  * double cast.
  91  */
  92 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  93
  94 /* Enter a start condition.  This macro really ought to take a parameter,
  95  * but we do it the disgusting crufty way forced on us by the ()-less
  96  * definition of BEGIN.
  97  */
  98 #define BEGIN yy_start = 1 + 2 *
  99
 100 /* Translate the current start state into a value that can be later handed
 101  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 102  * compatibility.
 103  */
 104 #define YY_START ((yy_start - 1) / 2)
 105 #define YYSTATE YY_START
 106
 107 /* Action number for EOF rule of a given start state. */
 108 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 109
 110 /* Special action meaning "start processing a new file". */
 111 #define YY_NEW_FILE yyrestart( yyin )
 112
 113 #define YY_END_OF_BUFFER_CHAR 0
 114
 115 /* Size of default input buffer. */
 116 #define YY_BUF_SIZE 16384
 117
 118 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 119
 120 extern int yyleng;
 121 extern FILE *yyin, *yyout;
 122
 123 #define EOB_ACT_CONTINUE_SCAN 0
 124 #define EOB_ACT_END_OF_FILE 1
 125 #define EOB_ACT_LAST_MATCH 2
 126
 127 /* The funky do-while in the following #define is used to turn the definition
 128  * int a single C statement (which needs a semi-colon terminator).  This
 129  * avoids problems with code like:
 130  *
 131  *      if ( condition_holds )
 132  *              yyless( 5 );
 133  *      else
 134  *              do_something_else();
 135  *
 136  * Prior to using the do-while the compiler would get upset at the
 137  * "else" because it interpreted the "if" statement as being all
 138  * done when it reached the ';' after the yyless() call.
 139  */
 140
 141 /* Return all but the first 'n' matched characters back to the input stream. */
 142
 143 #define yyless(n) \
 144         do \
 145                 { \
 146                 /* Undo effects of setting up yytext. */ \
 147                 *yy_cp = yy_hold_char; \
 148                 YY_RESTORE_YY_MORE_OFFSET \
 149                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 150                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 151                 } \
 152         while ( 0 )
 153
 154 #define unput(c) yyunput( c, yytext_ptr )
 155
 156 /* The following is because we cannot portably get our hands on size_t
 157  * (without autoconf's help, which isn't available because we want
 158  * flex-generated scanners to compile on their own).
 159  */
 160 typedef unsigned int yy_size_t;
 161
 162
 163 struct yy_buffer_state
 164         {
 165         FILE *yy_input_file;
 166
 167         char *yy_ch_buf;                /* input buffer */
 168         char *yy_buf_pos;               /* current position in input buffer */
 169
 170         /* Size of input buffer in bytes, not including room for EOB
 171          * characters.
 172          */
 173         yy_size_t yy_buf_size;
 174
 175         /* Number of characters read into yy_ch_buf, not including EOB
 176          * characters.
 177          */
 178         int yy_n_chars;
 179
 180         /* Whether we "own" the buffer - i.e., we know we created it,
 181          * and can realloc() it to grow it, and should free() it to
 182          * delete it.
 183          */
 184         int yy_is_our_buffer;
 185
 186         /* Whether this is an "interactive" input source; if so, and
 187          * if we're using stdio for input, then we want to use getc()
 188          * instead of fread(), to make sure we stop fetching input after
 189          * each newline.
 190          */
 191         int yy_is_interactive;
 192
 193         /* Whether we're considered to be at the beginning of a line.
 194          * If so, '^' rules will be active on the next match, otherwise
 195          * not.
 196          */
 197         int yy_at_bol;
 198
 199         /* Whether to try to fill the input buffer when we reach the
 200          * end of it.
 201          */
 202         int yy_fill_buffer;
 203
 204         int yy_buffer_status;
 205 #define YY_BUFFER_NEW 0
 206 #define YY_BUFFER_NORMAL 1
 207         /* When an EOF's been seen but there's still some text to process
 208          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 209          * shouldn't try reading from the input source any more.  We might
 210          * still have a bunch of tokens to match, though, because of
 211          * possible backing-up.
 212          *
 213          * When we actually see the EOF, we change the status to "new"
 214          * (via yyrestart()), so that the user can continue scanning by
 215          * just pointing yyin at a new input file.
 216          */
 217 #define YY_BUFFER_EOF_PENDING 2
 218         };
 219
 220 static YY_BUFFER_STATE yy_current_buffer = 0;
 221
 222 /* We provide macros for accessing buffer states in case in the
 223  * future we want to put the buffer states in a more general
 224  * "scanner state".
 225  */
 226 #define YY_CURRENT_BUFFER yy_current_buffer
 227
 228
 229 /* yy_hold_char holds the character lost when yytext is formed. */
 230 static char yy_hold_char;
 231
 232 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 233
 234
 235 int yyleng;
 236
 237 /* Points to current character in buffer. */
 238 static char *yy_c_buf_p = (char *) 0;
 239 static int yy_init = 1;         /* whether we need to initialize */
 240 static int yy_start = 0;        /* start state number */
 241
 242 /* Flag which is used to allow yywrap()'s to do buffer switches
 243  * instead of setting up a fresh yyin.  A bit of a hack ...
 244  */
 245 static int yy_did_buffer_switch_on_eof;
 246
 247 void yyrestart YY_PROTO(( FILE *input_file ));
 248
 249 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 250 void yy_load_buffer_state YY_PROTO(( void ));
 251 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 252 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 253 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 254 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 255 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 256
 257 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 258 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 259 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 260
 261 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 262 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 263 static void yy_flex_free YY_PROTO(( void * ));
 264
 265 #define yy_new_buffer yy_create_buffer
 266
 267 #define yy_set_interactive(is_interactive) \
 268         { \
 269         if ( ! yy_current_buffer ) \
 270                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 271         yy_current_buffer->yy_is_interactive = is_interactive; \
 272         }
 273
 274 #define yy_set_bol(at_bol) \
 275         { \
 276         if ( ! yy_current_buffer ) \
 277                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 278         yy_current_buffer->yy_at_bol = at_bol; \
 279         }
 280
 281 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 282
 283 typedef unsigned char YY_CHAR;
 284 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 285 typedef int yy_state_type;
 286 extern char *yytext;
 287 #define yytext_ptr yytext
 288
 289 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 290 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 291 static int yy_get_next_buffer YY_PROTO(( void ));
 292 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 293
 294 /* Done after the current pattern has been matched and before the
 295  * corresponding action - sets up yytext.
 296  */
 297 #define YY_DO_BEFORE_ACTION \
 298         yytext_ptr = yy_bp; \
 299         yyleng = (int) (yy_cp - yy_bp); \
 300         yy_hold_char = *yy_cp; \
 301         *yy_cp = '\0'; \
 302         yy_c_buf_p = yy_cp;
 303
 304 #define YY_NUM_RULES 12
 305 #define YY_END_OF_BUFFER 13
 306 static yyconst short int yy_accept[31] =
 307     {   0,
 308         0,    0,   13,   11,    9,    8,    6,   11,    3,    7,
 309         7,    7,    4,    5,    9,    8,    0,    7,    7,    7,
 310         0,   10,    7,    7,    7,    7,    7,    1,    2,    0
 311     } ;
 312
 313 static yyconst int yy_ec[256] =
 314     {   0,
 315         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 316         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
 317         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 318         1,    2,    1,    1,    1,    1,    1,    1,    1,    4,
 319         4,    1,    1,    4,    5,    1,    1,    6,    6,    6,
 320         6,    6,    6,    6,    6,    6,    6,    1,    7,    1,
 321         1,    1,    1,    1,    8,    9,   10,   10,   11,   10,
 322        10,   10,   10,   10,   10,   12,   13,   10,   10,   10,
 323        10,   14,   15,   16,   10,   10,   10,   10,   10,   10,
 324         1,    1,    1,    1,    6,    1,   10,   10,   10,   10,
 325
 326        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
 327        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
 328        10,   10,   17,    1,   18,    1,    1,    1,    1,    1,
 329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 336
 337         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 338         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 340         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 341         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 342         1,    1,    1,    1,    1
 343     } ;
 344
 345 static yyconst int yy_meta[19] =
 346     {   0,
 347         1,    1,    2,    1,    1,    3,    1,    3,    3,    3,
 348         3,    3,    3,    3,    3,    3,    1,    1
 349     } ;
 350
 351 static yyconst short int yy_base[34] =
 352     {   0,
 353         0,    0,   39,   40,   36,    0,   40,   32,   40,    0,
 354        20,   27,   40,   40,   32,    0,   30,    0,   18,   22,
 355        27,   40,   18,   16,   19,   15,   12,    0,    0,   40,
 356        18,   17,   21
 357     } ;
 358
 359 static yyconst short int yy_def[34] =
 360     {   0,
 361        30,    1,   30,   30,   30,   31,   30,   30,   30,   32,
 362        32,   32,   30,   30,   30,   31,   33,   32,   32,   32,
 363        33,   30,   32,   32,   32,   32,   32,   32,   32,    0,
 364        30,   30,   30
 365     } ;
 366
 367 static yyconst short int yy_nxt[59] =
 368     {   0,
 369         4,    5,    6,    7,    8,    4,    9,   10,   10,   10,
 370        10,   10,   10,   10,   11,   12,   13,   14,   16,   18,
 371        16,   21,   21,   21,   29,   28,   27,   26,   25,   22,
 372        24,   23,   22,   15,   20,   19,   17,   15,   30,    3,
 373        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
 374        30,   30,   30,   30,   30,   30,   30,   30
 375     } ;
 376
 377 static yyconst short int yy_chk[59] =
 378     {   0,
 379         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 380         1,    1,    1,    1,    1,    1,    1,    1,   31,   32,
 381        31,   33,   33,   33,   27,   26,   25,   24,   23,   21,
 382        20,   19,   17,   15,   12,   11,    8,    5,    3,   30,
 383        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
 384        30,   30,   30,   30,   30,   30,   30,   30
 385     } ;
 386
 387 static yy_state_type yy_last_accepting_state;
 388 static char *yy_last_accepting_cpos;
 389
 390 /* The intent behind this definition is that it'll catch
 391  * any uses of REJECT which flex missed.
 392  */
 393 #define REJECT reject_used_but_not_detected
 394 #define yymore() yymore_used_but_not_detected
 395 #define YY_MORE_ADJ 0
 396 #define YY_RESTORE_YY_MORE_OFFSET
 397 char *yytext;
 398 #line 1 "schema.l"
 399 #define INITIAL 0
 400 /*
 401         MUST COMPILE WITH
 402                 flex -PSchemaParser -oschemalexer.cc schema.l
 403         (or equivalent).
 404 */
 405 #line 9 "schema.l"
 406 /*
 407  * AT&T lex can't handle this lexer due to lex bugs.  It works with flex
 408  * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
 409  */
 410
 411  #include "parse_schema.h"
 412  #include <string.h>
 413
 414
 415
 416 #include "schema.tab.cc.h"
 417
 418 /*
 419         Some includes that flex doesn't include as standard,
 420         but which are needed.
 421 */
 422
 423 #include <stdlib.h>
 424 #include <string.h>
 425
 426
 427 //              Prevent flex from defining yywrap as extern "C"
 428
 429 #define YY_SKIP_YYWRAP
 430
 431 /*              No lex lib, supply the yywrap fcn. that normally resides there
 432 */
 433
 434 int SchemaParserwrap(){return(1);}
 435
 436 extern int SchemaParserdebug;
 437
 438
 439 /*
 440                 These variables are used for error reporting:
 441                 flex_lineno : the line currently being parsed when the error occurs.
 442                 flexch : the character on the line where the error occurs
 443                 flex_linebuf : store the line for reporting.
 444
 445                 NOTE : 1) the fixed size flex_linebuf buffer is dangerous.
 446                            2) You might get pointed to a place shortly after
 447                                   where the syntax error occurs.  It is close enough
 448                                   for now.
 449 */
 450
 451 int flex_schema_lineno = 1;
 452 int flex_schema_ch = 0;
 453 char flex_schema_linebuf[1000];
 454
 455 //void SchemaParsererror(char *s);
 456
 457 void SchemaParsererror(char *s){
 458         printf("On line %d, char %d: %s (token %s):\n%s\n",
 459                                 flex_schema_lineno, flex_schema_ch, s, SchemaParsertext, flex_schema_linebuf );
 460         printf("%*s\n",1+flex_schema_ch,"^");
 461 }
 462
 463
 464 /* MKS needs the next line to increase the NFA table */
 465 #line 466 "schemalexer.cc"
 466
 467 /* Macros after this point can all be overridden by user definitions in
 468  * section 1.
 469  */
 470
 471 #ifndef YY_SKIP_YYWRAP
 472 #ifdef __cplusplus
 473 extern "C" int yywrap YY_PROTO(( void ));
 474 #else
 475 extern int yywrap YY_PROTO(( void ));
 476 #endif
 477 #endif
 478
 479 #ifndef YY_NO_UNPUT
 480 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 481 #endif
 482
 483 #ifndef yytext_ptr
 484 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 485 #endif
 486
 487 #ifdef YY_NEED_STRLEN
 488 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 489 #endif
 490
 491 #ifndef YY_NO_INPUT
 492 #ifdef __cplusplus
 493 static int yyinput YY_PROTO(( void ));
 494 #else
 495 static int input YY_PROTO(( void ));
 496 #endif
 497 #endif
 498
 499 #if YY_STACK_USED
 500 static int yy_start_stack_ptr = 0;
 501 static int yy_start_stack_depth = 0;
 502 static int *yy_start_stack = 0;
 503 #ifndef YY_NO_PUSH_STATE
 504 static void yy_push_state YY_PROTO(( int new_state ));
 505 #endif
 506 #ifndef YY_NO_POP_STATE
 507 static void yy_pop_state YY_PROTO(( void ));
 508 #endif
 509 #ifndef YY_NO_TOP_STATE
 510 static int yy_top_state YY_PROTO(( void ));
 511 #endif
 512
 513 #else
 514 #define YY_NO_PUSH_STATE 1
 515 #define YY_NO_POP_STATE 1
 516 #define YY_NO_TOP_STATE 1
 517 #endif
 518
 519 #ifdef YY_MALLOC_DECL
 520 YY_MALLOC_DECL
 521 #else
 522 #if __STDC__
 523 #ifndef __cplusplus
 524 #include <stdlib.h>
 525 #endif
 526 #else
 527 /* Just try to get by without declaring the routines.  This will fail
 528  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 529  * or sizeof(void*) != sizeof(int).
 530  */
 531 #endif
 532 #endif
 533
 534 /* Amount of stuff to slurp up with each read. */
 535 #ifndef YY_READ_BUF_SIZE
 536 #define YY_READ_BUF_SIZE 8192
 537 #endif
 538
 539 /* Copy whatever the last rule matched to the standard output. */
 540
 541 #ifndef ECHO
 542 /* This used to be an fputs(), but since the string might contain NUL's,
 543  * we now use fwrite().
 544  */
 545 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 546 #endif
 547
 548 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 549  * is returned in "result".
 550  */
 551 #ifndef YY_INPUT
 552 #define YY_INPUT(buf,result,max_size) \
 553         if ( yy_current_buffer->yy_is_interactive ) \
 554                 { \
 555                 int c = '*', n; \
 556                 for ( n = 0; n < max_size && \
 557                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 558                         buf[n] = (char) c; \
 559                 if ( c == '\n' ) \
 560                         buf[n++] = (char) c; \
 561                 if ( c == EOF && ferror( yyin ) ) \
 562                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 563                 result = n; \
 564                 } \
 565         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 566                   && ferror( yyin ) ) \
 567                 YY_FATAL_ERROR( "input in flex scanner failed" );
 568 #endif
 569
 570 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 571  * we don't want an extra ';' after the "return" because that will cause
 572  * some compilers to complain about unreachable statements.
 573  */
 574 #ifndef yyterminate
 575 #define yyterminate() return YY_NULL
 576 #endif
 577
 578 /* Number of entries by which start-condition stack grows. */
 579 #ifndef YY_START_STACK_INCR
 580 #define YY_START_STACK_INCR 25
 581 #endif
 582
 583 /* Report a fatal error. */
 584 #ifndef YY_FATAL_ERROR
 585 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 586 #endif
 587
 588 /* Default declaration of generated scanner - a define so the user can
 589  * easily add parameters.
 590  */
 591 #ifndef YY_DECL
 592 #define YY_DECL int yylex YY_PROTO(( void ))
 593 #endif
 594
 595 /* Code executed at the beginning of each rule, after yytext and yyleng
 596  * have been set up.
 597  */
 598 #ifndef YY_USER_ACTION
 599 #define YY_USER_ACTION
 600 #endif
 601
 602 /* Code executed at the end of each rule. */
 603 #ifndef YY_BREAK
 604 #define YY_BREAK break;
 605 #endif
 606
 607 #define YY_RULE_SETUP \
 608         YY_USER_ACTION
 609
 610 YY_DECL
 611         {
 612         register yy_state_type yy_current_state;
 613         register char *yy_cp, *yy_bp;
 614         register int yy_act;
 615
 616 #line 71 "schema.l"
 617
 618
 619         /* literal keyword tokens */
 620
 621  /*
 622                         The actions associated with each text token are to
 623                         keep track of the current location (for syntax error reporting)
 624                         and to report any necessary info to the emf.y parse tree builder
 625
 626                         Its likely that there are a number of omissions, inconsistencies
 627                         (some keywords do not need to be in caps), and relics
 628                         (keywords such as BETWEEN, INDICATOR, etc., are not used
 629                          in emf.y)
 630                         This parser is somewhat of a work in progress.
 631  */
 632
 633 #line 634 "schemalexer.cc"
 634
 635         if ( yy_init )
 636                 {
 637                 yy_init = 0;
 638
 639 #ifdef YY_USER_INIT
 640                 YY_USER_INIT;
 641 #endif
 642
 643                 if ( ! yy_start )
 644                         yy_start = 1;   /* first start state */
 645
 646                 if ( ! yyin )
 647                         yyin = stdin;
 648
 649                 if ( ! yyout )
 650                         yyout = stdout;
 651
 652                 if ( ! yy_current_buffer )
 653                         yy_current_buffer =
 654                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 655
 656                 yy_load_buffer_state();
 657                 }
 658
 659         while ( 1 )             /* loops until end-of-file is reached */
 660                 {
 661                 yy_cp = yy_c_buf_p;
 662
 663                 /* Support of yytext. */
 664                 *yy_cp = yy_hold_char;
 665
 666                 /* yy_bp points to the position in yy_ch_buf of the start of
 667                  * the current run.
 668                  */
 669                 yy_bp = yy_cp;
 670
 671                 yy_current_state = yy_start;
 672 yy_match:
 673                 do
 674                         {
 675                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 676                         if ( yy_accept[yy_current_state] )
 677                                 {
 678                                 yy_last_accepting_state = yy_current_state;
 679                                 yy_last_accepting_cpos = yy_cp;
 680                                 }
 681                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 682                                 {
 683                                 yy_current_state = (int) yy_def[yy_current_state];
 684                                 if ( yy_current_state >= 31 )
 685                                         yy_c = yy_meta[(unsigned int) yy_c];
 686                                 }
 687                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 688                         ++yy_cp;
 689                         }
 690                 while ( yy_base[yy_current_state] != 40 );
 691
 692 yy_find_action:
 693                 yy_act = yy_accept[yy_current_state];
 694                 if ( yy_act == 0 )
 695                         { /* have to back up */
 696                         yy_cp = yy_last_accepting_cpos;
 697                         yy_current_state = yy_last_accepting_state;
 698                         yy_act = yy_accept[yy_current_state];
 699                         }
 700
 701                 YY_DO_BEFORE_ACTION;
 702
 703
 704 do_action:      /* This label is used only to access EOF actions. */
 705
 706
 707                 switch ( yy_act )
 708         { /* beginning of action switch */
 709                         case 0: /* must back up */
 710                         /* undo the effects of YY_DO_BEFORE_ACTION */
 711                         *yy_cp = yy_hold_char;
 712                         yy_cp = yy_last_accepting_cpos;
 713                         yy_current_state = yy_last_accepting_state;
 714                         goto yy_find_action;
 715
 716 case 1:
 717 YY_RULE_SETUP
 718 #line 87 "schema.l"
 719 { flex_schema_ch+=SchemaParserleng; return TABLE; }
 720         YY_BREAK
 721 case 2:
 722 YY_RULE_SETUP
 723 #line 88 "schema.l"
 724 { flex_schema_ch+=SchemaParserleng; return STREAM; }
 725         YY_BREAK
 726 case 3:
 727 YY_RULE_SETUP
 728 #line 90 "schema.l"
 729 {flex_schema_ch+=SchemaParserleng; return SEMICOLON;}
 730         YY_BREAK
 731 case 4:
 732 YY_RULE_SETUP
 733 #line 91 "schema.l"
 734 {flex_schema_ch+=SchemaParserleng; return LEFTBRACE;}
 735         YY_BREAK
 736 case 5:
 737 YY_RULE_SETUP
 738 #line 92 "schema.l"
 739 {flex_schema_ch+=SchemaParserleng; return RIGHTBRACE;}
 740         YY_BREAK
 741 case 6:
 742 YY_RULE_SETUP
 743 #line 94 "schema.l"
 744 { flex_schema_ch+=SchemaParserleng; return yytext[0]; }
 745         YY_BREAK
 746 /* names */
 747 case 7:
 748 YY_RULE_SETUP
 749 #line 99 "schema.l"
 750 { flex_schema_ch+=SchemaParserleng; SchemaParserlval.strval = strdup(yytext); return NAME; }
 751         YY_BREAK
 752 /*                                                                                                                      */
 753 /*              Newline : advance the error reporting line number       */
 754 /*              and grab the next line into flex_linebuf                        */
 755 /*                                                                                                                      */
 756 case 8:
 757 YY_RULE_SETUP
 758 #line 107 "schema.l"
 759 {flex_schema_ch=0; flex_schema_lineno++;
 760                            strcpy(flex_schema_linebuf,SchemaParsertext+1);
 761                            yyless(1);
 762                            }
 763         YY_BREAK
 764 case 9:
 765 YY_RULE_SETUP
 766 #line 112 "schema.l"
 767 {flex_schema_ch+=SchemaParserleng; }    /* white space */
 768         YY_BREAK
 769 case 10:
 770 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 771 yy_c_buf_p = yy_cp -= 1;
 772 YY_DO_BEFORE_ACTION; /* set up yytext again */
 773 YY_RULE_SETUP
 774 #line 114 "schema.l"
 775 {flex_schema_ch+=SchemaParserleng; };   /* comment */
 776         YY_BREAK
 777 /*              Parse error on anything else.           */
 778 case 11:
 779 YY_RULE_SETUP
 780 #line 117 "schema.l"
 781 {fprintf(stderr,"Warning: unknown token (ignored)\n");  SchemaParsererror(yytext);}
 782         YY_BREAK
 783 case 12:
 784 YY_RULE_SETUP
 785 #line 120 "schema.l"
 786 ECHO;
 787         YY_BREAK
 788 #line 789 "schemalexer.cc"
 789 case YY_STATE_EOF(INITIAL):
 790         yyterminate();
 791
 792         case YY_END_OF_BUFFER:
 793                 {
 794                 /* Amount of text matched not including the EOB char. */
 795                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
 796
 797                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 798                 *yy_cp = yy_hold_char;
 799                 YY_RESTORE_YY_MORE_OFFSET
 800
 801                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
 802                         {
 803                         /* We're scanning a new file or input source.  It's
 804                          * possible that this happened because the user
 805                          * just pointed yyin at a new source and called
 806                          * yylex().  If so, then we have to assure
 807                          * consistency between yy_current_buffer and our
 808                          * globals.  Here is the right place to do so, because
 809                          * this is the first action (other than possibly a
 810                          * back-up) that will match for the new input source.
 811                          */
 812                         yy_n_chars = yy_current_buffer->yy_n_chars;
 813                         yy_current_buffer->yy_input_file = yyin;
 814                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
 815                         }
 816
 817                 /* Note that here we test for yy_c_buf_p "<=" to the position
 818                  * of the first EOB in the buffer, since yy_c_buf_p will
 819                  * already have been incremented past the NUL character
 820                  * (since all states make transitions on EOB to the
 821                  * end-of-buffer state).  Contrast this with the test
 822                  * in input().
 823                  */
 824                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 825                         { /* This was really a NUL. */
 826                         yy_state_type yy_next_state;
 827
 828                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 829
 830                         yy_current_state = yy_get_previous_state();
 831
 832                         /* Okay, we're now positioned to make the NUL
 833                          * transition.  We couldn't have
 834                          * yy_get_previous_state() go ahead and do it
 835                          * for us because it doesn't know how to deal
 836                          * with the possibility of jamming (and we don't
 837                          * want to build jamming into it because then it
 838                          * will run more slowly).
 839                          */
 840
 841                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 842
 843                         yy_bp = yytext_ptr + YY_MORE_ADJ;
 844
 845                         if ( yy_next_state )
 846                                 {
 847                                 /* Consume the NUL. */
 848                                 yy_cp = ++yy_c_buf_p;
 849                                 yy_current_state = yy_next_state;
 850                                 goto yy_match;
 851                                 }
 852
 853                         else
 854                                 {
 855                                 yy_cp = yy_c_buf_p;
 856                                 goto yy_find_action;
 857                                 }
 858                         }
 859
 860                 else switch ( yy_get_next_buffer() )
 861                         {
 862                         case EOB_ACT_END_OF_FILE:
 863                                 {
 864                                 yy_did_buffer_switch_on_eof = 0;
 865
 866                                 if ( yywrap() )
 867                                         {
 868                                         /* Note: because we've taken care in
 869                                          * yy_get_next_buffer() to have set up
 870                                          * yytext, we can now set up
 871                                          * yy_c_buf_p so that if some total
 872                                          * hoser (like flex itself) wants to
 873                                          * call the scanner after we return the
 874                                          * YY_NULL, it'll still work - another
 875                                          * YY_NULL will get returned.
 876                                          */
 877                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
 878
 879                                         yy_act = YY_STATE_EOF(YY_START);
 880                                         goto do_action;
 881                                         }
 882
 883                                 else
 884                                         {
 885                                         if ( ! yy_did_buffer_switch_on_eof )
 886                                                 YY_NEW_FILE;
 887                                         }
 888                                 break;
 889                                 }
 890
 891                         case EOB_ACT_CONTINUE_SCAN:
 892                                 yy_c_buf_p =
 893                                         yytext_ptr + yy_amount_of_matched_text;
 894
 895                                 yy_current_state = yy_get_previous_state();
 896
 897                                 yy_cp = yy_c_buf_p;
 898                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 899                                 goto yy_match;
 900
 901                         case EOB_ACT_LAST_MATCH:
 902                                 yy_c_buf_p =
 903                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
 904
 905                                 yy_current_state = yy_get_previous_state();
 906
 907                                 yy_cp = yy_c_buf_p;
 908                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 909                                 goto yy_find_action;
 910                         }
 911                 break;
 912                 }
 913
 914         default:
 915                 YY_FATAL_ERROR(
 916                         "fatal flex scanner internal error--no action found" );
 917         } /* end of action switch */
 918                 } /* end of scanning one token */
 919         } /* end of yylex */
 920
 921
 922 /* yy_get_next_buffer - try to read in a new buffer
 923  *
 924  * Returns a code representing an action:
 925  *      EOB_ACT_LAST_MATCH -
 926  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 927  *      EOB_ACT_END_OF_FILE - end of file
 928  */
 929
 930 static int yy_get_next_buffer()
 931         {
 932         register char *dest = yy_current_buffer->yy_ch_buf;
 933         register char *source = yytext_ptr;
 934         register int number_to_move, i;
 935         int ret_val;
 936
 937         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
 938                 YY_FATAL_ERROR(
 939                 "fatal flex scanner internal error--end of buffer missed" );
 940
 941         if ( yy_current_buffer->yy_fill_buffer == 0 )
 942                 { /* Don't try to fill the buffer, so this is an EOF. */
 943                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
 944                         {
 945                         /* We matched a single character, the EOB, so
 946                          * treat this as a final EOF.
 947                          */
 948                         return EOB_ACT_END_OF_FILE;
 949                         }
 950
 951                 else
 952                         {
 953                         /* We matched some text prior to the EOB, first
 954                          * process it.
 955                          */
 956                         return EOB_ACT_LAST_MATCH;
 957                         }
 958                 }
 959
 960         /* Try to read more data. */
 961
 962         /* First move last chars to start of buffer. */
 963         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
 964
 965         for ( i = 0; i < number_to_move; ++i )
 966                 *(dest++) = *(source++);
 967
 968         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 969                 /* don't do the read, it's not guaranteed to return an EOF,
 970                  * just force an EOF
 971                  */
 972                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
 973
 974         else
 975                 {
 976                 int num_to_read =
 977                         yy_current_buffer->yy_buf_size - number_to_move - 1;
 978
 979                 while ( num_to_read <= 0 )
 980                         { /* Not enough room in the buffer - grow it. */
 981 #ifdef YY_USES_REJECT
 982                         YY_FATAL_ERROR(
 983 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
 984 #else
 985
 986                         /* just a shorter name for the current buffer */
 987                         YY_BUFFER_STATE b = yy_current_buffer;
 988
 989                         int yy_c_buf_p_offset =
 990                                 (int) (yy_c_buf_p - b->yy_ch_buf);
 991
 992                         if ( b->yy_is_our_buffer )
 993                                 {
 994                                 int new_size = b->yy_buf_size * 2;
 995
 996                                 if ( new_size <= 0 )
 997                                         b->yy_buf_size += b->yy_buf_size / 8;
 998                                 else
 999                                         b->yy_buf_size *= 2;
1000
1001                                 b->yy_ch_buf = (char *)
1002                                         /* Include room in for 2 EOB chars. */
1003                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1004                                                          b->yy_buf_size + 2 );
1005                                 }
1006                         else
1007                                 /* Can't grow it, we don't own it. */
1008                                 b->yy_ch_buf = 0;
1009
1010                         if ( ! b->yy_ch_buf )
1011                                 YY_FATAL_ERROR(
1012                                 "fatal error - scanner input buffer overflow" );
1013
1014                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1015
1016                         num_to_read = yy_current_buffer->yy_buf_size -
1017                                                 number_to_move - 1;
1018 #endif
1019                         }
1020
1021                 if ( num_to_read > YY_READ_BUF_SIZE )
1022                         num_to_read = YY_READ_BUF_SIZE;
1023
1024                 /* Read in more data. */
1025                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1026                         yy_n_chars, num_to_read );
1027
1028                 yy_current_buffer->yy_n_chars = yy_n_chars;
1029                 }
1030
1031         if ( yy_n_chars == 0 )
1032                 {
1033                 if ( number_to_move == YY_MORE_ADJ )
1034                         {
1035                         ret_val = EOB_ACT_END_OF_FILE;
1036                         yyrestart( yyin );
1037                         }
1038
1039                 else
1040                         {
1041                         ret_val = EOB_ACT_LAST_MATCH;
1042                         yy_current_buffer->yy_buffer_status =
1043                                 YY_BUFFER_EOF_PENDING;
1044                         }
1045                 }
1046
1047         else
1048                 ret_val = EOB_ACT_CONTINUE_SCAN;
1049
1050         yy_n_chars += number_to_move;
1051         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1052         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1053
1054         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1055
1056         return ret_val;
1057         }
1058
1059
1060 /* yy_get_previous_state - get the state just before the EOB char was reached */
1061
1062 static yy_state_type yy_get_previous_state()
1063         {
1064         register yy_state_type yy_current_state;
1065         register char *yy_cp;
1066
1067         yy_current_state = yy_start;
1068
1069         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1070                 {
1071                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1072                 if ( yy_accept[yy_current_state] )
1073                         {
1074                         yy_last_accepting_state = yy_current_state;
1075                         yy_last_accepting_cpos = yy_cp;
1076                         }
1077                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1078                         {
1079                         yy_current_state = (int) yy_def[yy_current_state];
1080                         if ( yy_current_state >= 31 )
1081                                 yy_c = yy_meta[(unsigned int) yy_c];
1082                         }
1083                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1084                 }
1085
1086         return yy_current_state;
1087         }
1088
1089
1090 /* yy_try_NUL_trans - try to make a transition on the NUL character
1091  *
1092  * synopsis
1093  *      next_state = yy_try_NUL_trans( current_state );
1094  */
1095
1096 #ifdef YY_USE_PROTOS
1097 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1098 #else
1099 static yy_state_type yy_try_NUL_trans( yy_current_state )
1100 yy_state_type yy_current_state;
1101 #endif
1102         {
1103         register int yy_is_jam;
1104         register char *yy_cp = yy_c_buf_p;
1105
1106         register YY_CHAR yy_c = 1;
1107         if ( yy_accept[yy_current_state] )
1108                 {
1109                 yy_last_accepting_state = yy_current_state;
1110                 yy_last_accepting_cpos = yy_cp;
1111                 }
1112         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1113                 {
1114                 yy_current_state = (int) yy_def[yy_current_state];
1115                 if ( yy_current_state >= 31 )
1116                         yy_c = yy_meta[(unsigned int) yy_c];
1117                 }
1118         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1119         yy_is_jam = (yy_current_state == 30);
1120
1121         return yy_is_jam ? 0 : yy_current_state;
1122         }
1123
1124
1125 #ifndef YY_NO_UNPUT
1126 #ifdef YY_USE_PROTOS
1127 static void yyunput( int c, register char *yy_bp )
1128 #else
1129 static void yyunput( c, yy_bp )
1130 int c;
1131 register char *yy_bp;
1132 #endif
1133         {
1134         register char *yy_cp = yy_c_buf_p;
1135
1136         /* undo effects of setting up yytext */
1137         *yy_cp = yy_hold_char;
1138
1139         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1140                 { /* need to shift things up to make room */
1141                 /* +2 for EOB chars. */
1142                 register int number_to_move = yy_n_chars + 2;
1143                 register char *dest = &yy_current_buffer->yy_ch_buf[
1144                                         yy_current_buffer->yy_buf_size + 2];
1145                 register char *source =
1146                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1147
1148                 while ( source > yy_current_buffer->yy_ch_buf )
1149                         *--dest = *--source;
1150
1151                 yy_cp += (int) (dest - source);
1152                 yy_bp += (int) (dest - source);
1153                 yy_current_buffer->yy_n_chars =
1154                         yy_n_chars = yy_current_buffer->yy_buf_size;
1155
1156                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1157                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1158                 }
1159
1160         *--yy_cp = (char) c;
1161
1162
1163         yytext_ptr = yy_bp;
1164         yy_hold_char = *yy_cp;
1165         yy_c_buf_p = yy_cp;
1166         }
1167 #endif  /* ifndef YY_NO_UNPUT */
1168
1169
1170 #ifdef __cplusplus
1171 static int yyinput()
1172 #else
1173 static int input()
1174 #endif
1175         {
1176         int c;
1177         static int _xpg = -1;
1178
1179         if (_xpg == -1)
1180                 {
1181                         char *_xpgenv = getenv("_XPG");
1182                         if (_xpgenv == NULL)
1183                                 _xpg = 0;
1184                         else
1185                                 {
1186                                 _xpg = atoi(_xpgenv);
1187                                 if (_xpg < 0)
1188                                         _xpg = 0;
1189                                 }
1190                 }
1191
1192         *yy_c_buf_p = yy_hold_char;
1193
1194         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1195                 {
1196                 /* yy_c_buf_p now points to the character we want to return.
1197                  * If this occurs *before* the EOB characters, then it's a
1198                  * valid NUL; if not, then we've hit the end of the buffer.
1199                  */
1200                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1201                         /* This was really a NUL. */
1202                         *yy_c_buf_p = '\0';
1203
1204                 else
1205                         { /* need more input */
1206                         int offset = yy_c_buf_p - yytext_ptr;
1207                         ++yy_c_buf_p;
1208
1209                         switch ( yy_get_next_buffer() )
1210                                 {
1211                                 case EOB_ACT_LAST_MATCH:
1212                                         /* This happens because yy_g_n_b()
1213                                          * sees that we've accumulated a
1214                                          * token and flags that we need to
1215                                          * try matching the token before
1216                                          * proceeding.  But for input(),
1217                                          * there's no matching to consider.
1218                                          * So convert the EOB_ACT_LAST_MATCH
1219                                          * to EOB_ACT_END_OF_FILE.
1220                                          */
1221
1222                                         /* Reset buffer status. */
1223                                         yyrestart( yyin );
1224
1225                                         /* fall through */
1226
1227                                 case EOB_ACT_END_OF_FILE:
1228                                         if (_xpg)
1229                                                 return 0;
1230                                         else
1231                                                 {
1232                                                 if ( yywrap() )
1233                                                         return 0;
1234
1235                                                 if ( ! yy_did_buffer_switch_on_eof )
1236                                                         YY_NEW_FILE;
1237 #ifdef __cplusplus
1238                                                 return yyinput();
1239 #else
1240                                                 return input();
1241 #endif
1242                                                 }
1243
1244                                 case EOB_ACT_CONTINUE_SCAN:
1245                                         yy_c_buf_p = yytext_ptr + offset;
1246                                         break;
1247                                 }
1248                         }
1249                 }
1250
1251         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1252         *yy_c_buf_p = '\0';     /* preserve yytext */
1253         yy_hold_char = *++yy_c_buf_p;
1254
1255
1256         return c;
1257         }
1258
1259
1260 #ifdef YY_USE_PROTOS
1261 void yyrestart( FILE *input_file )
1262 #else
1263 void yyrestart( input_file )
1264 FILE *input_file;
1265 #endif
1266         {
1267         if ( ! yy_current_buffer )
1268                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1269
1270         yy_init_buffer( yy_current_buffer, input_file );
1271         yy_load_buffer_state();
1272         }
1273
1274
1275 #ifdef YY_USE_PROTOS
1276 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1277 #else
1278 void yy_switch_to_buffer( new_buffer )
1279 YY_BUFFER_STATE new_buffer;
1280 #endif
1281         {
1282         if ( yy_current_buffer == new_buffer )
1283                 return;
1284
1285         if ( yy_current_buffer )
1286                 {
1287                 /* Flush out information for old buffer. */
1288                 *yy_c_buf_p = yy_hold_char;
1289                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1290                 yy_current_buffer->yy_n_chars = yy_n_chars;
1291                 }
1292
1293         yy_current_buffer = new_buffer;
1294         yy_load_buffer_state();
1295
1296         /* We don't actually know whether we did this switch during
1297          * EOF (yywrap()) processing, but the only time this flag
1298          * is looked at is after yywrap() is called, so it's safe
1299          * to go ahead and always set it.
1300          */
1301         yy_did_buffer_switch_on_eof = 1;
1302         }
1303
1304
1305 #ifdef YY_USE_PROTOS
1306 void yy_load_buffer_state( void )
1307 #else
1308 void yy_load_buffer_state()
1309 #endif
1310         {
1311         yy_n_chars = yy_current_buffer->yy_n_chars;
1312         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1313         yyin = yy_current_buffer->yy_input_file;
1314         yy_hold_char = *yy_c_buf_p;
1315         }
1316
1317
1318 #ifdef YY_USE_PROTOS
1319 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1320 #else
1321 YY_BUFFER_STATE yy_create_buffer( file, size )
1322 FILE *file;
1323 int size;
1324 #endif
1325         {
1326         YY_BUFFER_STATE b;
1327
1328         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1329         if ( ! b )
1330                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1331
1332         b->yy_buf_size = size;
1333
1334         /* yy_ch_buf has to be 2 characters longer than the size given because
1335          * we need to put in 2 end-of-buffer characters.
1336          */
1337         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1338         if ( ! b->yy_ch_buf )
1339                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1340
1341         b->yy_is_our_buffer = 1;
1342
1343         yy_init_buffer( b, file );
1344
1345         return b;
1346         }
1347
1348
1349 #ifdef YY_USE_PROTOS
1350 void yy_delete_buffer( YY_BUFFER_STATE b )
1351 #else
1352 void yy_delete_buffer( b )
1353 YY_BUFFER_STATE b;
1354 #endif
1355         {
1356         if ( ! b )
1357                 return;
1358
1359         if ( b == yy_current_buffer )
1360                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1361
1362         if ( b->yy_is_our_buffer )
1363                 yy_flex_free( (void *) b->yy_ch_buf );
1364
1365         yy_flex_free( (void *) b );
1366         }
1367
1368
1369 #ifndef YY_ALWAYS_INTERACTIVE
1370 #ifndef YY_NEVER_INTERACTIVE
1371 extern int isatty YY_PROTO(( int ));
1372 #endif
1373 #endif
1374
1375 #ifdef YY_USE_PROTOS
1376 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1377 #else
1378 void yy_init_buffer( b, file )
1379 YY_BUFFER_STATE b;
1380 FILE *file;
1381 #endif
1382
1383
1384         {
1385         yy_flush_buffer( b );
1386
1387         b->yy_input_file = file;
1388         b->yy_fill_buffer = 1;
1389
1390 #if YY_ALWAYS_INTERACTIVE
1391         b->yy_is_interactive = 1;
1392 #else
1393 #if YY_NEVER_INTERACTIVE
1394         b->yy_is_interactive = 0;
1395 #else
1396         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1397 #endif
1398 #endif
1399         }
1400
1401
1402 #ifdef YY_USE_PROTOS
1403 void yy_flush_buffer( YY_BUFFER_STATE b )
1404 #else
1405 void yy_flush_buffer( b )
1406 YY_BUFFER_STATE b;
1407 #endif
1408
1409         {
1410         if ( ! b )
1411                 return;
1412
1413         b->yy_n_chars = 0;
1414
1415         /* We always need two end-of-buffer characters.  The first causes
1416          * a transition to the end-of-buffer state.  The second causes
1417          * a jam in that state.
1418          */
1419         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1420         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1421
1422         b->yy_buf_pos = &b->yy_ch_buf[0];
1423
1424         b->yy_at_bol = 1;
1425         b->yy_buffer_status = YY_BUFFER_NEW;
1426
1427         if ( b == yy_current_buffer )
1428                 yy_load_buffer_state();
1429         }
1430
1431
1432 #ifndef YY_NO_SCAN_BUFFER
1433 #ifdef YY_USE_PROTOS
1434 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1435 #else
1436 YY_BUFFER_STATE yy_scan_buffer( base, size )
1437 char *base;
1438 yy_size_t size;
1439 #endif
1440         {
1441         YY_BUFFER_STATE b;
1442
1443         if ( size < 2 ||
1444              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1445              base[size-1] != YY_END_OF_BUFFER_CHAR )
1446                 /* They forgot to leave room for the EOB's. */
1447                 return 0;
1448
1449         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1450         if ( ! b )
1451                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1452
1453         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1454         b->yy_buf_pos = b->yy_ch_buf = base;
1455         b->yy_is_our_buffer = 0;
1456         b->yy_input_file = 0;
1457         b->yy_n_chars = b->yy_buf_size;
1458         b->yy_is_interactive = 0;
1459         b->yy_at_bol = 1;
1460         b->yy_fill_buffer = 0;
1461         b->yy_buffer_status = YY_BUFFER_NEW;
1462
1463         yy_switch_to_buffer( b );
1464
1465         return b;
1466         }
1467 #endif
1468
1469
1470 #ifndef YY_NO_SCAN_STRING
1471 #ifdef YY_USE_PROTOS
1472 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1473 #else
1474 YY_BUFFER_STATE yy_scan_string( yy_str )
1475 yyconst char *yy_str;
1476 #endif
1477         {
1478         int len;
1479         for ( len = 0; yy_str[len]; ++len )
1480                 ;
1481
1482         return yy_scan_bytes( yy_str, len );
1483         }
1484 #endif
1485
1486
1487 #ifndef YY_NO_SCAN_BYTES
1488 #ifdef YY_USE_PROTOS
1489 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1490 #else
1491 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1492 yyconst char *bytes;
1493 int len;
1494 #endif
1495         {
1496         YY_BUFFER_STATE b;
1497         char *buf;
1498         yy_size_t n;
1499         int i;
1500
1501         /* Get memory for full buffer, including space for trailing EOB's. */
1502         n = len + 2;
1503         buf = (char *) yy_flex_alloc( n );
1504         if ( ! buf )
1505                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1506
1507         for ( i = 0; i < len; ++i )
1508                 buf[i] = bytes[i];
1509
1510         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1511
1512         b = yy_scan_buffer( buf, n );
1513         if ( ! b )
1514                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1515
1516         /* It's okay to grow etc. this buffer, and we should throw it
1517          * away when we're done.
1518          */
1519         b->yy_is_our_buffer = 1;
1520
1521         return b;
1522         }
1523 #endif
1524
1525
1526 #ifndef YY_NO_PUSH_STATE
1527 #ifdef YY_USE_PROTOS
1528 static void yy_push_state( int new_state )
1529 #else
1530 static void yy_push_state( new_state )
1531 int new_state;
1532 #endif
1533         {
1534         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1535                 {
1536                 yy_size_t new_size;
1537
1538                 yy_start_stack_depth += YY_START_STACK_INCR;
1539                 new_size = yy_start_stack_depth * sizeof( int );
1540
1541                 if ( ! yy_start_stack )
1542                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1543
1544                 else
1545                         yy_start_stack = (int *) yy_flex_realloc(
1546                                         (void *) yy_start_stack, new_size );
1547
1548                 if ( ! yy_start_stack )
1549                         YY_FATAL_ERROR(
1550                         "out of memory expanding start-condition stack" );
1551                 }
1552
1553         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1554
1555         BEGIN(new_state);
1556         }
1557 #endif
1558
1559
1560 #ifndef YY_NO_POP_STATE
1561 static void yy_pop_state()
1562         {
1563         if ( --yy_start_stack_ptr < 0 )
1564                 YY_FATAL_ERROR( "start-condition stack underflow" );
1565
1566         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1567         }
1568 #endif
1569
1570
1571 #ifndef YY_NO_TOP_STATE
1572 static int yy_top_state()
1573         {
1574         return yy_start_stack[yy_start_stack_ptr - 1];
1575         }
1576 #endif
1577
1578 #ifndef YY_EXIT_FAILURE
1579 #define YY_EXIT_FAILURE 2
1580 #endif
1581
1582 #ifdef YY_USE_PROTOS
1583 static void yy_fatal_error( yyconst char msg[] )
1584 #else
1585 static void yy_fatal_error( msg )
1586 char msg[];
1587 #endif
1588         {
1589         (void) fprintf( stderr, "%s\n", msg );
1590         exit( YY_EXIT_FAILURE );
1591         }
1592
1593
1594
1595 /* Redefine yyless() so it works in section 3 code. */
1596
1597 #undef yyless
1598 #define yyless(n) \
1599         do \
1600                 { \
1601                 /* Undo effects of setting up yytext. */ \
1602                 yytext[yyleng] = yy_hold_char; \
1603                 yy_c_buf_p = yytext + n; \
1604                 yy_hold_char = *yy_c_buf_p; \
1605                 *yy_c_buf_p = '\0'; \
1606                 yyleng = n; \
1607                 } \
1608         while ( 0 )
1609
1610
1611 /* Internal utility routines. */
1612
1613 #ifndef yytext_ptr
1614 #ifdef YY_USE_PROTOS
1615 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1616 #else
1617 static void yy_flex_strncpy( s1, s2, n )
1618 char *s1;
1619 yyconst char *s2;
1620 int n;
1621 #endif
1622         {
1623         register int i;
1624         for ( i = 0; i < n; ++i )
1625                 s1[i] = s2[i];
1626         }
1627 #endif
1628
1629 #ifdef YY_NEED_STRLEN
1630 #ifdef YY_USE_PROTOS
1631 static int yy_flex_strlen( yyconst char *s )
1632 #else
1633 static int yy_flex_strlen( s )
1634 yyconst char *s;
1635 #endif
1636         {
1637         register int n;
1638         for ( n = 0; s[n]; ++n )
1639                 ;
1640
1641         return n;
1642         }
1643 #endif
1644
1645
1646 #ifdef YY_USE_PROTOS
1647 static void *yy_flex_alloc( yy_size_t size )
1648 #else
1649 static void *yy_flex_alloc( size )
1650 yy_size_t size;
1651 #endif
1652         {
1653         return (void *) malloc( size );
1654         }
1655
1656 #ifdef YY_USE_PROTOS
1657 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1658 #else
1659 static void *yy_flex_realloc( ptr, size )
1660 void *ptr;
1661 yy_size_t size;
1662 #endif
1663         {
1664         /* The cast to (char *) in the following accommodates both
1665          * implementations that use char* generic pointers, and those
1666          * that use void* generic pointers.  It works with the latter
1667          * because both ANSI C and C++ allow castless assignment from
1668          * any pointer type to void*, and deal with argument conversions
1669          * as though doing an assignment.
1670          */
1671         return (void *) realloc( (char *) ptr, size );
1672         }
1673
1674 #ifdef YY_USE_PROTOS
1675 static void yy_flex_free( void *ptr )
1676 #else
1677 static void yy_flex_free( ptr )
1678 void *ptr;
1679 #endif
1680         {
1681         free( ptr );
1682         }
1683
1684 #if YY_MAIN
1685 int main()
1686         {
1687         yylex();
1688         return 0;
1689         }
1690 #endif
1691 #line 120 "schema.l"
1692
1693
1694