home *** CD-ROM | disk | FTP | other *** search
/ Frostbyte's 1980s DOS Shareware Collection / floppyshareware.zip / floppyshareware / FORTH / FLEX.ARC / FLEXFAST.SRC < prev    next >
Text File  |  1988-10-09  |  10KB  |  407 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. #define FLEX_FAST_SKEL
  4.  
  5. #indef MSDOS
  6. # include "fastskeldef.h"
  7. #else
  8. # include "fastskel.h"
  9. #endif
  10.  
  11. %% section 1 code and the definition of YY_TRANS_OFFSET_TYPE, if needed, go here
  12.  
  13. #ifndef FLEX_FULL_TABLE
  14.     /* struct for yy_transition */
  15.     struct yy_trans_info
  16.     {
  17.     /* v is a verify for a transition. */
  18.     short v;
  19.  
  20.     /* In cases where its sister v *is* a "yes, there is a transition",
  21.      * n is* the offset (in records) to the next state.  In most cases
  22.      * where there is no transition, the value of n is irrelevant.    If n
  23.      * is the -1th    record of a state, though, then n is the action
  24.      * number for that state
  25.      */
  26.     YY_TRANS_OFFSET_TYPE n;
  27.     };
  28. #endif
  29.  
  30. %% data tables for DFA go here
  31.  
  32. /* these declarations have to come after the section 1 code or lint gets
  33.  * confused about whether the variables are used
  34.  */
  35. FILE *yyin = stdin, *yyout = stdout;
  36.  
  37. /* these variables are all declared out here so that section 3 code can
  38.  * manipulate them
  39.  */
  40. static char *yy_c_buf_p;    /* points to current character in buffer */
  41. static char *yy_b_buf_p;    /* points to start of current scan */
  42. static int yy_init = 1; /* whether we need to initialize */
  43. static int yy_start;    /* start state number */
  44.  
  45. /* true when we've seen an EOF for the current input file */
  46. static int yy_eof_has_been_seen;
  47.  
  48. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  49.  
  50. /* yy_ch_buf has to be 2 characters longer than YY_BUF_SIZE because we need
  51.  * to put in 2 end-of-buffer characters (this is explained where it is
  52.  * done) at the end of yy_ch_buf
  53.  */
  54. static char yy_ch_buf[YY_BUF_SIZE + 2];
  55.  
  56. /* yy_hold_char holds the character lost when yytext is formed */
  57. static char yy_hold_char;
  58. char *yytext;
  59. static int yyleng;    /* length of yytext */
  60.  
  61. static YY_CS_TYPE yy_last_accepting_state;
  62. static char *yy_last_accepting_cpos;
  63.  
  64. static YY_CS_TYPE yy_get_previous_state();
  65. static int yy_get_next_buffer();
  66.  
  67. #define FLEX_USES_BACKTRACKING
  68.  
  69. #ifdef FLEX_USES_BACKTRACKING
  70. #    ifdef FLEX_FULL_TABLE
  71. #    define YY_BACKTRACKING_ACTION \
  72.         if ( l[yy_current_state] ) \
  73.             { \
  74.             yy_last_accepting_state = yy_current_state; \
  75.             yy_last_accepting_cpos = yy_c_buf_p; \
  76.             }
  77. #    else
  78. #    define YY_BACKTRACKING_ACTION \
  79.         if ( yy_current_state[-1].n ) \
  80.             { \
  81.             yy_last_accepting_state = yy_current_state; \
  82.             yy_last_accepting_cpos = yy_c_buf_p; \
  83.             }
  84. #    endif
  85. #else
  86. #    define YY_BACKTRACKING_ACTION
  87. #endif
  88.  
  89. YY_DECL
  90.     {
  91.     register YY_CS_TYPE yy_current_state;
  92.     register int yy_c;
  93.     register struct yy_trans_info *yy_trans_info;
  94.     register int yy_act;
  95.  
  96. %% user's declarations go here
  97.  
  98.     if ( yy_init )
  99.     {
  100.     yy_start = 1;    /* first start state */
  101.  
  102. new_file:
  103.     /* this is where we enter upon encountering and end-of-file and
  104.      * yywrap() indicating that we should continue processing
  105.      */
  106.  
  107.     /* we put in the '\n' and start reading from [1] so that an
  108.      * initial match-at-newline will be true.
  109.      */
  110.  
  111.     yy_ch_buf[0] = '\n';
  112.     yy_n_chars = 1;
  113.  
  114.     /* we always need two end-of-buffer characters.  The first causes
  115.      * a transition to the end-of-buffer state.  The second causes
  116.      * a jam in that state.
  117.      */
  118.     yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  119.     yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  120.  
  121.     yy_eof_has_been_seen = 0;
  122.  
  123.     YY_FAST_INIT;
  124.     yy_init = 0;
  125.     }
  126.  
  127.     while ( 1 )     /* loops until end-of-file is reached */
  128.     {
  129.     /* support of yytext and yyleng */
  130.     YY_DO_BEFORE_SCAN;
  131.  
  132.     /* yy_b_buf_p points to the position in yy_ch_buf of the start of the
  133.      * current run.
  134.      */
  135.     yy_b_buf_p = yy_c_buf_p;
  136.  
  137.     YY_FIND_START_STATE( yy_current_state );
  138.  
  139.     YY_FIND_NEXT_MATCH;
  140.  
  141.     YY_DO_BEFORE_ACTION;
  142.  
  143. /* we need this label to process the very last action (right before the end of
  144.  * the file)
  145.  */
  146. do_action:
  147.     YY_FIND_ACTION( yy_act );
  148.  
  149. #ifdef FLEX_DEBUG
  150.     fprintf( stderr, "--accepting rule #%d\n", yy_act );
  151. #endif
  152.     switch ( yy_act )
  153.         {
  154. %% actions go here
  155.  
  156.         case YY_BACK_TRACK:
  157.         YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */
  158.         yy_c_buf_p = yy_last_accepting_cpos + 1;
  159.         yy_current_state = yy_last_accepting_state;
  160.         YY_DO_BEFORE_ACTION;
  161.         goto do_action;
  162.  
  163.         case YY_NEW_FILE:
  164.         break; /* begin reading from new file */
  165.  
  166.         case YY_DO_DEFAULT:
  167.         /* we have to eat up one character and recompute yytext and
  168.          * yyleng
  169.          */
  170.         YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */
  171.         ++yy_c_buf_p;
  172.         YY_DO_BEFORE_ACTION;
  173.         YY_DEFAULT_ACTION;
  174.         break;
  175.  
  176.         case YY_END_OF_BUFFER:
  177.         YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */
  178.  
  179.         switch ( yy_get_next_buffer() )
  180.             {
  181.             case EOB_ACT_END_OF_FILE:
  182.             {
  183.             if ( yywrap() )
  184.                 {
  185.                 /* note: because we've taken care in
  186.                  * yy_get_next_buffer() to have set up yy_b_buf_p,
  187.                  * we can now set up yy_c_buf_p so that if some
  188.                  * total hoser (like flex itself) wants
  189.                  * to call the scanner after we return the
  190.                  * YY_NULL, it'll still work - another YY_NULL
  191.                  * will get returned.
  192.                  */
  193.                 yy_c_buf_p = yy_b_buf_p;
  194.                 return ( YY_NULL );
  195.                 }
  196.  
  197.             else
  198.                 goto new_file;
  199.             }
  200.             break;
  201.  
  202.             case EOB_ACT_RESTART_SCAN:
  203.             yy_c_buf_p = yy_b_buf_p;
  204.  
  205.             YY_DO_BEFORE_RESTART;
  206.             break;
  207.  
  208.             case EOB_ACT_LAST_MATCH:
  209.             yy_c_buf_p = &yy_ch_buf[yy_n_chars];
  210.  
  211.             yy_current_state = yy_get_previous_state();
  212.  
  213.             YY_DO_BEFORE_ACTION;
  214.  
  215.             goto do_action;
  216.             }
  217.         break;
  218.  
  219.         default:
  220.         printf( "action # %d\n", yy_act );
  221.         YY_FATAL_ERROR( "fatal flex scanner internal error" );
  222.         }
  223.     }
  224.     }
  225.  
  226.  
  227. /* yy_get_next_buffer - try to read in new buffer
  228.  *
  229.  * synopsis
  230.  *     int yy_get_next_buffer();
  231.  *
  232.  * returns a code representing an action
  233.  *     EOB_ACT_LAST_MATCH -
  234.  *     EOB_ACT_RESTART_SCAN - restart the scanner
  235.  *     EOB_ACT_END_OF_FILE - end of file
  236.  */
  237.  
  238. static int yy_get_next_buffer()
  239.  
  240.     {
  241.     if ( yy_c_buf_p != &yy_ch_buf[yy_n_chars + 1] )
  242.     {
  243.     YY_FATAL_ERROR( "NULL in input" );
  244.     /*NOTREACHED*/
  245.     }
  246.  
  247.     else
  248.     { /* try to read more data */
  249.     register char *dest = yy_ch_buf;
  250.     register char *source = yy_b_buf_p - 1; /* copy prev. char, too */
  251.     register int number_to_move, i;
  252.     int ret_val;
  253.  
  254.     /* first move last chars to start of buffer */
  255.     number_to_move = yy_c_buf_p - yy_b_buf_p;
  256.  
  257.     for ( i = 0; i < number_to_move; ++i )
  258.         *(dest++) = *(source++);
  259.  
  260.     if ( yy_eof_has_been_seen )
  261.         /* don't do the read, it's not guaranteed to return an EOF,
  262.          * just force an EOF
  263.          */
  264.         yy_n_chars = 0;
  265.  
  266.     else
  267.         /* read in more data */
  268.         YY_INPUT( (&yy_ch_buf[number_to_move]), yy_n_chars,
  269.               YY_BUF_SIZE - number_to_move - 1 );
  270.  
  271.     if ( yy_n_chars == 0 )
  272.         {
  273.         if ( number_to_move == 1 )
  274.         ret_val = EOB_ACT_END_OF_FILE;
  275.         else
  276.         ret_val = EOB_ACT_LAST_MATCH;
  277.  
  278.         yy_eof_has_been_seen = 1;
  279.         }
  280.  
  281.     else
  282.         ret_val = EOB_ACT_RESTART_SCAN;
  283.  
  284.     yy_n_chars += number_to_move;
  285.     yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  286.     yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  287.  
  288.     /* yy_b_buf_p begins at the second character in
  289.      * yy_ch_buf; the first character is the one which
  290.      * preceded it before reading in the latest buffer;
  291.      * it needs to be kept around in case it's a
  292.      * newline, so yy_get_previous_state() will have
  293.      * with '^' rules active
  294.      */
  295.  
  296.     yy_b_buf_p = &yy_ch_buf[1];
  297.  
  298.     return ( ret_val );
  299.     }
  300.     }
  301.  
  302.  
  303. /* yy_get_previous_state - get the state just before the eob char was reached
  304.  *
  305.  * synopsis
  306.  *     YY_CS_TYPE yy_get_previous_state();
  307.  */
  308.  
  309. static YY_CS_TYPE yy_get_previous_state()
  310.  
  311.     {
  312.     register YY_CS_TYPE yy_cur_state;
  313.     register char *yy_temp_char_ptr;
  314.  
  315.     YY_FIND_START_STATE( yy_cur_state );
  316.  
  317.     for ( yy_temp_char_ptr = yy_b_buf_p; yy_temp_char_ptr < yy_c_buf_p; )
  318.     YY_GET_NEXT_STATE;
  319.  
  320.     return ( yy_cur_state );
  321.     }
  322.  
  323.  
  324. static unput( c )
  325. int c;
  326.  
  327.     {
  328.     YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  329.  
  330.     if ( yy_c_buf_p < yy_ch_buf + 2 )
  331.     { /* need to shift things up to make room */
  332.     register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
  333.     register char *dest = &yy_ch_buf[YY_BUF_SIZE + 2];
  334.     register char *source = &yy_ch_buf[number_to_move];
  335.  
  336.     while ( source > yy_ch_buf )
  337.         *--dest = *--source;
  338.  
  339.     yy_c_buf_p += dest - source;
  340.     yy_b_buf_p += dest - source;
  341.  
  342.     if ( yy_c_buf_p < yy_ch_buf + 2 )
  343.         YY_FATAL_ERROR( "flex scanner push-back overflow" );
  344.     }
  345.  
  346.     if ( yy_c_buf_p > yy_b_buf_p && yy_c_buf_p[-1] == '\n' )
  347.     yy_c_buf_p[-2] = '\n';
  348.  
  349.     *--yy_c_buf_p = c;
  350.  
  351.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  352.     }
  353.  
  354.  
  355. static int input()
  356.  
  357.     {
  358.     int c;
  359.  
  360.     YY_DO_BEFORE_SCAN;
  361.  
  362.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  363.     { /* need more input */
  364.     yy_b_buf_p = yy_c_buf_p;
  365.     ++yy_c_buf_p;
  366.  
  367.     switch ( yy_get_next_buffer() )
  368.         {
  369.         /* this code, unfortunately, is somewhat redundant with
  370.          * that above
  371.          */
  372.         case EOB_ACT_END_OF_FILE:
  373.         {
  374.         if ( yywrap() )
  375.             {
  376.             yy_c_buf_p = yy_b_buf_p;
  377.             return ( EOF );
  378.             }
  379.  
  380.         yy_ch_buf[0] = '\n';
  381.         yy_n_chars = 1;
  382.         yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  383.         yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  384.         yy_eof_has_been_seen = 0;
  385.  
  386.         YY_FAST_INIT;
  387.  
  388.         return ( input() );
  389.         }
  390.         break;
  391.  
  392.         case EOB_ACT_RESTART_SCAN:
  393.         yy_c_buf_p = yy_b_buf_p;
  394.         break;
  395.  
  396.         case EOB_ACT_LAST_MATCH:
  397.         YY_FATAL_ERROR( "unexpected last match in input()" );
  398.         }
  399.     }
  400.  
  401.     c = *yy_c_buf_p++;
  402.  
  403.     YY_DO_BEFORE_RESTART;
  404.  
  405.     return ( c );
  406.     }
  407.