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