lib/flex/skel.c

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