yyFlexLexer Class Reference

#include <ossimFlexLexer.h>

Inheritance diagram for yyFlexLexer:

Public Member Functions
	yyFlexLexer (istream *arg_yyin=0, ostream *arg_yyout=0)
virtual	~yyFlexLexer ()
void	yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
struct yy_buffer_state *	yy_create_buffer (istream *s, int size)
void	yy_delete_buffer (struct yy_buffer_state *b)
void	yyrestart (istream *s)
virtual int	yylex ()
virtual void	switch_streams (istream *new_in, ostream *new_out)
Public Member Functions inherited from FlexLexer
virtual	~FlexLexer ()
const char *	YYText ()
int	YYLeng ()
int	yylex (istream *new_in, ostream *new_out=0)
int	lineno () const
int	debug () const
void	set_debug (int flag)

Protected Member Functions
virtual int	LexerInput (char *buf, int max_size)
virtual void	LexerOutput (const char *buf, int size)
virtual void	LexerError (const char *msg)
void	yyunput (int c, char *buf_ptr)
int	yyinput ()
void	yy_load_buffer_state ()
void	yy_init_buffer (struct yy_buffer_state *b, istream *s)
void	yy_flush_buffer (struct yy_buffer_state *b)
void	yy_push_state (int new_state)
void	yy_pop_state ()
int	yy_top_state ()
yy_state_type	yy_get_previous_state ()
yy_state_type	yy_try_NUL_trans (yy_state_type current_state)
int	yy_get_next_buffer ()

Protected Attributes
int	yy_start_stack_ptr
int	yy_start_stack_depth
int *	yy_start_stack
istream *	yyin
ostream *	yyout
struct yy_buffer_state *	yy_current_buffer
char	yy_hold_char
int	yy_n_chars
char *	yy_c_buf_p
int	yy_init
int	yy_start
int	yy_did_buffer_switch_on_eof
yy_state_type	yy_last_accepting_state
char *	yy_last_accepting_cpos
yy_state_type *	yy_state_buf
yy_state_type *	yy_state_ptr
char *	yy_full_match
int *	yy_full_state
int	yy_full_lp
int	yy_lp
int	yy_looking_for_trail_begin
int	yy_more_flag
int	yy_more_len
int	yy_more_offset
int	yy_prev_more_offset
Protected Attributes inherited from FlexLexer
char *	yytext
int	yyleng
int	yylineno
int	yy_flex_debug

Detailed Description

Definition at line 106 of file ossimFlexLexer.h.

Constructor & Destructor Documentation

yyFlexLexer()

yyFlexLexer::yyFlexLexer	(	istream *	arg_yyin = 0,
		ostream *	arg_yyout = 0
	)

Definition at line 1140 of file ossimEquTokenizer.cpp.

References YY_BUF_SIZE.

    {
    yyin = arg_yyin;
    yyout = arg_yyout;
    yy_c_buf_p = 0;
    yy_init = 1;
    yy_start = 0;
    yy_flex_debug = 0;
    yylineno = 1;   // this will only get updated if %option yylineno

    yy_did_buffer_switch_on_eof = 0;

    yy_looking_for_trail_begin = 0;
    yy_more_flag = 0;
    yy_more_len = 0;
    yy_more_offset = yy_prev_more_offset = 0;

    yy_start_stack_ptr = yy_start_stack_depth = 0;
    yy_start_stack = 0;

    yy_current_buffer = 0;

#ifdef YY_USES_REJECT
    yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];
#else
    yy_state_buf = 0;
#endif
    }

~yyFlexLexer()

yyFlexLexer::~yyFlexLexer ( )

virtual

Definition at line 1169 of file ossimEquTokenizer.cpp.

    {
    delete yy_state_buf;
    yy_delete_buffer( yy_current_buffer );
    }

Member Function Documentation

LexerError()

void yyFlexLexer::LexerError ( const char *  msg )

protectedvirtual

Definition at line 1709 of file ossimEquTokenizer.cpp.

References YY_EXIT_FAILURE.

    {
    cerr << msg << '\n';
    exit( YY_EXIT_FAILURE );
    }

LexerInput()

int yyFlexLexer::LexerInput ( char *  buf, int  max_size  )

protectedvirtual

Definition at line 1188 of file ossimEquTokenizer.cpp.

    {
    if ( yyin->eof() || yyin->fail() )
        return 0;

#ifdef YY_INTERACTIVE
    yyin->get( buf[0] );

    if ( yyin->eof() )
        return 0;

    if ( yyin->bad() )
        return -1;

    return 1;

#else
    (void) yyin->read( buf, max_size );

    if ( yyin->bad() )
        return -1;
    else
        return yyin->gcount();
#endif
    }

LexerOutput()

void yyFlexLexer::LexerOutput ( const char *  buf, int  size  )

protectedvirtual

Definition at line 1217 of file ossimEquTokenizer.cpp.

References size.

    {
    (void) yyout->write( buf, size );
    }

switch_streams()

void yyFlexLexer::switch_streams ( istream *  new_in, ostream *  new_out  )

virtual

Implements FlexLexer.

Definition at line 1175 of file ossimEquTokenizer.cpp.

References YY_BUF_SIZE.

    {
    if ( new_in )
        {
        yy_delete_buffer( yy_current_buffer );
        yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
        }

    if ( new_out )
        yyout = new_out;
    }

yy_create_buffer()

YY_BUFFER_STATE yyFlexLexer::yy_create_buffer ( istream *  s, int  size  )

virtual

Implements FlexLexer.

Definition at line 1569 of file ossimEquTokenizer.cpp.

    {
    YY_BUFFER_STATE b;

    b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
    if ( ! b )
        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

    b->yy_buf_size = size;

    /* yy_ch_buf has to be 2 characters longer than the size given because
     * we need to put in 2 end-of-buffer characters.
     */
    b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
    if ( ! b->yy_ch_buf )
        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

    b->yy_is_our_buffer = 1;

    yy_init_buffer( b, file );

    return b;
    }

yy_delete_buffer()

void yyFlexLexer::yy_delete_buffer ( struct yy_buffer_state *  b )

virtual

Implements FlexLexer.

Definition at line 1594 of file ossimEquTokenizer.cpp.

References yy_buffer_state::yy_is_our_buffer.

    {
    if ( ! b )
        return;

    if ( b == yy_current_buffer )
        yy_current_buffer = (YY_BUFFER_STATE) 0;

    if ( b->yy_is_our_buffer )
        yy_flex_free( (void *) b->yy_ch_buf );

    yy_flex_free( (void *) b );
    }

yy_flush_buffer()

void yyFlexLexer::yy_flush_buffer ( struct yy_buffer_state *  b )

protected

Definition at line 1621 of file ossimEquTokenizer.cpp.

References yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_END_OF_BUFFER_CHAR, and yy_buffer_state::yy_n_chars.

    {
    if ( ! b )
        return;

    b->yy_n_chars = 0;

    /* 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.
     */
    b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

    b->yy_buf_pos = &b->yy_ch_buf[0];

    b->yy_at_bol = 1;
    b->yy_buffer_status = YY_BUFFER_NEW;

    if ( b == yy_current_buffer )
        yy_load_buffer_state();
    }

yy_get_next_buffer()

int yyFlexLexer::yy_get_next_buffer ( )

protected

Definition at line 1230 of file ossimEquTokenizer.cpp.

References EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, and yytext_ptr.

    {
    char *dest = yy_current_buffer->yy_ch_buf;
    char *source = yytext_ptr;
    int number_to_move, i;
    int ret_val;

    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
        YY_FATAL_ERROR(
        "fatal flex scanner internal error--end of buffer missed" );

    if ( yy_current_buffer->yy_fill_buffer == 0 )
        { /* Don't try to fill the buffer, so this is an EOF. */
        if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
            {
            /* We matched a single character, the EOB, so
             * treat this as a final EOF.
             */
            return EOB_ACT_END_OF_FILE;
            }

        else
            {
            /* We matched some text prior to the EOB, first
             * process it.
             */
            return EOB_ACT_LAST_MATCH;
            }
        }

    /* Try to read more data. */

    /* First move last chars to start of buffer. */
    number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;

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

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

    else
        {
        int num_to_read =
            yy_current_buffer->yy_buf_size - number_to_move - 1;

        while ( num_to_read <= 0 )
            { /* Not enough room in the buffer - grow it. */
#ifdef YY_USES_REJECT
            YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else

            /* just a shorter name for the current buffer */
            YY_BUFFER_STATE b = yy_current_buffer;

            int yy_c_buf_p_offset =
                (int) (yy_c_buf_p - b->yy_ch_buf);

            if ( b->yy_is_our_buffer )
                {
                int new_size = b->yy_buf_size * 2;

                if ( new_size <= 0 )
                    b->yy_buf_size += b->yy_buf_size / 8;
                else
                    b->yy_buf_size *= 2;

                b->yy_ch_buf = (char *)
                    /* Include room in for 2 EOB chars. */
                    yy_flex_realloc( (void *) b->yy_ch_buf,
                             b->yy_buf_size + 2 );
                }
            else
                /* Can't grow it, we don't own it. */
                b->yy_ch_buf = 0;

            if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR(
                "fatal error - scanner input buffer overflow" );

            yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

            num_to_read = yy_current_buffer->yy_buf_size -
                        number_to_move - 1;
#endif
            }

        if ( num_to_read > YY_READ_BUF_SIZE )
            num_to_read = YY_READ_BUF_SIZE;

        /* Read in more data. */
        YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
            yy_n_chars, num_to_read );

        yy_current_buffer->yy_n_chars = yy_n_chars;
        }

    if ( yy_n_chars == 0 )
        {
        if ( number_to_move == YY_MORE_ADJ )
            {
            ret_val = EOB_ACT_END_OF_FILE;
            yyrestart( yyin );
            }

        else
            {
            ret_val = EOB_ACT_LAST_MATCH;
            yy_current_buffer->yy_buffer_status =
                YY_BUFFER_EOF_PENDING;
            }
        }

    else
        ret_val = EOB_ACT_CONTINUE_SCAN;

    yy_n_chars += number_to_move;
    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

    yytext_ptr = &yy_current_buffer->yy_ch_buf[0];

    return ret_val;
    }

yy_get_previous_state()

yy_state_type yyFlexLexer::yy_get_previous_state ( )

protected

Definition at line 1362 of file ossimEquTokenizer.cpp.

References yy_cp, YY_MORE_ADJ, and yytext_ptr.

    {
    yy_state_type yy_current_state;
    char *yy_cp;

    yy_current_state = yy_start;

    for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
        {
        YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
        if ( yy_accept[yy_current_state] )
            {
            yy_last_accepting_state = yy_current_state;
            yy_last_accepting_cpos = yy_cp;
            }
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
            {
            yy_current_state = (int) yy_def[yy_current_state];
            if ( yy_current_state >= 119 )
                yy_c = yy_meta[(unsigned int) yy_c];
            }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
        }

    return yy_current_state;
    }

yy_init_buffer()

void yyFlexLexer::yy_init_buffer ( struct yy_buffer_state *  b, istream *  s  )

protected

Definition at line 1609 of file ossimEquTokenizer.cpp.

References yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, and yy_buffer_state::yy_is_interactive.

    {
    yy_flush_buffer( b );

    b->yy_input_file = file;
    b->yy_fill_buffer = 1;

    b->yy_is_interactive = 0;
    }

yy_load_buffer_state()

void yyFlexLexer::yy_load_buffer_state ( )

protected

Definition at line 1560 of file ossimEquTokenizer.cpp.

References yytext_ptr.

    {
    yy_n_chars = yy_current_buffer->yy_n_chars;
    yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
    yyin = yy_current_buffer->yy_input_file;
    yy_hold_char = *yy_c_buf_p;
    }

yy_pop_state()

void yyFlexLexer::yy_pop_state ( )

protected

yy_push_state()

void yyFlexLexer::yy_push_state ( int  new_state )

protected

yy_switch_to_buffer()

void yyFlexLexer::yy_switch_to_buffer ( struct yy_buffer_state *  new_buffer )

virtual

Implements FlexLexer.

Definition at line 1535 of file ossimEquTokenizer.cpp.

    {
    if ( yy_current_buffer == new_buffer )
        return;

    if ( yy_current_buffer )
        {
        /* Flush out information for old buffer. */
        *yy_c_buf_p = yy_hold_char;
        yy_current_buffer->yy_buf_pos = yy_c_buf_p;
        yy_current_buffer->yy_n_chars = yy_n_chars;
        }

    yy_current_buffer = new_buffer;
    yy_load_buffer_state();

    /* We don't actually know whether we did this switch during
     * EOF (yywrap()) processing, but the only time this flag
     * is looked at is after yywrap() is called, so it's safe
     * to go ahead and always set it.
     */
    yy_did_buffer_switch_on_eof = 1;
    }

yy_top_state()

int yyFlexLexer::yy_top_state ( )

protected

yy_try_NUL_trans()

yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type  current_state )

protected

Definition at line 1396 of file ossimEquTokenizer.cpp.

References yy_cp.

    {
    int yy_is_jam;
    char *yy_cp = yy_c_buf_p;

    YY_CHAR yy_c = 1;
    if ( yy_accept[yy_current_state] )
        {
        yy_last_accepting_state = yy_current_state;
        yy_last_accepting_cpos = yy_cp;
        }
    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
        {
        yy_current_state = (int) yy_def[yy_current_state];
        if ( yy_current_state >= 119 )
            yy_c = yy_meta[(unsigned int) yy_c];
        }
    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    yy_is_jam = (yy_current_state == 118);

    return yy_is_jam ? 0 : yy_current_state;
    }

yyinput()

int yyFlexLexer::yyinput ( )

protected

Definition at line 1457 of file ossimEquTokenizer.cpp.

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, YY_END_OF_BUFFER_CHAR, YY_NEW_FILE, yytext_ptr, and yywrap().

    {
    int c;

    *yy_c_buf_p = yy_hold_char;

    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
        {
        /* yy_c_buf_p now points to the character we want to return.
         * If this occurs *before* the EOB characters, then it's a
         * valid NUL; if not, then we've hit the end of the buffer.
         */
        if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
            /* This was really a NUL. */
            *yy_c_buf_p = '\0';

        else
            { /* need more input */
            int offset = yy_c_buf_p - yytext_ptr;
            ++yy_c_buf_p;

            switch ( yy_get_next_buffer() )
                {
                case EOB_ACT_LAST_MATCH:
                    /* This happens because yy_g_n_b()
                     * sees that we've accumulated a
                     * token and flags that we need to
                     * try matching the token before
                     * proceeding.  But for input(),
                     * there's no matching to consider.
                     * So convert the EOB_ACT_LAST_MATCH
                     * to EOB_ACT_END_OF_FILE.
                     */

                    /* Reset buffer status. */
                    yyrestart( yyin );

                    /* fall through */

                case EOB_ACT_END_OF_FILE:
                    {
                    if ( yywrap() )
                        return EOF;

                    if ( ! yy_did_buffer_switch_on_eof )
                        YY_NEW_FILE;
#ifdef __cplusplus
                    return yyinput();
#else
                    return input();
#endif
                    }

                case EOB_ACT_CONTINUE_SCAN:
                    yy_c_buf_p = yytext_ptr + offset;
                    break;
                }
            }
        }

    c = *(unsigned char *) yy_c_buf_p;  /* cast for 8-bit char's */
    *yy_c_buf_p = '\0'; /* preserve yytext */
    yy_hold_char = *++yy_c_buf_p;


    return c;
    }

yylex()

virtual int yyFlexLexer::yylex ( )

virtual

Implements FlexLexer.

yyrestart()

void yyFlexLexer::yyrestart ( istream *  s )

virtual

Implements FlexLexer.

Definition at line 1525 of file ossimEquTokenizer.cpp.

References YY_BUF_SIZE.

    {
    if ( ! yy_current_buffer )
        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );

    yy_init_buffer( yy_current_buffer, input_file );
    yy_load_buffer_state();
    }

yyunput()

void yyFlexLexer::yyunput ( int  c, char *  buf_ptr  )

protected

Definition at line 1420 of file ossimEquTokenizer.cpp.

References yy_bp, yy_cp, YY_FATAL_ERROR, and yytext_ptr.

    {
    char *yy_cp = yy_c_buf_p;

    /* undo effects of setting up yytext */
    *yy_cp = yy_hold_char;

    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
        { /* need to shift things up to make room */
        /* +2 for EOB chars. */
        int number_to_move = yy_n_chars + 2;
        char *dest = &yy_current_buffer->yy_ch_buf[
                    yy_current_buffer->yy_buf_size + 2];
        char *source =
                &yy_current_buffer->yy_ch_buf[number_to_move];

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

        yy_cp += (int) (dest - source);
        yy_bp += (int) (dest - source);
        yy_current_buffer->yy_n_chars =
            yy_n_chars = yy_current_buffer->yy_buf_size;

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

    *--yy_cp = (char) c;


    yytext_ptr = yy_bp;
    yy_hold_char = *yy_cp;
    yy_c_buf_p = yy_cp;
    }

Member Data Documentation

yy_c_buf_p

char* yyFlexLexer::yy_c_buf_p

protected

Definition at line 158 of file ossimFlexLexer.h.

yy_current_buffer

struct yy_buffer_state* yyFlexLexer::yy_current_buffer

protected

Definition at line 149 of file ossimFlexLexer.h.

yy_did_buffer_switch_on_eof

int yyFlexLexer::yy_did_buffer_switch_on_eof

protected

Definition at line 165 of file ossimFlexLexer.h.

yy_full_lp

int yyFlexLexer::yy_full_lp

protected

Definition at line 178 of file ossimFlexLexer.h.

yy_full_match

char* yyFlexLexer::yy_full_match

protected

Definition at line 176 of file ossimFlexLexer.h.

yy_full_state

int* yyFlexLexer::yy_full_state

protected

Definition at line 177 of file ossimFlexLexer.h.

yy_hold_char

char yyFlexLexer::yy_hold_char

protected

Definition at line 152 of file ossimFlexLexer.h.

yy_init

int yyFlexLexer::yy_init

protected

Definition at line 160 of file ossimFlexLexer.h.

yy_last_accepting_cpos

char* yyFlexLexer::yy_last_accepting_cpos

protected

Definition at line 171 of file ossimFlexLexer.h.

yy_last_accepting_state

yy_state_type yyFlexLexer::yy_last_accepting_state

protected

Definition at line 170 of file ossimFlexLexer.h.

yy_looking_for_trail_begin

int yyFlexLexer::yy_looking_for_trail_begin

protected

Definition at line 181 of file ossimFlexLexer.h.

yy_lp

int yyFlexLexer::yy_lp

protected

Definition at line 180 of file ossimFlexLexer.h.

yy_more_flag

int yyFlexLexer::yy_more_flag

protected

Definition at line 183 of file ossimFlexLexer.h.

yy_more_len

int yyFlexLexer::yy_more_len

protected

Definition at line 184 of file ossimFlexLexer.h.

yy_more_offset

int yyFlexLexer::yy_more_offset

protected

Definition at line 185 of file ossimFlexLexer.h.

yy_n_chars

int yyFlexLexer::yy_n_chars

protected

Definition at line 155 of file ossimFlexLexer.h.

yy_prev_more_offset

int yyFlexLexer::yy_prev_more_offset

protected

Definition at line 186 of file ossimFlexLexer.h.

yy_start

int yyFlexLexer::yy_start

protected

Definition at line 161 of file ossimFlexLexer.h.

yy_start_stack

int* yyFlexLexer::yy_start_stack

protected

Definition at line 136 of file ossimFlexLexer.h.

yy_start_stack_depth

int yyFlexLexer::yy_start_stack_depth

protected

Definition at line 135 of file ossimFlexLexer.h.

yy_start_stack_ptr

int yyFlexLexer::yy_start_stack_ptr

protected

Definition at line 134 of file ossimFlexLexer.h.

yy_state_buf

yy_state_type* yyFlexLexer::yy_state_buf

protected

Definition at line 173 of file ossimFlexLexer.h.

yy_state_ptr

yy_state_type* yyFlexLexer::yy_state_ptr

protected

Definition at line 174 of file ossimFlexLexer.h.

yyin

istream* yyFlexLexer::yyin

protected

Definition at line 146 of file ossimFlexLexer.h.

yyout

ostream* yyFlexLexer::yyout

protected

Definition at line 147 of file ossimFlexLexer.h.

---

The documentation for this class was generated from the following files:

• ossimFlexLexer.h
• ossimEquTokenizer.cpp