/* A lexical scanner generated by flex */

#define FLEX_FAST_SKEL

#include "s:fastskeldef.h"

%% section 1 code and the definition of YY_TRANS_OFFSET_TYPE, if needed, go here

#ifndef FLEX_FULL_TABLE
    /* struct for yy_transition */
    struct yy_trans_info
        {
        /* v is a verify for a transition. */
        short v;

        /* In cases where its sister v *is* a "yes, there is a transition",
         * n is* the offset (in records) to the next state.  In most cases
         * where there is no transition, the value of n is irrelevant.  If n
         * is the -1th  record of a state, though, then n is the action
         * number for that state
         */
        YY_TRANS_OFFSET_TYPE n;
        };
#endif

%% data tables for DFA go here

/* these declarations have to come after the section 1 code or lint gets
 * confused about whether the variables are used
 */
FILE *yyin = stdin, *yyout = stdout;

/* these variables are all declared out here so that section 3 code can
 * manipulate them
 */
static char *yy_c_buf_p;        /* points to current character in buffer */
static char *yy_b_buf_p;        /* points to start of current scan */
static int yy_init = 1; /* whether we need to initialize */
static int yy_start;    /* start state number */

/* true when we've seen an EOF for the current input file */
static int yy_eof_has_been_seen;

static int yy_n_chars;          /* number of characters read into yy_ch_buf */

/* yy_ch_buf has to be 2 characters longer than YY_BUF_SIZE because we need
 * to put in 2 end-of-buffer characters (this is explained where it is
 * done) at the end of yy_ch_buf
 */
static char yy_ch_buf[YY_BUF_SIZE + 2];

/* yy_hold_char holds the character lost when yytext is formed */
static char yy_hold_char;
char *yytext;
static int yyleng;      /* length of yytext */

static YY_CS_TYPE yy_last_accepting_state;
static char *yy_last_accepting_cpos;

static YY_CS_TYPE yy_get_previous_state();
static int yy_get_next_buffer();

#define FLEX_USES_BACKTRACKING

#ifdef FLEX_USES_BACKTRACKING
#    ifdef FLEX_FULL_TABLE
#       define YY_BACKTRACKING_ACTION \
                if ( l[yy_current_state] ) \
                        { \
                        yy_last_accepting_state = yy_current_state; \
                        yy_last_accepting_cpos = yy_c_buf_p; \
                        }
#    else
#       define YY_BACKTRACKING_ACTION \
                if ( yy_current_state[-1].n ) \
                        { \
                        yy_last_accepting_state = yy_current_state; \
                        yy_last_accepting_cpos = yy_c_buf_p; \
                        }
#    endif
#else
#    define YY_BACKTRACKING_ACTION
#endif

YY_DECL
    {
    register YY_CS_TYPE yy_current_state;
    register int yy_c;
    register struct yy_trans_info *yy_trans_info;
    register int yy_act;

%% user's declarations go here

    if ( yy_init )
        {
        yy_start = 1;   /* first start state */

new_file:
        /* this is where we enter upon encountering and end-of-file and
         * yywrap() indicating that we should continue processing
         */

        /* we put in the '\n' and start reading from [1] so that an
         * initial match-at-newline will be true.
         */

        yy_ch_buf[0] = '\n';
        yy_n_chars = 1;

        /* we always need two end-of-buffer characters.  The first causes
         * a transition to the end-of-buffer state.  The second causes
         * a jam in that state.
         */
        yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
        yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

        yy_eof_has_been_seen = 0;

        YY_FAST_INIT;
        yy_init = 0;
        }

    while ( 1 )         /* loops until end-of-file is reached */
        {
        /* support of yytext and yyleng */
        YY_DO_BEFORE_SCAN;

        /* yy_b_buf_p points to the position in yy_ch_buf of the start of the
         * current run.
         */
        yy_b_buf_p = yy_c_buf_p;

        YY_FIND_START_STATE( yy_current_state );

        YY_FIND_NEXT_MATCH;

        YY_DO_BEFORE_ACTION;

/* we need this label to process the very last action (right before the end of
 * the file)
 */
do_action:
        YY_FIND_ACTION( yy_act );

#ifdef FLEX_DEBUG
        fprintf( stderr, "--accepting rule #%d\n", yy_act );
#endif
        switch ( yy_act )
            {
%% actions go here

            case YY_BACK_TRACK:
                YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */
                yy_c_buf_p = yy_last_accepting_cpos + 1;
                yy_current_state = yy_last_accepting_state;
                YY_DO_BEFORE_ACTION;
                goto do_action;

            case YY_NEW_FILE:
                break; /* begin reading from new file */

            case YY_DO_DEFAULT:
                /* we have to eat up one character and recompute yytext and
                 * yyleng
                 */
                YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */
                ++yy_c_buf_p;
                YY_DO_BEFORE_ACTION;
                YY_DEFAULT_ACTION;
                break;

            case YY_END_OF_BUFFER:
                YY_DO_BEFORE_SCAN; /* undo the effects of YY_DO_BEFORE_ACTION */

                switch ( yy_get_next_buffer() )
                    {
                    case EOB_ACT_END_OF_FILE:
                        {
                        if ( yywrap() )
                            {
                            /* note: because we've taken care in
                             * yy_get_next_buffer() to have set up yy_b_buf_p,
                             * we can now set up yy_c_buf_p so that if some
                             * total hoser (like flex itself) wants
                             * to call the scanner after we return the
                             * YY_NULL, it'll still work - another YY_NULL
                             * will get returned.
                             */
                            yy_c_buf_p = yy_b_buf_p;
                            return ( YY_NULL );
                            }

                        else
                            goto new_file;
                        }
                        break;

                    case EOB_ACT_RESTART_SCAN:
                        yy_c_buf_p = yy_b_buf_p;

                        YY_DO_BEFORE_RESTART;
                        break;

                    case EOB_ACT_LAST_MATCH:
                        yy_c_buf_p = &yy_ch_buf[yy_n_chars];

                        yy_current_state = yy_get_previous_state();

                        YY_DO_BEFORE_ACTION;

                        goto do_action;
                    }
                break;

            default:
                printf( "action # %d\n", yy_act );
                YY_FATAL_ERROR( "fatal flex scanner internal error" );
            }
        }
    }


/* yy_get_next_buffer - try to read in new buffer
 *
 * synopsis
 *     int yy_get_next_buffer();
 *
 * returns a code representing an action
 *     EOB_ACT_LAST_MATCH -
 *     EOB_ACT_RESTART_SCAN - restart the scanner
 *     EOB_ACT_END_OF_FILE - end of file
 */

static int yy_get_next_buffer()

    {
    if ( yy_c_buf_p != &yy_ch_buf[yy_n_chars + 1] )
        {
        YY_FATAL_ERROR( "NULL in input" );
        /*NOTREACHED*/
        }

    else
        { /* try to read more data */
        register char *dest = yy_ch_buf;
        register char *source = yy_b_buf_p - 1; /* copy prev. char, too */
        register int number_to_move, i;
        int ret_val;

        /* first move last chars to start of buffer */
        number_to_move = yy_c_buf_p - yy_b_buf_p;

        for ( i = 0; i < number_to_move; ++i )
            *(dest++) = *(source++);

        if ( yy_eof_has_been_seen )
            /* don't do the read, it's not guaranteed to return an EOF,
             * just force an EOF
             */
            yy_n_chars = 0;

        else
            /* read in more data */
            YY_INPUT( (&yy_ch_buf[number_to_move]), yy_n_chars,
                      YY_BUF_SIZE - number_to_move - 1 );

        if ( yy_n_chars == 0 )
            {
            if ( number_to_move == 1 )
                ret_val = EOB_ACT_END_OF_FILE;
            else
                ret_val = EOB_ACT_LAST_MATCH;

            yy_eof_has_been_seen = 1;
            }

        else
            ret_val = EOB_ACT_RESTART_SCAN;

        yy_n_chars += number_to_move;
        yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
        yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

        /* yy_b_buf_p begins at the second character in
         * yy_ch_buf; the first character is the one which
         * preceded it before reading in the latest buffer;
         * it needs to be kept around in case it's a
         * newline, so yy_get_previous_state() will have
         * with '^' rules active
         */

        yy_b_buf_p = &yy_ch_buf[1];

        return ( ret_val );
        }
    }


/* yy_get_previous_state - get the state just before the eob char was reached
 *
 * synopsis
 *     YY_CS_TYPE yy_get_previous_state();
 */

static YY_CS_TYPE yy_get_previous_state()

    {
    register YY_CS_TYPE yy_cur_state;
    register char *yy_temp_char_ptr;

    YY_FIND_START_STATE( yy_cur_state );

    for ( yy_temp_char_ptr = yy_b_buf_p; yy_temp_char_ptr < yy_c_buf_p; )
        YY_GET_NEXT_STATE;

    return ( yy_cur_state );
    }


static unput( c )
int c;

    {
    YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */

    if ( yy_c_buf_p < yy_ch_buf + 2 )
        { /* need to shift things up to make room */
        register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
        register char *dest = &yy_ch_buf[YY_BUF_SIZE + 2];
        register char *source = &yy_ch_buf[number_to_move];

        while ( source > yy_ch_buf )
            *--dest = *--source;

        yy_c_buf_p += dest - source;
        yy_b_buf_p += dest - source;

        if ( yy_c_buf_p < yy_ch_buf + 2 )
            YY_FATAL_ERROR( "flex scanner push-back overflow" );
        }

    if ( yy_c_buf_p > yy_b_buf_p && yy_c_buf_p[-1] == '\n' )
        yy_c_buf_p[-2] = '\n';

    *--yy_c_buf_p = c;

    YY_DO_BEFORE_ACTION; /* set up yytext again */
    }


static int input()

    {
    int c;

    YY_DO_BEFORE_SCAN;

    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
        { /* need more input */
        yy_b_buf_p = yy_c_buf_p;
        ++yy_c_buf_p;

        switch ( yy_get_next_buffer() )
            {
            /* this code, unfortunately, is somewhat redundant with
             * that above
             */
            case EOB_ACT_END_OF_FILE:
                {
                if ( yywrap() )
                    {
                    yy_c_buf_p = yy_b_buf_p;
                    return ( EOF );
                    }

                yy_ch_buf[0] = '\n';
                yy_n_chars = 1;
                yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
                yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
                yy_eof_has_been_seen = 0;

                YY_FAST_INIT;

                return ( input() );
                }
                break;

            case EOB_ACT_RESTART_SCAN:
                yy_c_buf_p = yy_b_buf_p;
                break;

            case EOB_ACT_LAST_MATCH:
                YY_FATAL_ERROR( "unexpected last match in input()" );
            }
        }

    c = *yy_c_buf_p++;

    YY_DO_BEFORE_RESTART;

    return ( c );
    }