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