home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / gnu / flex-2.4.6-src.lha / src / amiga / flex-2.4.6 / flex.skl < prev    next >
Text File  |  1994-01-04  |  27KB  |  1,217 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* Scanner skeleton version:
  4.  * $Header: flex.skl,v 1.2 94/01/04 14:33:15 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8.  
  9. %-
  10. #include <stdio.h>
  11. %*
  12.  
  13.  
  14. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15. #ifdef c_plusplus
  16. #ifndef __cplusplus
  17. #define __cplusplus
  18. #endif
  19. #endif
  20.  
  21.  
  22. #ifdef __cplusplus
  23.  
  24. #include <stdlib.h>
  25. %+
  26. class istream;
  27. %*
  28. #include <unistd.h>
  29.  
  30. /* Use prototypes in function declarations. */
  31. #define YY_USE_PROTOS
  32.  
  33. /* The "const" storage-class-modifier is valid. */
  34. #define YY_USE_CONST
  35.  
  36. #else    /* ! __cplusplus */
  37.  
  38. #ifdef __STDC__
  39.  
  40. #define YY_USE_PROTOS
  41. #define YY_USE_CONST
  42.  
  43. #endif    /* __STDC__ */
  44. #endif    /* ! __cplusplus */
  45.  
  46.  
  47. #ifdef __TURBOC__
  48. #define YY_USE_CONST
  49. #endif
  50.  
  51.  
  52. #ifndef YY_USE_CONST
  53. #ifndef const
  54. #define const
  55. #endif
  56. #endif
  57.  
  58.  
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  64.  
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  67.  
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74.  
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  80.  
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.
  83.  */
  84. #define YY_START ((yy_start - 1) / 2)
  85.  
  86. /* Action number for EOF rule of a given start state. */
  87. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  88.  
  89. /* Special action meaning "start processing a new file".  Now included
  90.  * only for backward compatibility with previous versions of flex.
  91.  */
  92. #define YY_NEW_FILE yyrestart( yyin )
  93.  
  94. #define YY_END_OF_BUFFER_CHAR 0
  95.  
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  98.  
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  100.  
  101. extern int yyleng;
  102. %-
  103. extern FILE *yyin, *yyout;
  104. %*
  105.  
  106. #ifdef __cplusplus
  107. extern "C" {
  108. #endif
  109.     extern int yywrap YY_PROTO(( void ));
  110. #ifdef __cplusplus
  111.     }
  112. #endif
  113.  
  114. #define EOB_ACT_CONTINUE_SCAN 0
  115. #define EOB_ACT_END_OF_FILE 1
  116. #define EOB_ACT_LAST_MATCH 2
  117.  
  118. /* The funky do-while in the following #define is used to turn the definition
  119.  * int a single C statement (which needs a semi-colon terminator).  This
  120.  * avoids problems with code like:
  121.  *
  122.  *     if ( condition_holds )
  123.  *        yyless( 5 );
  124.  *    else
  125.  *        do_something_else();
  126.  *
  127.  * Prior to using the do-while the compiler would get upset at the
  128.  * "else" because it interpreted the "if" statement as being all
  129.  * done when it reached the ';' after the yyless() call.
  130.  */
  131.  
  132. /* Return all but the first 'n' matched characters back to the input stream. */
  133.  
  134. #define yyless(n) \
  135.     do \
  136.         { \
  137.         /* Undo effects of setting up yytext. */ \
  138.         *yy_cp = yy_hold_char; \
  139.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  140.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  141.         } \
  142.     while ( 0 )
  143.  
  144. #define unput(c) yyunput( c, yytext_ptr )
  145.  
  146.  
  147. struct yy_buffer_state
  148.     {
  149. %-
  150.     FILE *yy_input_file;
  151. %+
  152.     istream* yy_input_file;
  153. %*
  154.  
  155.     char *yy_ch_buf;        /* input buffer */
  156.     char *yy_buf_pos;        /* current position in input buffer */
  157.  
  158.     /* Size of input buffer in bytes, not including room for EOB
  159.      * characters.
  160.      */
  161.     int yy_buf_size;
  162.  
  163.     /* Number of characters read into yy_ch_buf, not including EOB
  164.      * characters.
  165.      */
  166.     int yy_n_chars;
  167.  
  168.     /* Whether this is an "interactive" input source; if so, and
  169.      * if we're using stdio for input, then we want to use getc()
  170.      * instead of fread(), to make sure we stop fetching input after
  171.      * each newline.
  172.      */
  173.     int yy_is_interactive;
  174.  
  175.     /* Whether to try to fill the input buffer when we reach the
  176.      * end of it.
  177.      */
  178.     int yy_fill_buffer;
  179.  
  180.     /* Whether we've seen an EOF on this buffer. */
  181.     int yy_eof_status;
  182. #define EOF_NOT_SEEN 0
  183.     /* "Pending" happens when the EOF has been seen but there's still
  184.      * some text to process.  Note that when we actually see the EOF,
  185.      * we switch the status back to "not seen" (via yyrestart()), so
  186.      * that the user can continue scanning by just pointing yyin at
  187.      * a new input file.
  188.      */
  189. #define EOF_PENDING 1
  190.     };
  191.  
  192. %- Standard (non-C++) definition
  193. static YY_BUFFER_STATE yy_current_buffer = 0;
  194. %*
  195.  
  196. /* We provide macros for accessing buffer states in case in the
  197.  * future we want to put the buffer states in a more general
  198.  * "scanner state".
  199.  */
  200. #define YY_CURRENT_BUFFER yy_current_buffer
  201.  
  202.  
  203. %- Standard (non-C++) definition
  204. /* yy_hold_char holds the character lost when yytext is formed. */
  205. static char yy_hold_char;
  206.  
  207. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  208.  
  209.  
  210. int yyleng;
  211.  
  212. /* Points to current character in buffer. */
  213. static char *yy_c_buf_p = (char *) 0;
  214. static int yy_init = 1;        /* whether we need to initialize */
  215. static int yy_start = 0;    /* start state number */
  216.  
  217. /* Flag which is used to allow yywrap()'s to do buffer switches
  218.  * instead of setting up a fresh yyin.  A bit of a hack ...
  219.  */
  220. static int yy_did_buffer_switch_on_eof;
  221.  
  222. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  223. void yyrestart YY_PROTO(( FILE *input_file ));
  224. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  225. void yy_load_buffer_state YY_PROTO(( void ));
  226. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  227. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  228. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  229.  
  230. static int yy_start_stack_ptr = 0;
  231. static int yy_start_stack_depth = 0;
  232. static int *yy_start_stack = 0;
  233. static void yy_push_state YY_PROTO(( int new_state ));
  234. static void yy_pop_state YY_PROTO(( void ));
  235. static int yy_top_state YY_PROTO(( void ));
  236. %*
  237.  
  238. #ifndef yytext_ptr
  239. static void yy_flex_strcpy YY_PROTO(( char *, const char * ));
  240. #endif
  241.  
  242. static void *yy_flex_alloc YY_PROTO(( unsigned int ));
  243. static void *yy_flex_realloc YY_PROTO(( void *ptr, unsigned int ));
  244. static void yy_flex_free YY_PROTO(( void * ));
  245.  
  246. #define yy_new_buffer yy_create_buffer
  247.  
  248. %% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here
  249.  
  250. %- Standard (non-C++) definition
  251. #ifdef __cplusplus
  252. static int yyinput YY_PROTO(( void ));
  253. #else
  254. static int input YY_PROTO(( void ));
  255. #endif
  256. %*
  257.  
  258. %- Standard (non-C++) definition
  259. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  260. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  261. static int yy_get_next_buffer YY_PROTO(( void ));
  262. static void yy_fatal_error YY_PROTO(( const char msg[] ));
  263. %*
  264.  
  265. /* Done after the current pattern has been matched and before the
  266.  * corresponding action - sets up yytext.
  267.  */
  268. #define YY_DO_BEFORE_ACTION \
  269.     yytext_ptr = yy_bp; \
  270. %% code to fiddle yytext and yyleng for yymore() goes here
  271.     yy_hold_char = *yy_cp; \
  272.     *yy_cp = '\0'; \
  273. %% code to copy yytext_ptr to yytext[] goes here, if %array
  274.     yy_c_buf_p = yy_cp;
  275.  
  276. %% data tables for the DFA and the user's section 1 definitions go here
  277.  
  278. /* Macros after this point can all be overridden by user definitions in
  279.  * section 1.
  280.  */
  281.  
  282. #ifdef YY_MALLOC_DECL
  283. YY_MALLOC_DECL
  284. #else
  285. #if __STDC__
  286. #ifndef __cplusplus
  287. #include <stdlib.h>
  288. #endif
  289. #else
  290. /* Just try to get by without declaring the routines.  This will fail
  291.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  292.  * or sizeof(void*) != sizeof(int).
  293.  */
  294. #endif
  295. #endif
  296.  
  297. /* Amount of stuff to slurp up with each read. */
  298. #ifndef YY_READ_BUF_SIZE
  299. #define YY_READ_BUF_SIZE 8192
  300. #endif
  301.  
  302. /* Copy whatever the last rule matched to the standard output. */
  303.  
  304. #ifndef ECHO
  305. %- Standard (non-C++) definition
  306. /* This used to be an fputs(), but since the string might contain NUL's,
  307.  * we now use fwrite().
  308.  */
  309. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  310. %+ C++ definition
  311. #define ECHO LexerOutput( yytext, yyleng )
  312. %*
  313. #endif
  314.  
  315. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  316.  * is returned in "result".
  317.  */
  318. #ifndef YY_INPUT
  319. #define YY_INPUT(buf,result,max_size) \
  320. %% fread()/read() definition of YY_INPUT goes here unless we're doing C++
  321. %+ C++ definition
  322.     if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
  323.         YY_FATAL_ERROR( "input in flex scanner failed" );
  324. %*
  325. #endif
  326.  
  327. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  328.  * we don't want an extra ';' after the "return" because that will cause
  329.  * some compilers to complain about unreachable statements.
  330.  */
  331. #ifndef yyterminate
  332. #define yyterminate() return YY_NULL
  333. #endif
  334.  
  335. /* Number of entries by which start-condition stack grows. */
  336. #ifndef YY_START_STACK_INCR
  337. #define YY_START_STACK_INCR 25
  338. #endif
  339.  
  340. /* Report a fatal error. */
  341. #ifndef YY_FATAL_ERROR
  342. %-
  343. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  344. %+
  345. #define YY_FATAL_ERROR(msg) LexerError( msg )
  346. %*
  347. #endif
  348.  
  349. /* Default declaration of generated scanner - a define so the user can
  350.  * easily add parameters.
  351.  */
  352. #ifndef YY_DECL
  353. %- Standard (non-C++) definition
  354. #define YY_DECL int yylex YY_PROTO(( void ))
  355. %+ C++ definition
  356. #define YY_DECL int yyFlexLexer::yylex()
  357. %*
  358. #endif
  359.  
  360. /* Code executed at the beginning of each rule, after yytext and yyleng
  361.  * have been set up.
  362.  */
  363. #ifndef YY_USER_ACTION
  364. #define YY_USER_ACTION
  365. #endif
  366.  
  367. /* Code executed at the end of each rule. */
  368. #ifndef YY_BREAK
  369. #define YY_BREAK break;
  370. #endif
  371.  
  372. YY_DECL
  373.     {
  374.     register yy_state_type yy_current_state;
  375.     register char *yy_cp, *yy_bp;
  376.     register int yy_act;
  377.  
  378. %% user's declarations go here
  379.  
  380.     if ( yy_init )
  381.         {
  382. #ifdef YY_USER_INIT
  383.         YY_USER_INIT;
  384. #endif
  385.  
  386.         if ( ! yy_start )
  387.             yy_start = 1;    /* first start state */
  388.  
  389.         if ( ! yyin )
  390. %-
  391.             yyin = stdin;
  392. %+
  393.             yyin = &cin;
  394. %*
  395.  
  396.         if ( ! yyout )
  397. %-
  398.             yyout = stdout;
  399. %+
  400.             yyout = &cout;
  401. %*
  402.  
  403.         if ( yy_current_buffer )
  404.             yy_init_buffer( yy_current_buffer, yyin );
  405.         else
  406.             yy_current_buffer =
  407.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  408.  
  409.         yy_load_buffer_state();
  410.  
  411.         yy_init = 0;
  412.         }
  413.  
  414.     while ( 1 )        /* loops until end-of-file is reached */
  415.         {
  416. %% yymore()-related code goes here
  417.         yy_cp = yy_c_buf_p;
  418.  
  419.         /* Support of yytext. */
  420.         *yy_cp = yy_hold_char;
  421.  
  422.         /* yy_bp points to the position in yy_ch_buf of the start of
  423.          * the current run.
  424.          */
  425.         yy_bp = yy_cp;
  426.  
  427. %% code to set up and find next match goes here
  428.  
  429. yy_find_action:
  430. %% code to find the action number goes here
  431.  
  432.         YY_DO_BEFORE_ACTION;
  433.  
  434. %% code for yylineno update goes here, if -l option
  435.  
  436. do_action:    /* This label is used only to access EOF actions. */
  437.  
  438. %% debug code goes here
  439.  
  440.         switch ( yy_act )
  441.     { /* beginning of action switch */
  442. %% actions go here
  443.  
  444.     case YY_END_OF_BUFFER:
  445.         {
  446.         /* Amount of text matched not including the EOB char. */
  447.         int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
  448.  
  449.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  450.         *yy_cp = yy_hold_char;
  451.  
  452.         if ( yy_current_buffer->yy_input_file != yyin )
  453.             {
  454.             /* This can happen if we scan a file, yywrap() returns
  455.              * 1, and then later the user points yyin at a new
  456.              * file to resume scanning.  We have to assure
  457.              * consistency between yy_current_buffer and our
  458.              * globals.  Here is the right place to do so, because
  459.              * this is the first action (other than possibly a
  460.              * back-up) that will match for the new input file.
  461.              */
  462.             yy_current_buffer->yy_input_file = yyin;
  463.             yy_n_chars = yy_current_buffer->yy_n_chars;
  464.             }
  465.  
  466.         /* Note that here we test for yy_c_buf_p "<=" to the position
  467.          * of the first EOB in the buffer, since yy_c_buf_p will
  468.          * already have been incremented past the NUL character
  469.          * (since all states make transitions on EOB to the
  470.          * end-of-buffer state).  Contrast this with the test
  471.          * in input().
  472.          */
  473.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  474.             { /* This was really a NUL. */
  475.             yy_state_type yy_next_state;
  476.  
  477.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  478.  
  479.             yy_current_state = yy_get_previous_state();
  480.  
  481.             /* Okay, we're now positioned to make the NUL
  482.              * transition.  We couldn't have
  483.              * yy_get_previous_state() go ahead and do it
  484.              * for us because it doesn't know how to deal
  485.              * with the possibility of jamming (and we don't
  486.              * want to build jamming into it because then it
  487.              * will run more slowly).
  488.              */
  489.  
  490.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  491.  
  492.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  493.  
  494.             if ( yy_next_state )
  495.                 {
  496.                 /* Consume the NUL. */
  497.                 yy_cp = ++yy_c_buf_p;
  498.                 yy_current_state = yy_next_state;
  499.                 goto yy_match;
  500.                 }
  501.  
  502.             else
  503.                 {
  504. %% code to do back-up for compressed tables and set up yy_cp goes here
  505.                 goto yy_find_action;
  506.                 }
  507.             }
  508.  
  509.         else switch ( yy_get_next_buffer() )
  510.             {
  511.             case EOB_ACT_END_OF_FILE:
  512.                 {
  513.                 yy_did_buffer_switch_on_eof = 0;
  514.  
  515.                 if ( yywrap() )
  516.                     {
  517.                     /* Note: because we've taken care in
  518.                      * yy_get_next_buffer() to have set up
  519.                      * yytext, we can now set up
  520.                      * yy_c_buf_p so that if some total
  521.                      * hoser (like flex itself) wants to
  522.                      * call the scanner after we return the
  523.                      * YY_NULL, it'll still work - another
  524.                      * YY_NULL will get returned.
  525.                      */
  526.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  527.  
  528.                     yy_act = YY_STATE_EOF(YY_START);
  529.                     goto do_action;
  530.                     }
  531.  
  532.                 else
  533.                     {
  534.                     if ( ! yy_did_buffer_switch_on_eof )
  535.                         YY_NEW_FILE;
  536.                     }
  537.                 break;
  538.                 }
  539.  
  540.             case EOB_ACT_CONTINUE_SCAN:
  541.                 yy_c_buf_p =
  542.                     yytext_ptr + yy_amount_of_matched_text;
  543.  
  544.                 yy_current_state = yy_get_previous_state();
  545.  
  546.                 yy_cp = yy_c_buf_p;
  547.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  548.                 goto yy_match;
  549.  
  550.             case EOB_ACT_LAST_MATCH:
  551.                 yy_c_buf_p =
  552.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  553.  
  554.                 yy_current_state = yy_get_previous_state();
  555.  
  556.                 yy_cp = yy_c_buf_p;
  557.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  558.                 goto yy_find_action;
  559.             }
  560.         break;
  561.         }
  562.  
  563.     default:
  564.         YY_FATAL_ERROR(
  565.             "fatal flex scanner internal error--no action found" );
  566.     } /* end of action switch */
  567.         } /* end of scanning one token */
  568.     } /* end of yylex */
  569.  
  570. %+
  571. #ifdef YY_INTERACTIVE
  572. int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )
  573. #else
  574. int yyFlexLexer::LexerInput( char* buf, int max_size )
  575. #endif
  576.     {
  577.     if ( yyin->eof() || yyin->fail() )
  578.         return 0;
  579.  
  580. #ifdef YY_INTERACTIVE
  581.     yyin->get( buf[0] );
  582.  
  583.     if ( yyin->eof() )
  584.         return 0;
  585.  
  586.     if ( yyin->bad() )
  587.         return -1;
  588.  
  589.     return 1;
  590.  
  591. #else
  592.     (void) yyin->read( buf, max_size );
  593.  
  594.     if ( yyin->bad() )
  595.         return -1;
  596.     else
  597.         return yyin->gcount();
  598. #endif
  599.     }
  600.  
  601. void yyFlexLexer::LexerOutput( const char* buf, int size )
  602.     {
  603.     (void) yyout->write( buf, size );
  604.     }
  605. %*
  606.  
  607. /* yy_get_next_buffer - try to read in a new buffer
  608.  *
  609.  * Returns a code representing an action:
  610.  *    EOB_ACT_LAST_MATCH -
  611.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  612.  *    EOB_ACT_END_OF_FILE - end of file
  613.  */
  614.  
  615. %-
  616. static int yy_get_next_buffer()
  617. %+
  618. int yyFlexLexer::yy_get_next_buffer()
  619. %*
  620.     {
  621.     register char *dest = yy_current_buffer->yy_ch_buf;
  622.     register char *source = yytext_ptr - 1; /* copy prev. char, too */
  623.     register int number_to_move, i;
  624.     int ret_val;
  625.  
  626.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  627.         YY_FATAL_ERROR(
  628.         "fatal flex scanner internal error--end of buffer missed" );
  629.  
  630.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  631.         { /* Don't try to fill the buffer, so this is an EOF. */
  632.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  633.             {
  634.             /* We matched a singled characater, the EOB, so
  635.              * treat this as a final EOF.
  636.              */
  637.             return EOB_ACT_END_OF_FILE;
  638.             }
  639.  
  640.         else
  641.             {
  642.             /* We matched some text prior to the EOB, first
  643.              * process it.
  644.              */
  645.             return EOB_ACT_LAST_MATCH;
  646.             }
  647.         }
  648.  
  649.     /* Try to read more data. */
  650.  
  651.     /* First move last chars to start of buffer. */
  652.     number_to_move = yy_c_buf_p - yytext_ptr;
  653.  
  654.     for ( i = 0; i < number_to_move; ++i )
  655.         *(dest++) = *(source++);
  656.  
  657.     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  658.         /* don't do the read, it's not guaranteed to return an EOF,
  659.          * just force an EOF
  660.          */
  661.         yy_n_chars = 0;
  662.  
  663.     else
  664.         {
  665.         int num_to_read =
  666.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  667.  
  668.         while ( num_to_read <= 0 )
  669.             { /* Not enough room in the buffer - grow it. */
  670. #ifdef YY_USES_REJECT
  671.             YY_FATAL_ERROR(
  672. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  673. #else
  674.  
  675.             /* just a shorter name for the current buffer */
  676.             YY_BUFFER_STATE b = yy_current_buffer;
  677.  
  678.             int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
  679.  
  680.             b->yy_buf_size *= 2;
  681.             b->yy_ch_buf = (char *)
  682.                 yy_flex_realloc( (void *) b->yy_ch_buf,
  683.                          b->yy_buf_size );
  684.  
  685.             if ( ! b->yy_ch_buf )
  686.                 YY_FATAL_ERROR(
  687.                 "fatal error - scanner input buffer overflow" );
  688.  
  689.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  690.  
  691.             num_to_read = yy_current_buffer->yy_buf_size -
  692.                         number_to_move - 1;
  693. #endif
  694.             }
  695.  
  696.         if ( num_to_read > YY_READ_BUF_SIZE )
  697.             num_to_read = YY_READ_BUF_SIZE;
  698.  
  699.         /* Read in more data. */
  700.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  701.             yy_n_chars, num_to_read );
  702.         }
  703.  
  704.     if ( yy_n_chars == 0 )
  705.         {
  706.         if ( number_to_move - YY_MORE_ADJ == 1 )
  707.             {
  708.             ret_val = EOB_ACT_END_OF_FILE;
  709.             yyrestart( yyin );
  710.             }
  711.  
  712.         else
  713.             {
  714.             ret_val = EOB_ACT_LAST_MATCH;
  715.             yy_current_buffer->yy_eof_status = EOF_PENDING;
  716.             }
  717.         }
  718.  
  719.     else
  720.         ret_val = EOB_ACT_CONTINUE_SCAN;
  721.  
  722.     yy_n_chars += number_to_move;
  723.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  724.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  725.  
  726.     /* yytext begins at the second character in yy_ch_buf; the first
  727.      * character is the one which preceded it before reading in the latest
  728.      * buffer; it needs to be kept around in case it's a newline, so
  729.      * yy_get_previous_state() will have with '^' rules active.
  730.      */
  731.  
  732.     yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
  733.  
  734.     return ret_val;
  735.     }
  736.  
  737.  
  738. /* yy_get_previous_state - get the state just before the EOB char was reached */
  739.  
  740. %-
  741. static yy_state_type yy_get_previous_state()
  742. %+
  743. yy_state_type yyFlexLexer::yy_get_previous_state()
  744. %*
  745.     {
  746.     register yy_state_type yy_current_state;
  747.     register char *yy_cp;
  748.  
  749. %% code to get the start state into yy_current_state goes here
  750.  
  751.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  752.         {
  753. %% code to find the next state goes here
  754.         }
  755.  
  756.     return yy_current_state;
  757.     }
  758.  
  759.  
  760. /* yy_try_NUL_trans - try to make a transition on the NUL character
  761.  *
  762.  * synopsis
  763.  *    next_state = yy_try_NUL_trans( current_state );
  764.  */
  765.  
  766. %-
  767. #ifdef YY_USE_PROTOS
  768. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  769. #else
  770. static yy_state_type yy_try_NUL_trans( yy_current_state )
  771. yy_state_type yy_current_state;
  772. #endif
  773. %+
  774. yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
  775. %*
  776.     {
  777.     register int yy_is_jam;
  778. %% code to find the next state, and perhaps do backing up, goes here
  779.  
  780.     return yy_is_jam ? 0 : yy_current_state;
  781.     }
  782.  
  783.  
  784. %-
  785. #ifdef YY_USE_PROTOS
  786. static void yyunput( int c, register char *yy_bp )
  787. #else
  788. static void yyunput( c, yy_bp )
  789. int c;
  790. register char *yy_bp;
  791. #endif
  792. %+
  793. void yyFlexLexer::yyunput( int c, register char* yy_bp )
  794. %*
  795.     {
  796.     register char *yy_cp = yy_c_buf_p;
  797.  
  798.     /* undo effects of setting up yytext */
  799.     *yy_cp = yy_hold_char;
  800.  
  801.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  802.         { /* need to shift things up to make room */
  803.         /* +2 for EOB chars. */
  804.         register int number_to_move = yy_n_chars + 2;
  805.         register char *dest = &yy_current_buffer->yy_ch_buf[
  806.                     yy_current_buffer->yy_buf_size + 2];
  807.         register char *source =
  808.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  809.  
  810.         while ( source > yy_current_buffer->yy_ch_buf )
  811.             *--dest = *--source;
  812.  
  813.         yy_cp += dest - source;
  814.         yy_bp += dest - source;
  815.         yy_n_chars = yy_current_buffer->yy_buf_size;
  816.  
  817.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  818.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  819.         }
  820.  
  821.     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  822.         yy_cp[-2] = '\n';
  823.  
  824.     *--yy_cp = (char) c;
  825.  
  826. %% update yylineno here, if doing -l
  827.  
  828.     /* Note: the formal parameter *must* be called "yy_bp" for this
  829.      * macro to now work correctly.
  830.      */
  831.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  832.     }
  833.  
  834.  
  835. %-
  836. #ifdef __cplusplus
  837. static int yyinput()
  838. #else
  839. static int input()
  840. #endif
  841. %+
  842. int yyFlexLexer::yyinput()
  843. %*
  844.     {
  845.     int c;
  846.  
  847.     *yy_c_buf_p = yy_hold_char;
  848.  
  849.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  850.         {
  851.         /* yy_c_buf_p now points to the character we want to return.
  852.          * If this occurs *before* the EOB characters, then it's a
  853.          * valid NUL; if not, then we've hit the end of the buffer.
  854.          */
  855.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  856.             /* This was really a NUL. */
  857.             *yy_c_buf_p = '\0';
  858.  
  859.         else
  860.             { /* need more input */
  861.             yytext_ptr = yy_c_buf_p;
  862.             ++yy_c_buf_p;
  863.  
  864.             switch ( yy_get_next_buffer() )
  865.                 {
  866.                 case EOB_ACT_END_OF_FILE:
  867.                     {
  868.                     if ( yywrap() )
  869.                         {
  870.                         yy_c_buf_p =
  871.                         yytext_ptr + YY_MORE_ADJ;
  872.                         return EOF;
  873.                         }
  874.  
  875.                     YY_NEW_FILE;
  876. #ifdef __cplusplus
  877.                     return yyinput();
  878. #else
  879.                     return input();
  880. #endif
  881.                     }
  882.  
  883.                 case EOB_ACT_CONTINUE_SCAN:
  884.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  885.                     break;
  886.  
  887.                 case EOB_ACT_LAST_MATCH:
  888. #ifdef __cplusplus
  889.                     YY_FATAL_ERROR(
  890.                     "unexpected last match in yyinput()" );
  891. #else
  892.                     YY_FATAL_ERROR(
  893.                     "unexpected last match in input()" );
  894. #endif
  895.                 }
  896.             }
  897.         }
  898.  
  899.     c = *yy_c_buf_p;
  900.     *yy_c_buf_p = '\0';    /* preserve yytext */
  901.     yy_hold_char = *++yy_c_buf_p;
  902.  
  903.     return c;
  904.     }
  905.  
  906.  
  907. %-
  908. #ifdef YY_USE_PROTOS
  909. void yyrestart( FILE *input_file )
  910. #else
  911. void yyrestart( input_file )
  912. FILE *input_file;
  913. #endif
  914. %+
  915. void yyFlexLexer::yyrestart( istream* input_file )
  916. %*
  917.     {
  918.     if ( ! yy_current_buffer )
  919.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  920.  
  921.     yy_init_buffer( yy_current_buffer, input_file );
  922.     yy_load_buffer_state();
  923.     }
  924.  
  925.  
  926. %-
  927. #ifdef YY_USE_PROTOS
  928. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  929. #else
  930. void yy_switch_to_buffer( new_buffer )
  931. YY_BUFFER_STATE new_buffer;
  932. #endif
  933. %+
  934. void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  935. %*
  936.     {
  937.     if ( yy_current_buffer == new_buffer )
  938.         return;
  939.  
  940.     if ( yy_current_buffer )
  941.         {
  942.         /* Flush out information for old buffer. */
  943.         *yy_c_buf_p = yy_hold_char;
  944.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  945.         yy_current_buffer->yy_n_chars = yy_n_chars;
  946.         }
  947.  
  948.     yy_current_buffer = new_buffer;
  949.     yy_load_buffer_state();
  950.  
  951.     /* We don't actually know whether we did this switch during
  952.      * EOF (yywrap()) processing, but the only time this flag
  953.      * is looked at is after yywrap() is called, so it's safe
  954.      * to go ahead and always set it.
  955.      */
  956.     yy_did_buffer_switch_on_eof = 1;
  957.     }
  958.  
  959.  
  960. %-
  961. #ifdef YY_USE_PROTOS
  962. void yy_load_buffer_state( void )
  963. #else
  964. void yy_load_buffer_state()
  965. #endif
  966. %+
  967. void yyFlexLexer::yy_load_buffer_state()
  968. %*
  969.     {
  970.     yy_n_chars = yy_current_buffer->yy_n_chars;
  971.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  972.     yyin = yy_current_buffer->yy_input_file;
  973.     yy_hold_char = *yy_c_buf_p;
  974.     }
  975.  
  976.  
  977. %-
  978. #ifdef YY_USE_PROTOS
  979. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  980. #else
  981. YY_BUFFER_STATE yy_create_buffer( file, size )
  982. FILE *file;
  983. int size;
  984. #endif
  985. %+
  986. YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )
  987. %*
  988.     {
  989.     YY_BUFFER_STATE b;
  990.  
  991.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  992.  
  993.     if ( ! b )
  994.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  995.  
  996.     b->yy_buf_size = size;
  997.  
  998.     /* yy_ch_buf has to be 2 characters longer than the size given because
  999.      * we need to put in 2 end-of-buffer characters.
  1000.      */
  1001.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1002.  
  1003.     if ( ! b->yy_ch_buf )
  1004.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1005.  
  1006.     yy_init_buffer( b, file );
  1007.  
  1008.     return b;
  1009.     }
  1010.  
  1011.  
  1012. %-
  1013. #ifdef YY_USE_PROTOS
  1014. void yy_delete_buffer( YY_BUFFER_STATE b )
  1015. #else
  1016. void yy_delete_buffer( b )
  1017. YY_BUFFER_STATE b;
  1018. #endif
  1019. %+
  1020. void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
  1021. %*
  1022.     {
  1023.     if ( b == yy_current_buffer )
  1024.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1025.  
  1026.     yy_flex_free( (void *) b->yy_ch_buf );
  1027.     yy_flex_free( (void *) b );
  1028.     }
  1029.  
  1030.  
  1031. %-
  1032. #ifdef YY_USE_PROTOS
  1033. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1034. #else
  1035. void yy_init_buffer( b, file )
  1036. YY_BUFFER_STATE b;
  1037. FILE *file;
  1038. #endif
  1039. %+
  1040. void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )
  1041. %*
  1042.     {
  1043.     b->yy_input_file = file;
  1044.  
  1045.     /* We put in the '\n' and start reading from [1] so that an
  1046.      * initial match-at-newline will be true.
  1047.      */
  1048.  
  1049.     b->yy_ch_buf[0] = '\n';
  1050.     b->yy_n_chars = 1;
  1051.  
  1052.     /* We always need two end-of-buffer characters.  The first causes
  1053.      * a transition to the end-of-buffer state.  The second causes
  1054.      * a jam in that state.
  1055.      */
  1056.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1057.     b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1058.  
  1059.     b->yy_buf_pos = &b->yy_ch_buf[1];
  1060.  
  1061. %-
  1062.     b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
  1063. %+
  1064.     b->yy_is_interactive = 0;
  1065. %*
  1066.  
  1067.     b->yy_fill_buffer = 1;
  1068.  
  1069.     b->yy_eof_status = EOF_NOT_SEEN;
  1070.     }
  1071.  
  1072.  
  1073. %-
  1074. #ifdef YY_USE_PROTOS
  1075. static void yy_push_state( int new_state )
  1076. #else
  1077. static void yy_push_state( new_state )
  1078. int new_state;
  1079. #endif
  1080. %+
  1081. void yyFlexLexer::yy_push_state( int new_state )
  1082. %*
  1083.     {
  1084.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1085.         {
  1086.         int new_size;
  1087.  
  1088.         yy_start_stack_depth += YY_START_STACK_INCR;
  1089.         new_size = yy_start_stack_depth * sizeof( int );
  1090.  
  1091.         if ( ! yy_start_stack )
  1092.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1093.  
  1094.         else
  1095.             yy_start_stack = (int *) yy_flex_realloc(
  1096.                     (void *) yy_start_stack, new_size );
  1097.  
  1098.         if ( ! yy_start_stack )
  1099.             YY_FATAL_ERROR(
  1100.             "out of memory expanding start-condition stack" );
  1101.         }
  1102.  
  1103.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1104.  
  1105.     BEGIN(new_state);
  1106.     }
  1107.  
  1108.  
  1109. %-
  1110. static void yy_pop_state()
  1111. %+
  1112. void yyFlexLexer::yy_pop_state()
  1113. %*
  1114.     {
  1115.     if ( --yy_start_stack_ptr < 0 )
  1116.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1117.  
  1118.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1119.     }
  1120.  
  1121.  
  1122. %-
  1123. static int yy_top_state()
  1124. %+
  1125. int yyFlexLexer::yy_top_state()
  1126. %*
  1127.     {
  1128.     return yy_start_stack[yy_start_stack_ptr - 1];
  1129.     }
  1130.  
  1131.  
  1132. %-
  1133. #ifdef YY_USE_PROTOS
  1134. static void yy_fatal_error( const char msg[] )
  1135. #else
  1136. static void yy_fatal_error( msg )
  1137. char msg[];
  1138. #endif
  1139.     {
  1140.     (void) fprintf( stderr, "%s\n", msg );
  1141.     exit( 1 );
  1142.     }
  1143.  
  1144. %+
  1145.  
  1146. void yyFlexLexer::LexerError( const char msg[] )
  1147.     {
  1148.     cerr << msg << '\n';
  1149.     exit( 1 );
  1150.     }
  1151. %*
  1152.  
  1153.  
  1154. /* Redefine yyless() so it works in section 3 code. */
  1155.  
  1156. #undef yyless
  1157. #define yyless(n) \
  1158.     do \
  1159.         { \
  1160.         /* Undo effects of setting up yytext. */ \
  1161.         yytext[yyleng] = yy_hold_char; \
  1162.         yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  1163.         yy_hold_char = *yy_c_buf_p; \
  1164.         *yy_c_buf_p = '\0'; \
  1165.         yyleng = n; \
  1166.         } \
  1167.     while ( 0 )
  1168.  
  1169.  
  1170. /* Internal utility routines. */
  1171.  
  1172. #ifndef yytext_ptr
  1173. #ifdef YY_USE_PROTOS
  1174. static void yy_flex_strcpy( char *s1, const char *s2 )
  1175. #else
  1176. static void yy_flex_strcpy( s1, s2 )
  1177. char *s1;
  1178. const char *s2;
  1179. #endif
  1180.     {
  1181.     while ( (*(s1++) = *(s2++)) )
  1182.         ;
  1183.     }
  1184. #endif
  1185.  
  1186.  
  1187. #ifdef YY_USE_PROTOS
  1188. static void *yy_flex_alloc( unsigned int size )
  1189. #else
  1190. static void *yy_flex_alloc( size )
  1191. unsigned int size;
  1192. #endif
  1193.     {
  1194.     return (void *) malloc( size );
  1195.     }
  1196.  
  1197. #ifdef YY_USE_PROTOS
  1198. static void *yy_flex_realloc( void *ptr, unsigned int size )
  1199. #else
  1200. static void *yy_flex_realloc( ptr, size )
  1201. void *ptr;
  1202. unsigned int size;
  1203. #endif
  1204.     {
  1205.     return (void *) realloc( ptr, size );
  1206.     }
  1207.  
  1208. #ifdef YY_USE_PROTOS
  1209. static void yy_flex_free( void *ptr )
  1210. #else
  1211. static void yy_flex_free( ptr )
  1212. void *ptr;
  1213. #endif
  1214.     {
  1215.     free( ptr );
  1216.     }
  1217.