home *** CD-ROM | disk | FTP | other *** search
/ Frostbyte's 1980s DOS Shareware Collection / floppyshareware.zip / floppyshareware / FORTH / FLEX.ARC / FLEXSKEL.SRC < prev    next >
Text File  |  1988-10-09  |  7KB  |  340 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. #ifndef MSDOS
  4. # include "flexskeldef.h"
  5. #else
  6. # include "flexsdef.h"
  7. #endif
  8.  
  9. %% section 1 code and data tables for DFA go here
  10.  
  11. /* these declarations have to come after the section 1 code or lint gets
  12.  * confused about whether the variables are used
  13.  */
  14. FILE *yyin = stdin, *yyout = stdout;
  15.  
  16. /* these variables are all declared out here so that section 3 code can
  17.  * manipulate them
  18.  */
  19. static int yy_start, yy_b_buf_p, yy_c_buf_p, yy_e_buf_p;
  20. static int yy_saw_eof, yy_init = 1;
  21.  
  22. /* yy_ch_buf has to be 1 character longer than YY_BUF_SIZE, since when
  23.  * setting up yytext we can try to put a '\0' just past the end of the
  24.  * matched text
  25.  */
  26. static char yy_ch_buf[YY_BUF_SIZE + 1];
  27. static int yy_st_buf[YY_BUF_SIZE];
  28. static char yy_hold_char;
  29. char *yytext;
  30. static int yyleng;
  31.  
  32. YY_DECL
  33.     {
  34.     int yy_n_chars, yy_lp, yy_iii, yy_buf_pos, yy_act;
  35.  
  36. %% user's declarations go here
  37.  
  38.     if ( yy_init )
  39.     {
  40.     YY_INIT;
  41.     yy_start = 1;
  42.     yy_init = 0;
  43.     }
  44.  
  45.     goto get_next_token;
  46.  
  47. do_action:
  48.     for ( ; ; )
  49.     {
  50.     YY_DO_BEFORE_ACTION
  51.  
  52. #ifdef FLEX_DEBUG
  53.     fprintf( stderr, "--accepting rule #%d\n", yy_act );
  54. #endif
  55.     switch ( yy_act )
  56.         {
  57. %% actions go here
  58.  
  59. case YY_NEW_FILE:
  60. break; /* begin reading from new file */
  61.  
  62. case YY_DO_DEFAULT:
  63. YY_DEFAULT_ACTION;
  64. break;
  65.  
  66. case YY_END_TOK:
  67. return ( YY_END_TOK );
  68.  
  69. default:
  70. YY_FATAL_ERROR( "fatal flex scanner internal error" );
  71.         }
  72.  
  73. get_next_token:
  74.     {
  75.     register int yy_curst;
  76.     register char yy_sym;
  77.  
  78.     YY_DO_BEFORE_SCAN
  79.  
  80.     /* set up to begin running DFA */
  81.  
  82.     yy_curst = yy_start;
  83.  
  84.     if ( yy_ch_buf[yy_c_buf_p] == '\n' )
  85.         ++yy_curst;
  86.  
  87.     /* yy_b_buf_p points to the position in yy_ch_buf
  88.      * of the start of the current run.
  89.      */
  90.  
  91.     yy_b_buf_p = yy_c_buf_p + 1;
  92.  
  93.     do /* until the machine jams */
  94.         {
  95.         if ( yy_c_buf_p == yy_e_buf_p )
  96.         { /* need more input */
  97.         if ( yy_e_buf_p >= YY_BUF_LIM )
  98.             { /* not enough room to do another read */
  99.             /* see if we can make some room for more chars */
  100.  
  101.             yy_n_chars = yy_e_buf_p - yy_b_buf_p;
  102.  
  103.             if ( yy_n_chars >= 0 )
  104.             /* shift down buffer to make room */
  105.             for ( yy_iii = 0; yy_iii <= yy_n_chars; ++yy_iii )
  106.                 {
  107.                 yy_buf_pos = yy_b_buf_p + yy_iii;
  108.                 yy_ch_buf[yy_iii] = yy_ch_buf[yy_buf_pos];
  109.                 yy_st_buf[yy_iii] = yy_st_buf[yy_buf_pos];
  110.                 }
  111.  
  112.             yy_b_buf_p = 0;
  113.             yy_e_buf_p = yy_n_chars;
  114.  
  115.             if ( yy_e_buf_p >= YY_BUF_LIM )
  116.             YY_FATAL_ERROR( "flex input buffer overflowed" );
  117.  
  118.             yy_c_buf_p = yy_e_buf_p;
  119.             }
  120.  
  121.         else if ( yy_saw_eof )
  122.             {
  123. saweof:         if ( yy_b_buf_p > yy_e_buf_p )
  124.             {
  125.             if ( yywrap() )
  126.                 {
  127.                 yy_act = YY_END_TOK;
  128.                 goto do_action;
  129.                 }
  130.  
  131.             else
  132.                 {
  133.                 YY_INIT;
  134.                 yy_act = YY_NEW_FILE;
  135.                 goto do_action;
  136.                 }
  137.             }
  138.  
  139.             else /* do a jam to eat up more input */
  140.             {
  141. #ifndef FLEX_INTERACTIVE_SCANNER
  142.             /* we're going to decrement yy_c_buf_p upon doing
  143.              * the jam.  In this case, that's wrong, since
  144.              * it points to the last non-jam character.  So
  145.              * we increment it now to counter the decrement.
  146.              */
  147.             ++yy_c_buf_p;
  148. #endif
  149.             break;
  150.             }
  151.             }
  152.  
  153.         YY_INPUT( (yy_ch_buf + yy_c_buf_p + 1), yy_n_chars,
  154.               YY_MAX_LINE );
  155.  
  156.         if ( yy_n_chars == YY_NULL )
  157.             {
  158.             if ( yy_saw_eof )
  159.     YY_FATAL_ERROR( "flex scanner saw EOF twice - shouldn't happen" );
  160.             yy_saw_eof = 1;
  161.             goto saweof;
  162.             }
  163.  
  164.         yy_e_buf_p += yy_n_chars;
  165.         }
  166.  
  167.         ++yy_c_buf_p;
  168.  
  169. #ifdef FLEX_USE_ECS
  170.         yy_sym = e[yy_ch_buf[yy_c_buf_p]];
  171. #else
  172.         yy_sym = yy_ch_buf[yy_c_buf_p];
  173. #endif
  174.  
  175. #ifdef FLEX_FULL_TABLE
  176.         yy_curst = n[yy_curst][yy_sym];
  177.  
  178. #else /* get next state from compressed table */
  179.  
  180.         while ( c[b[yy_curst] + yy_sym] != yy_curst )
  181.         {
  182.         yy_curst = d[yy_curst];
  183.  
  184. #ifdef FLEX_USE_MECS
  185.         /* we've arrange it so that templates are never chained
  186.          * to one another.  This means we can afford make a
  187.          * very simple test to see if we need to convert to
  188.          * yy_sym's meta-equivalence class without worrying
  189.          * about erroneously looking up the meta-equivalence
  190.          * class twice
  191.          */
  192.  
  193.         if ( yy_curst >= YY_TEMPLATE )
  194.             yy_sym = m[yy_sym];
  195. #endif
  196.         }
  197.  
  198.         yy_curst = n[b[yy_curst] + yy_sym];
  199.  
  200. #endif
  201.  
  202.         yy_st_buf[yy_c_buf_p] = yy_curst;
  203.  
  204.         }
  205. #ifdef FLEX_INTERACTIVE_SCANNER
  206.     while ( b[yy_curst] != YY_JAM_BASE );
  207. #else
  208.     while ( yy_curst != YY_JAM );
  209.     --yy_c_buf_p; /* put back character we jammed on */
  210.  
  211. #endif
  212.  
  213.     if ( yy_c_buf_p >= yy_b_buf_p )
  214.         { /* we matched some text */
  215.         yy_curst = yy_st_buf[yy_c_buf_p];
  216.         yy_lp = l[yy_curst];
  217.  
  218. #ifdef FLEX_REJECT_ENABLED
  219. find_rule: /* we branch to this label when doing a REJECT */
  220. #endif
  221.  
  222.         for ( ; ; ) /* until we find what rule we matched */
  223.         {
  224. #ifdef FLEX_REJECT_ENABLED
  225.         if ( yy_lp && yy_lp < l[yy_curst + 1] )
  226.             {
  227.             yy_act = a[yy_lp];
  228.             goto do_action; /* "continue 2" */
  229.             }
  230. #else
  231.         if ( yy_lp )
  232.             {
  233.             yy_act = yy_lp;
  234.             goto do_action; /* "continue 2" */
  235.             }
  236. #endif
  237.  
  238.         if ( --yy_c_buf_p < yy_b_buf_p )
  239.             break;
  240.  
  241.         yy_curst = yy_st_buf[yy_c_buf_p];
  242.         yy_lp = l[yy_curst];
  243.         }
  244.         }
  245.  
  246.     /* if we got this far, then we didn't find any accepting
  247.      * states
  248.      */
  249.  
  250.     /* so that the default applies to the first char read */
  251.     ++yy_c_buf_p;
  252.  
  253.     yy_act = YY_DO_DEFAULT;
  254.     }
  255.     }
  256.  
  257.     /*NOTREACHED*/
  258.     }
  259.  
  260.  
  261. static int unput( c )
  262. char c;
  263.  
  264.     {
  265.     YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  266.  
  267.     if ( yy_c_buf_p == 0 )
  268.     {
  269.     register int i;
  270.     register int yy_buf_pos = YY_BUF_MAX;
  271.  
  272.     for ( i = yy_e_buf_p; i >= yy_c_buf_p; --i )
  273.         {
  274.         yy_ch_buf[yy_buf_pos] = yy_ch_buf[i];
  275.         yy_st_buf[yy_buf_pos] = yy_st_buf[i];
  276.         --yy_buf_pos;
  277.         }
  278.  
  279.     yy_c_buf_p = YY_BUF_MAX - yy_e_buf_p;
  280.     yy_e_buf_p = YY_BUF_MAX;
  281.     }
  282.  
  283.     if ( yy_c_buf_p <= 0 )
  284.     YY_FATAL_ERROR( "flex scanner push-back overflow" );
  285.  
  286.     if ( yy_c_buf_p >= yy_b_buf_p && yy_ch_buf[yy_c_buf_p] == '\n' )
  287.     yy_ch_buf[yy_c_buf_p - 1] = '\n';
  288.  
  289.     yy_ch_buf[yy_c_buf_p--] = c;
  290.  
  291.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  292.     }
  293.  
  294.  
  295. static int input()
  296.  
  297.     {
  298.     int c;
  299.  
  300.     YY_DO_BEFORE_SCAN
  301.  
  302.     if ( yy_c_buf_p == yy_e_buf_p )
  303.     { /* need more input */
  304.     int yy_n_chars;
  305.  
  306.     /* we can throw away the entire current buffer */
  307.     if ( yy_saw_eof )
  308.         {
  309.         if ( yywrap() )
  310.         return ( EOF );
  311.  
  312.         YY_INIT;
  313.         }
  314.  
  315.     yy_b_buf_p = 0;
  316.     YY_INPUT( yy_ch_buf, yy_n_chars, YY_MAX_LINE );
  317.  
  318.     if ( yy_n_chars == YY_NULL )
  319.         {
  320.         yy_saw_eof = 1;
  321.  
  322.         if ( yywrap() )
  323.         return ( EOF );
  324.  
  325.         YY_INIT;
  326.  
  327.         return ( input() );
  328.         }
  329.  
  330.     yy_c_buf_p = -1;
  331.     yy_e_buf_p = yy_n_chars - 1;
  332.     }
  333.  
  334.     c = yy_ch_buf[++yy_c_buf_p];
  335.  
  336.     YY_DO_BEFORE_ACTION;
  337.  
  338.     return ( c );
  339.     }
  340.