yyFlexLexer Class Reference

#include <FlexLexer.h>

Inheritance diagram for yyFlexLexer:

Collaboration diagram for yyFlexLexer:

Public Member Functions
	yyFlexLexer (FLEX_STD istream *arg_yyin=0, FLEX_STD ostream *arg_yyout=0)
virtual	~yyFlexLexer ()
void	yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
struct yy_buffer_state *	yy_create_buffer (FLEX_STD istream *s, int size)
void	yy_delete_buffer (struct yy_buffer_state *b)
void	yyrestart (FLEX_STD istream *s)
void	yypush_buffer_state (struct yy_buffer_state *new_buffer)
void	yypop_buffer_state ()
virtual int	yylex ()
virtual void	switch_streams (FLEX_STD istream *new_in, FLEX_STD ostream *new_out)
virtual int	yywrap ()
	yyFlexLexer (FLEX_STD istream *arg_yyin=0, FLEX_STD ostream *arg_yyout=0)
virtual	~yyFlexLexer ()
void	yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
struct yy_buffer_state *	yy_create_buffer (FLEX_STD istream *s, int size)
void	yy_delete_buffer (struct yy_buffer_state *b)
void	yyrestart (FLEX_STD istream *s)
void	yypush_buffer_state (struct yy_buffer_state *new_buffer)
void	yypop_buffer_state ()
virtual int	yylex ()
virtual void	switch_streams (FLEX_STD istream *new_in, FLEX_STD ostream *new_out=0)
virtual int	yywrap ()
	yyFlexLexer (FLEX_STD istream *arg_yyin=0, FLEX_STD ostream *arg_yyout=0)
virtual	~yyFlexLexer ()
void	yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
struct yy_buffer_state *	yy_create_buffer (FLEX_STD istream *s, int size)
void	yy_delete_buffer (struct yy_buffer_state *b)
void	yyrestart (FLEX_STD istream *s)
void	yypush_buffer_state (struct yy_buffer_state *new_buffer)
void	yypop_buffer_state ()
virtual int	yylex ()
virtual void	switch_streams (FLEX_STD istream *new_in, FLEX_STD ostream *new_out)
virtual int	yywrap ()
const char *	YYText () const
const char *	YYText () const
const char *	YYText () const
int	YYLeng () const
int	YYLeng () const
int	YYLeng () const
int	yylex (FLEX_STD istream *new_in, FLEX_STD ostream *new_out=0)
int	lineno () const
int	lineno () const
int	lineno () const
int	debug () const
int	debug () const
int	debug () const
void	set_debug (int flag)
void	set_debug (int flag)
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, FLEX_STD 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 ()
void	yyensure_buffer_stack (void)
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, FLEX_STD 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 ()
void	yyensure_buffer_stack (void)
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, FLEX_STD 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 ()
void	yyensure_buffer_stack (void)

Protected Attributes
int	yy_start_stack_ptr
int	yy_start_stack_depth
int *	yy_start_stack
FLEX_STD istream *	yyin
FLEX_STD ostream *	yyout
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
size_t	yy_buffer_stack_top
size_t	yy_buffer_stack_max
struct yy_buffer_state **	yy_buffer_stack
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
char *	yytext
int	yyleng
int	yylineno
int	yy_flex_debug

Detailed Description

Definition at line 113 of file bitstream/assembler/lut/FlexLexer.h.

Constructor & Destructor Documentation

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

yyFlexLexer::~yyFlexLexer ( )

virtual

Definition at line 905 of file LutScanner.cpp.

{
    delete [] yy_state_buf;
    Lutfree(yy_start_stack  );
    yy_delete_buffer( YY_CURRENT_BUFFER );
    Lutfree(yy_buffer_stack  );
}

Here is the call graph for this function:

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

virtual yyFlexLexer::~yyFlexLexer ( )

virtual

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

virtual yyFlexLexer::~yyFlexLexer ( )

virtual

Member Function Documentation

int FlexLexer::debug ( ) const

inlineinherited

Definition at line 91 of file generic/edif/FlexLexer.h.

{ return yy_flex_debug; }

int FlexLexer::debug ( ) const

inlineinherited

Definition at line 92 of file bitstream/assembler/lut/FlexLexer.h.

{ return yy_flex_debug; }

int FlexLexer::debug ( ) const

inlineinherited

Definition at line 92 of file physical/xdl/FlexLexer.h.

{ return yy_flex_debug; }

virtual void yyFlexLexer::LexerError ( const char *  msg )

protectedvirtual

virtual void yyFlexLexer::LexerError ( const char *  msg )

protectedvirtual

virtual void yyFlexLexer::LexerError ( const char *  msg )

protectedvirtual

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

protectedvirtual

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

protectedvirtual

Definition at line 930 of file LutScanner.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
}

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

protectedvirtual

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

protectedvirtual

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

protectedvirtual

Definition at line 957 of file LutScanner.cpp.

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

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

protectedvirtual

int FlexLexer::lineno ( ) const

inlineinherited

Definition at line 89 of file generic/edif/FlexLexer.h.

{ return yylineno; }

int FlexLexer::lineno ( ) const

inlineinherited

Definition at line 90 of file bitstream/assembler/lut/FlexLexer.h.

{ return yylineno; }

int FlexLexer::lineno ( ) const

inlineinherited

Definition at line 90 of file physical/xdl/FlexLexer.h.

{ return yylineno; }

void FlexLexer::set_debug ( int  flag )

inlineinherited

Definition at line 92 of file generic/edif/FlexLexer.h.

{ yy_flex_debug = flag; }

void FlexLexer::set_debug ( int  flag )

inlineinherited

Definition at line 93 of file bitstream/assembler/lut/FlexLexer.h.

{ yy_flex_debug = flag; }

void FlexLexer::set_debug ( int  flag )

inlineinherited

Definition at line 93 of file physical/xdl/FlexLexer.h.

{ yy_flex_debug = flag; }

virtual void yyFlexLexer::switch_streams ( FLEX_STD istream *  new_in, FLEX_STD ostream *  new_out = 0  )

virtual

Implements FlexLexer.

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

virtual

Implements FlexLexer.

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

virtual

Implements FlexLexer.

struct yy_buffer_state* yyFlexLexer::yy_create_buffer ( FLEX_STD istream *  s, int  size  )

virtual

Implements FlexLexer.

struct yy_buffer_state* yyFlexLexer::yy_create_buffer ( FLEX_STD istream *  s, int  size  )

virtual

Implements FlexLexer.

struct yy_buffer_state* yyFlexLexer::yy_create_buffer ( FLEX_STD istream *  s, int  size  )

virtual

Implements FlexLexer.

void yyFlexLexer::yy_delete_buffer ( struct yy_buffer_state *  b )

virtual

Implements FlexLexer.

void yyFlexLexer::yy_delete_buffer ( struct yy_buffer_state *  b )

virtual

Implements FlexLexer.

void yyFlexLexer::yy_delete_buffer ( struct yy_buffer_state *  b )

virtual

Implements FlexLexer.

void yyFlexLexer::yy_flush_buffer ( struct yy_buffer_state *  b )

protected

void yyFlexLexer::yy_flush_buffer ( struct yy_buffer_state *  b )

protected

void yyFlexLexer::yy_flush_buffer ( struct yy_buffer_state *  b )

protected

int yyFlexLexer::yy_get_next_buffer ( )

protected

int yyFlexLexer::yy_get_next_buffer ( )

protected

int yyFlexLexer::yy_get_next_buffer ( )

protected

Definition at line 969 of file LutScanner.cpp.

{
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    register char *source = (yytext_ptr);
    register int number_to_move, i;
    int ret_val;

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

    if ( YY_CURRENT_BUFFER_LVALUE->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_LVALUE->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_LVALUE->yy_n_chars = (yy_n_chars) = 0;

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

        while ( num_to_read <= 0 )
            { /* Not enough room in the buffer - grow it. */

            /* 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. */
                    Lutrealloc((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_LVALUE->yy_buf_size -
                        number_to_move - 1;

            }

        if ( num_to_read > YY_READ_BUF_SIZE )
            num_to_read = YY_READ_BUF_SIZE;

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

        YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_buffer_status =
                YY_BUFFER_EOF_PENDING;
            }
        }

    else
        ret_val = EOB_ACT_CONTINUE_SCAN;

    if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
        /* Extend the array by 50%, plus the number we really need. */
        yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) Lutrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
        if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
            YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    }

    (yy_n_chars) += number_to_move;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

    (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

    return ret_val;
}

Here is the call graph for this function:

yy_state_type yyFlexLexer::yy_get_previous_state ( )

protected

yy_state_type yyFlexLexer::yy_get_previous_state ( )

protected

yy_state_type yyFlexLexer::yy_get_previous_state ( )

protected

Definition at line 1103 of file LutScanner.cpp.

{
    register yy_state_type yy_current_state;
    register char *yy_cp;
    
    yy_current_state = (yy_start);

    for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
        {
        register 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 >= 19 )
                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;
}

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

protected

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

protected

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

protected

void yyFlexLexer::yy_load_buffer_state ( )

protected

void yyFlexLexer::yy_load_buffer_state ( )

protected

Definition at line 1315 of file LutScanner.cpp.

{
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    (yy_hold_char) = *(yy_c_buf_p);
}

void yyFlexLexer::yy_load_buffer_state ( )

protected

void yyFlexLexer::yy_pop_state ( )

protected

void yyFlexLexer::yy_pop_state ( )

protected

void yyFlexLexer::yy_pop_state ( )

protected

Definition at line 1550 of file LutScanner.cpp.

{
        if ( --(yy_start_stack_ptr) < 0 )
        YY_FATAL_ERROR( "start-condition stack underflow" );

    BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
}

void yyFlexLexer::yy_push_state ( int  new_state )

protected

void yyFlexLexer::yy_push_state ( int  new_state )

protected

Definition at line 1526 of file LutScanner.cpp.

{
        if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
        {
        yy_size_t new_size;

        (yy_start_stack_depth) += YY_START_STACK_INCR;
        new_size = (yy_start_stack_depth) * sizeof( int );

        if ( ! (yy_start_stack) )
            (yy_start_stack) = (int *) Lutalloc(new_size  );

        else
            (yy_start_stack) = (int *) Lutrealloc((void *) (yy_start_stack),new_size  );

        if ( ! (yy_start_stack) )
            YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
        }

    (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;

    BEGIN(new_state);
}

Here is the call graph for this function:

void yyFlexLexer::yy_push_state ( int  new_state )

protected

void yyFlexLexer::yy_switch_to_buffer ( struct yy_buffer_state *  new_buffer )

virtual

Implements FlexLexer.

void yyFlexLexer::yy_switch_to_buffer ( struct yy_buffer_state *  new_buffer )

virtual

Implements FlexLexer.

void yyFlexLexer::yy_switch_to_buffer ( struct yy_buffer_state *  new_buffer )

virtual

Implements FlexLexer.

int yyFlexLexer::yy_top_state ( )

protected

int yyFlexLexer::yy_top_state ( )

protected

int yyFlexLexer::yy_top_state ( )

protected

Definition at line 1558 of file LutScanner.cpp.

{
        return (yy_start_stack)[(yy_start_stack_ptr) - 1];
}

yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type  current_state )

protected

yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type  current_state )

protected

Definition at line 1135 of file LutScanner.cpp.

{
    register int yy_is_jam;
        register char *yy_cp = (yy_c_buf_p);

    register 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 >= 19 )
            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 == 18);

    return yy_is_jam ? 0 : yy_current_state;
}

yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type  current_state )

protected

void yyFlexLexer::yyensure_buffer_stack ( void  )

protected

void yyFlexLexer::yyensure_buffer_stack ( void  )

protected

void yyFlexLexer::yyensure_buffer_stack ( void  )

protected

Definition at line 1483 of file LutScanner.cpp.

{
    int num_to_alloc;
    
    if (!(yy_buffer_stack)) {

        /* First allocation is just for 2 elements, since we don't know if this
         * scanner will even need a stack. We use 2 instead of 1 to avoid an
         * immediate realloc on the next call.
         */
        num_to_alloc = 1;
        (yy_buffer_stack) = (struct yy_buffer_state**)Lutalloc
                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
                                  
        memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                
        (yy_buffer_stack_max) = num_to_alloc;
        (yy_buffer_stack_top) = 0;
        return;
    }

    if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

        /* Increase the buffer to prepare for a possible push. */
        int grow_size = 8 /* arbitrary grow size */;

        num_to_alloc = (yy_buffer_stack_max) + grow_size;
        (yy_buffer_stack) = (struct yy_buffer_state**)Lutrealloc
                                ((yy_buffer_stack),
                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

        /* zero only the new slots.*/
        memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
        (yy_buffer_stack_max) = num_to_alloc;
    }
}

Here is the call graph for this function:

int yyFlexLexer::yyinput ( )

protected

int yyFlexLexer::yyinput ( )

protected

int yyFlexLexer::yyinput ( )

protected

Definition at line 1195 of file LutScanner.cpp.

{
    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_LVALUE->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 );

                    /*FALLTHROUGH*/

                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;
}

int FlexLexer::YYLeng ( ) const

inlineinherited

Definition at line 66 of file generic/edif/FlexLexer.h.

{ return yyleng; }

int FlexLexer::YYLeng ( ) const

inlineinherited

Definition at line 67 of file physical/xdl/FlexLexer.h.

{ return yyleng; }

int FlexLexer::YYLeng ( ) const

inlineinherited

Definition at line 67 of file bitstream/assembler/lut/FlexLexer.h.

{ return yyleng; }

int FlexLexer::yylex ( FLEX_STD istream *  new_in, FLEX_STD ostream *  new_out = 0  )

inlineinherited

Definition at line 79 of file bitstream/assembler/lut/FlexLexer.h.

    {
    switch_streams(new_in, new_out);
    return yylex();
    }

Here is the call graph for this function:

virtual int yyFlexLexer::yylex ( )

virtual

Implements FlexLexer.

virtual int yyFlexLexer::yylex ( )

virtual

Implements FlexLexer.

virtual int yyFlexLexer::yylex ( )

virtual

Implements FlexLexer.

void yyFlexLexer::yypop_buffer_state

(

)

void yyFlexLexer::yypop_buffer_state

(

)

void yyFlexLexer::yypop_buffer_state

(

void

)

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Definition at line 1464 of file LutScanner.cpp.

{
        if (!YY_CURRENT_BUFFER)
        return;

    yy_delete_buffer(YY_CURRENT_BUFFER );
    YY_CURRENT_BUFFER_LVALUE = NULL;
    if ((yy_buffer_stack_top) > 0)
        --(yy_buffer_stack_top);

    if (YY_CURRENT_BUFFER) {
        yy_load_buffer_state(  );
        (yy_did_buffer_switch_on_eof) = 1;
    }
}

void yyFlexLexer::yypush_buffer_state

(

struct yy_buffer_state *

new_buffer

)

void yyFlexLexer::yypush_buffer_state

(

struct yy_buffer_state *

new_buffer

)

void yyFlexLexer::yypush_buffer_state

(

struct yy_buffer_state *

new_buffer

)

void yyFlexLexer::yyrestart ( FLEX_STD istream *  s )

virtual

Implements FlexLexer.

void yyFlexLexer::yyrestart ( FLEX_STD istream *  s )

virtual

Implements FlexLexer.

void yyFlexLexer::yyrestart ( FLEX_STD istream *  s )

virtual

Implements FlexLexer.

const char* FlexLexer::YYText ( ) const

inlineinherited

Definition at line 65 of file generic/edif/FlexLexer.h.

{ return yytext; }

const char* FlexLexer::YYText ( ) const

inlineinherited

Definition at line 66 of file physical/xdl/FlexLexer.h.

{ return yytext; }

const char* FlexLexer::YYText ( ) const

inlineinherited

Definition at line 66 of file bitstream/assembler/lut/FlexLexer.h.

{ return yytext; }

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

protected

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

protected

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

protected

virtual int yyFlexLexer::yywrap ( )

virtual

virtual int yyFlexLexer::yywrap ( )

virtual

virtual int yyFlexLexer::yywrap ( )

virtual

Field Documentation

struct yy_buffer_state ** yyFlexLexer::yy_buffer_stack

protected

Stack as an array.

Definition at line 185 of file bitstream/assembler/lut/FlexLexer.h.

size_t yyFlexLexer::yy_buffer_stack_max

protected

capacity of stack.

Definition at line 184 of file bitstream/assembler/lut/FlexLexer.h.

size_t yyFlexLexer::yy_buffer_stack_top

protected

index of top of stack.

Definition at line 183 of file bitstream/assembler/lut/FlexLexer.h.

char * yyFlexLexer::yy_c_buf_p

protected

Definition at line 173 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_did_buffer_switch_on_eof

protected

Definition at line 180 of file bitstream/assembler/lut/FlexLexer.h.

int FlexLexer::yy_flex_debug

protectedinherited

Definition at line 99 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_full_lp

protected

Definition at line 199 of file bitstream/assembler/lut/FlexLexer.h.

char * yyFlexLexer::yy_full_match

protected

Definition at line 197 of file bitstream/assembler/lut/FlexLexer.h.

int * yyFlexLexer::yy_full_state

protected

Definition at line 198 of file bitstream/assembler/lut/FlexLexer.h.

char yyFlexLexer::yy_hold_char

protected

Definition at line 167 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_init

protected

Definition at line 175 of file bitstream/assembler/lut/FlexLexer.h.

char * yyFlexLexer::yy_last_accepting_cpos

protected

Definition at line 192 of file bitstream/assembler/lut/FlexLexer.h.

yy_state_type yyFlexLexer::yy_last_accepting_state

protected

Definition at line 191 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_looking_for_trail_begin

protected

Definition at line 202 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_lp

protected

Definition at line 201 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_more_flag

protected

Definition at line 204 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_more_len

protected

Definition at line 205 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_more_offset

protected

Definition at line 206 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_n_chars

protected

Definition at line 170 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_prev_more_offset

protected

Definition at line 207 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_start

protected

Definition at line 176 of file bitstream/assembler/lut/FlexLexer.h.

int * yyFlexLexer::yy_start_stack

protected

Definition at line 153 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_start_stack_depth

protected

Definition at line 152 of file bitstream/assembler/lut/FlexLexer.h.

int yyFlexLexer::yy_start_stack_ptr

protected

Definition at line 151 of file bitstream/assembler/lut/FlexLexer.h.

yy_state_type * yyFlexLexer::yy_state_buf

protected

Definition at line 194 of file bitstream/assembler/lut/FlexLexer.h.

yy_state_type * yyFlexLexer::yy_state_ptr

protected

Definition at line 195 of file bitstream/assembler/lut/FlexLexer.h.

FLEX_STD istream * yyFlexLexer::yyin

protected

Definition at line 163 of file bitstream/assembler/lut/FlexLexer.h.

int FlexLexer::yyleng

protectedinherited

Definition at line 97 of file bitstream/assembler/lut/FlexLexer.h.

int FlexLexer::yylineno

protectedinherited

Definition at line 98 of file bitstream/assembler/lut/FlexLexer.h.

FLEX_STD ostream * yyFlexLexer::yyout

protected

Definition at line 164 of file bitstream/assembler/lut/FlexLexer.h.

char * FlexLexer::yytext

protectedinherited

Definition at line 96 of file bitstream/assembler/lut/FlexLexer.h.

---

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

• bitstream/assembler/lut/FlexLexer.h
• LutScanner.cpp
• Scanner.cc
• XdlScanner.cpp