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=0)
virtual int	yywrap ()
Public Member Functions inherited from FlexLexer
virtual	~FlexLexer ()
const char *	YYText () const
int	YYLeng () const
int	yylex (FLEX_STD istream *new_in, FLEX_STD 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, 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
Protected Attributes inherited from FlexLexer
char *	yytext
int	yyleng
int	yylineno
int	yy_flex_debug

Detailed Description

Definition at line 112 of file FlexLexer.h.

Constructor & Destructor Documentation

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

Definition at line 966 of file flex_scanner.cpp.

{
  yyin = arg_yyin;
  yyout = arg_yyout;
  yy_c_buf_p = 0;
  yy_init = 0;
  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 = NULL;

  yy_buffer_stack = 0;
  yy_buffer_stack_top = 0;
  yy_buffer_stack_max = 0;

  yy_state_buf = 0;

}

yyFlexLexer::~yyFlexLexer ( )

virtual

Definition at line 996 of file flex_scanner.cpp.

References Slamfree(), and YY_CURRENT_BUFFER.

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

Member Function Documentation

void yyFlexLexer::LexerError ( const char *  msg )

protectedvirtual

Definition at line 1658 of file flex_scanner.cpp.

References YY_EXIT_FAILURE.

{
      std::cerr << msg << std::endl;
  exit( YY_EXIT_FAILURE );
}

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

protectedvirtual

Definition at line 1021 of file flex_scanner.cpp.

Referenced by switch_streams().

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

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

protectedvirtual

Definition at line 1048 of file flex_scanner.cpp.

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

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

virtual

Implements FlexLexer.

Definition at line 1006 of file flex_scanner.cpp.

References LexerInput(), YY_BUF_SIZE, and YY_CURRENT_BUFFER.

{
  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_BUFFER_STATE yyFlexLexer::yy_create_buffer ( FLEX_STD istream *  s, int  size  )

virtual

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The character buffer size in bytes. When in doubt, use YY_BUF_SIZE.

Returns

the allocated buffer state.

Implements FlexLexer.

Definition at line 1420 of file flex_scanner.cpp.

References Slamalloc(), yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, and yy_buffer_state::yy_is_our_buffer.

{
  YY_BUFFER_STATE b;
    
  b = (YY_BUFFER_STATE) Slamalloc(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 *) Slamalloc(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;
}

void yyFlexLexer::yy_delete_buffer ( struct yy_buffer_state *  b )

virtual

Destroy the buffer.

Parameters

b	a buffer created with yy_create_buffer()

Implements FlexLexer.

Definition at line 1448 of file flex_scanner.cpp.

References isatty(), Slamfree(), yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yy_buffer_state::yy_is_our_buffer.

{
    
  if ( ! b )
    return;

  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

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

  Slamfree((void *) b  );
}

void yyFlexLexer::yy_flush_buffer ( struct yy_buffer_state *  b )

protected

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 1496 of file flex_scanner.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_CURRENT_BUFFER, 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(  );
}

int yyFlexLexer::yy_get_next_buffer ( )

protected

Definition at line 1060 of file flex_scanner.cpp.

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, Slamrealloc(), yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, yy_buffer_state::yy_n_chars, YY_READ_BUF_SIZE, and yytext_ptr.

{
      char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
  char *source = (yytext_ptr);
  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. */
          Slamrealloc((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 *) Slamrealloc((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;
}

yy_state_type yyFlexLexer::yy_get_previous_state ( )

protected

Definition at line 1194 of file flex_scanner.cpp.

References yy_accept, yy_base, yy_chk, yy_cp, yy_def, yy_ec, yy_meta, YY_MORE_ADJ, yy_nxt, YY_SC_TO_UI, 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 >= 77 )
        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

Definition at line 1469 of file flex_scanner.cpp.

References yy_buffer_state::yy_bs_column, yy_buffer_state::yy_bs_lineno, YY_CURRENT_BUFFER, yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, and yy_buffer_state::yy_is_interactive.

{
  int oerrno = errno;
    
  yy_flush_buffer( b );

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

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

  b->yy_is_interactive = 0;
  errno = oerrno;
}

void yyFlexLexer::yy_load_buffer_state ( )

protected

Definition at line 1406 of file flex_scanner.cpp.

References YY_CURRENT_BUFFER_LVALUE, yy_buffer_state::yy_n_chars, and yytext_ptr.

{
      (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_pop_state ( )

protected

Definition at line 1641 of file flex_scanner.cpp.

References BEGIN, and YY_FATAL_ERROR.

{
      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

Definition at line 1617 of file flex_scanner.cpp.

References BEGIN, Slamalloc(), Slamrealloc(), YY_FATAL_ERROR, YY_START, and YY_START_STACK_INCR.

{
      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 *) Slamalloc(new_size  );

    else
      (yy_start_stack) = (int *) Slamrealloc((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);
}

void yyFlexLexer::yy_switch_to_buffer ( struct yy_buffer_state *  new_buffer )

virtual

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Implements FlexLexer.

Definition at line 1375 of file flex_scanner.cpp.

References YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yy_buffer_state::yy_n_chars.

{
    
  /* TODO. We should be able to replace this entire function body
   * with
   *    yypop_buffer_state();
   *    yypush_buffer_state(new_buffer);
     */
  yyensure_buffer_stack ();
  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_LVALUE->yy_buf_pos = (yy_c_buf_p);
    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    }

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

int yyFlexLexer::yy_top_state ( )

protected

Definition at line 1649 of file flex_scanner.cpp.

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

yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type  current_state )

protected

Definition at line 1226 of file flex_scanner.cpp.

References yy_accept, yy_base, yy_chk, yy_def, yy_meta, and yy_nxt.

{
  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 >= 77 )
      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 == 76);

  return yy_is_jam ? 0 : yy_current_state;
}

void yyFlexLexer::yyensure_buffer_stack ( void  )

protected

Definition at line 1574 of file flex_scanner.cpp.

References Slamalloc(), Slamrealloc(), and YY_FATAL_ERROR.

{
  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**)Slamalloc
                (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**)Slamrealloc
                ((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;
  }
}

int yyFlexLexer::yyinput ( )

protected

Definition at line 1286 of file flex_scanner.cpp.

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, yy_buffer_state::yy_n_chars, YY_NEW_FILE, and yytext_ptr.

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

virtual int yyFlexLexer::yylex ( )

virtual

Implements FlexLexer.

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 1555 of file flex_scanner.cpp.

References YY_CURRENT_BUFFER, and YY_CURRENT_BUFFER_LVALUE.

{
      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

)

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters

new_buffer

The new state.

Definition at line 1525 of file flex_scanner.cpp.

References YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yy_buffer_state::yy_n_chars.

{
      if (new_buffer == NULL)
    return;

  yyensure_buffer_stack();

  /* This block is copied from yy_switch_to_buffer. */
  if ( YY_CURRENT_BUFFER )
    {
    /* Flush out information for old buffer. */
    *(yy_c_buf_p) = (yy_hold_char);
    YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
    }

  /* Only push if top exists. Otherwise, replace top. */
  if (YY_CURRENT_BUFFER)
    (yy_buffer_stack_top)++;
  YY_CURRENT_BUFFER_LVALUE = new_buffer;

  /* copied from yy_switch_to_buffer. */
  yy_load_buffer_state(  );
  (yy_did_buffer_switch_on_eof) = 1;
}

void yyFlexLexer::yyrestart ( FLEX_STD istream *  s )

virtual

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Implements FlexLexer.

Definition at line 1358 of file flex_scanner.cpp.

References YY_BUF_SIZE, YY_CURRENT_BUFFER, and YY_CURRENT_BUFFER_LVALUE.

{
    
  if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
    YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE );
  }

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

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

protected

Definition at line 1249 of file flex_scanner.cpp.

References if(), yy_buffer_state::yy_ch_buf, yy_cp, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yy_buffer_state::yy_n_chars, and yytext_ptr.

{
  char *yy_cp;
    
    yy_cp = (yy_c_buf_p);

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

  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_ch_buf[
          YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
    char *source =
        &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

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

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

    if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->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;
}

virtual int yyFlexLexer::yywrap ( )

virtual

Member Data Documentation

struct yy_buffer_state** yyFlexLexer::yy_buffer_stack

protected

Stack as an array.

Definition at line 178 of file FlexLexer.h.

size_t yyFlexLexer::yy_buffer_stack_max

protected

capacity of stack.

Definition at line 177 of file FlexLexer.h.

size_t yyFlexLexer::yy_buffer_stack_top

protected

index of top of stack.

Definition at line 176 of file FlexLexer.h.

char* yyFlexLexer::yy_c_buf_p

protected

Definition at line 166 of file FlexLexer.h.

int yyFlexLexer::yy_did_buffer_switch_on_eof

protected

Definition at line 173 of file FlexLexer.h.

int yyFlexLexer::yy_full_lp

protected

Definition at line 192 of file FlexLexer.h.

char* yyFlexLexer::yy_full_match

protected

Definition at line 190 of file FlexLexer.h.

int* yyFlexLexer::yy_full_state

protected

Definition at line 191 of file FlexLexer.h.

char yyFlexLexer::yy_hold_char

protected

Definition at line 160 of file FlexLexer.h.

int yyFlexLexer::yy_init

protected

Definition at line 168 of file FlexLexer.h.

char* yyFlexLexer::yy_last_accepting_cpos

protected

Definition at line 185 of file FlexLexer.h.

yy_state_type yyFlexLexer::yy_last_accepting_state

protected

Definition at line 184 of file FlexLexer.h.

int yyFlexLexer::yy_looking_for_trail_begin

protected

Definition at line 195 of file FlexLexer.h.

int yyFlexLexer::yy_lp

protected

Definition at line 194 of file FlexLexer.h.

int yyFlexLexer::yy_more_flag

protected

Definition at line 197 of file FlexLexer.h.

int yyFlexLexer::yy_more_len

protected

Definition at line 198 of file FlexLexer.h.

int yyFlexLexer::yy_more_offset

protected

Definition at line 199 of file FlexLexer.h.

int yyFlexLexer::yy_n_chars

protected

Definition at line 163 of file FlexLexer.h.

int yyFlexLexer::yy_prev_more_offset

protected

Definition at line 200 of file FlexLexer.h.

int yyFlexLexer::yy_start

protected

Definition at line 169 of file FlexLexer.h.

int* yyFlexLexer::yy_start_stack

protected

Definition at line 146 of file FlexLexer.h.

int yyFlexLexer::yy_start_stack_depth

protected

Definition at line 145 of file FlexLexer.h.

int yyFlexLexer::yy_start_stack_ptr

protected

Definition at line 144 of file FlexLexer.h.

yy_state_type* yyFlexLexer::yy_state_buf

protected

Definition at line 187 of file FlexLexer.h.

yy_state_type* yyFlexLexer::yy_state_ptr

protected

Definition at line 188 of file FlexLexer.h.

FLEX_STD istream* yyFlexLexer::yyin

protected

Definition at line 156 of file FlexLexer.h.

FLEX_STD ostream* yyFlexLexer::yyout

protected

Definition at line 157 of file FlexLexer.h.

---

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

• /home/xuezhisd/CLionProjects/g2o/g2o/examples/interactive_slam/slam_parser/parser/FlexLexer.h
• /home/xuezhisd/CLionProjects/g2o/g2o/examples/interactive_slam/slam_parser/parser/flex_scanner.cpp