#include <FlexLexer.h>

Inheritance diagram for yyFlexLexer:

Collaboration diagram for yyFlexLexer:

[legend]

Public Member Functions
	yyFlexLexer (std::istream &arg_yyin, std::ostream &arg_yyout)

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

virtual	~yyFlexLexer ()

void	yy_switch_to_buffer (yy_buffer_state *new_buffer)

yy_buffer_state *	yy_create_buffer (std::istream *s, int size)

yy_buffer_state *	yy_create_buffer (std::istream &s, int size)

void	yy_delete_buffer (yy_buffer_state *b)

void	yyrestart (std::istream *s)

void	yyrestart (std::istream &s)

void	yypush_buffer_state (yy_buffer_state *new_buffer)

void	yypop_buffer_state ()

virtual int	yylex ()

virtual void	switch_streams (std::istream &new_in, std::ostream &new_out)

virtual void	switch_streams (std::istream new_in=0, 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 (std::istream &new_in, std::ostream &new_out)

int	yylex (std::istream new_in, 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 (yy_buffer_state *b, std::istream &s)

void	yy_flush_buffer (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

std::istream	yyin

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

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

Private Member Functions
void	ctor_common ()

Detailed Description

Definition at line 112 of file FlexLexer.h.

Constructor & Destructor Documentation

◆ yyFlexLexer() [1/2]

yyFlexLexer::yyFlexLexer	(	std::istream &	arg_yyin,
		std::ostream &	arg_yyout
	)

Definition at line 895 of file flex_scanner.cpp.

    : yyin(arg_yyin.rdbuf()), yyout(arg_yyout.rdbuf()) {
  ctor_common();
}

References ctor_common(), and yyFlexLexer().

Referenced by yyFlexLexer(), and yyFlexLexer().

◆ yyFlexLexer() [2/2]

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

Definition at line 887 of file flex_scanner.cpp.

    : yyin(arg_yyin ? arg_yyin->rdbuf() : std::cin.rdbuf()),
      yyout(arg_yyout ? arg_yyout->rdbuf() : std::cout.rdbuf()) {
  ctor_common();
}

References ctor_common(), and yyFlexLexer().

◆ ~yyFlexLexer()

yyFlexLexer::~yyFlexLexer ( )

virtual

Definition at line 928 of file flex_scanner.cpp.

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

References yy_buffer_stack, YY_CURRENT_BUFFER, yy_delete_buffer(), yy_start_stack, yy_state_buf, yyfree, and ~yyFlexLexer().

Referenced by ~yyFlexLexer().

Member Function Documentation

◆ ctor_common()

void yyFlexLexer::ctor_common ( )

private

Definition at line 902 of file flex_scanner.cpp.

                              {
  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 = NULL;
  yy_buffer_stack_top = 0;
  yy_buffer_stack_max = 0;
 
  yy_state_buf = 0;
}

References ctor_common(), yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yy_c_buf_p, yy_did_buffer_switch_on_eof, yy_flex_debug, yy_init, yy_looking_for_trail_begin, yy_more_flag, yy_more_len, yy_more_offset, yy_prev_more_offset, yy_start, yy_start_stack, yy_start_stack_depth, yy_start_stack_ptr, yy_state_buf, and FlexLexer::yylineno.

Referenced by ctor_common(), yyFlexLexer(), and yyFlexLexer().

◆ LexerError()

void yyFlexLexer::LexerError ( const char * msg )

protectedvirtual

Definition at line 1555 of file flex_scanner.cpp.

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

References LexerError(), and YY_EXIT_FAILURE.

Referenced by LexerError(), and yywrap().

◆ LexerInput()

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

protectedvirtual

Definition at line 963 of file flex_scanner.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
}

References LexerInput().

Referenced by LexerInput(), and yywrap().

◆ LexerOutput()

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

protectedvirtual

Definition at line 987 of file flex_scanner.cpp.

                                                       {
  (void)yyout.write(buf, size);
}

References LexerOutput(), and yyout.

Referenced by LexerOutput(), and yywrap().

◆ switch_streams() [1/2]

void yyFlexLexer::switch_streams	(	std::istream &	new_in,
		std::ostream &	new_out
	)

virtual

Implements FlexLexer.

Definition at line 937 of file flex_scanner.cpp.

                                                                        {
  // was if( new_in )
  yy_delete_buffer(YY_CURRENT_BUFFER);
  yy_switch_to_buffer(yy_create_buffer(new_in, YY_BUF_SIZE));
 
  // was if( new_out )
  yyout.rdbuf(new_out.rdbuf());
}

References switch_streams(), YY_BUF_SIZE, yy_create_buffer(), YY_CURRENT_BUFFER, yy_delete_buffer(), yy_switch_to_buffer(), and yyout.

Referenced by switch_streams(), switch_streams(), and yylex().

◆ switch_streams() [2/2]

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

virtual

Implements FlexLexer.

Definition at line 948 of file flex_scanner.cpp.

                                                                        {
  if (!new_in) {
    new_in = &yyin;
  }
 
  if (!new_out) {
    new_out = &yyout;
  }
 
  switch_streams(*new_in, *new_out);
}

References switch_streams(), yyin, and yyout.

◆ yy_create_buffer() [1/2]

YY_BUFFER_STATE yyFlexLexer::yy_create_buffer	(	std::istream &	file,
		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 1331 of file flex_scanner.cpp.

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

References yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, yy_create_buffer(), YY_FATAL_ERROR, yy_init_buffer(), yy_buffer_state::yy_is_our_buffer, and yyalloc.

◆ yy_create_buffer() [2/2]

YY_BUFFER_STATE yyFlexLexer::yy_create_buffer	(	std::istream *	file,
		int	size
	)

virtual

Delegate creation of buffers to the new version that takes an istream reference.

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

                                                                        {
  return yy_create_buffer(*file, size);
}

References yy_create_buffer().

Referenced by switch_streams(), yy_create_buffer(), yy_create_buffer(), and yyrestart().

◆ yy_delete_buffer()

void yyFlexLexer::yy_delete_buffer ( yy_buffer_state * b )

virtual

Destroy the buffer.

Parameters

b	a buffer created with yy_create_buffer()

Implements FlexLexer.

Definition at line 1369 of file flex_scanner.cpp.

                                                    {
  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) yyfree((void*)b->yy_ch_buf);
 
  yyfree((void*)b);
}

References yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_buffer_state::yy_is_our_buffer, and yyfree.

Referenced by switch_streams(), yy_delete_buffer(), yypop_buffer_state(), and ~yyFlexLexer().

◆ yy_flush_buffer()

void yyFlexLexer::yy_flush_buffer ( 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 1411 of file flex_scanner.cpp.

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

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, yy_flush_buffer(), yy_load_buffer_state(), and yy_buffer_state::yy_n_chars.

Referenced by yy_flush_buffer(), yy_init_buffer(), and yywrap().

◆ yy_get_next_buffer()

int yyFlexLexer::yy_get_next_buffer ( )

protected

Definition at line 998 of file flex_scanner.cpp.

                                    {
  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_LVALUE;
 
      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. */
            yyrealloc((void*)b->yy_ch_buf, (yy_size_t)(b->yy_buf_size + 2));
      } else
        /* Can't grow it, we don't own it. */
        b->yy_ch_buf = NULL;
 
      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), 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_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
    /* Extend the array by 50%, plus the number we really need. */
    int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char*)yyrealloc(
        (void*)YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t)new_size);
    if (!YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
      YY_FATAL_ERROR("out of dynamic memory in yy_get_next_buffer()");
    /* "- 2" to take care of EOB's */
    YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int)(new_size - 2);
  }
 
  (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;
}

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yy_c_buf_p, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, yy_get_next_buffer(), YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, yy_n_chars, YY_READ_BUF_SIZE, yyin, yyrealloc, yyrestart(), and yytext_ptr.

Referenced by yy_get_next_buffer(), and yyinput().

◆ yy_get_previous_state()

yy_state_type yyFlexLexer::yy_get_previous_state ( )

protected

Definition at line 1117 of file flex_scanner.cpp.

                                                 {
  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[yy_c];
    }
    yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  }
 
  return yy_current_state;
}

References yy_accept, yy_base, yy_c_buf_p, yy_chk, yy_cp, yy_def, yy_ec, yy_get_previous_state(), yy_last_accepting_cpos, yy_last_accepting_state, yy_meta, YY_MORE_ADJ, yy_nxt, YY_SC_TO_UI, yy_start, and yytext_ptr.

Referenced by yy_get_previous_state().

◆ yy_init_buffer()

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

protected

Definition at line 1384 of file flex_scanner.cpp.

{
  int oerrno = errno;
 
  yy_flush_buffer(b);
 
  b->yy_input_file = file.rdbuf();
  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;
}

References yy_buffer_state::yy_bs_column, yy_buffer_state::yy_bs_lineno, YY_CURRENT_BUFFER, yy_buffer_state::yy_fill_buffer, yy_flush_buffer(), yy_init_buffer(), yy_buffer_state::yy_input_file, and yy_buffer_state::yy_is_interactive.

Referenced by yy_create_buffer(), yy_init_buffer(), yyrestart(), and yywrap().

◆ yy_load_buffer_state()

void yyFlexLexer::yy_load_buffer_state ( )

protected

Definition at line 1317 of file flex_scanner.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.rdbuf(YY_CURRENT_BUFFER_LVALUE->yy_input_file);
  (yy_hold_char) = *(yy_c_buf_p);
}

References yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yy_hold_char, yy_load_buffer_state(), yy_n_chars, yyin, and yytext_ptr.

Referenced by yy_flush_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), yypop_buffer_state(), yypush_buffer_state(), yyrestart(), and yywrap().

◆ yy_pop_state()

void yyFlexLexer::yy_pop_state ( )

protected

Definition at line 1540 of file flex_scanner.cpp.

                               {
  if (--(yy_start_stack_ptr) < 0)
    YY_FATAL_ERROR("start-condition stack underflow");
 
  BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
}

References BEGIN, YY_FATAL_ERROR, yy_pop_state(), yy_start_stack, and yy_start_stack_ptr.

Referenced by yy_pop_state().

◆ yy_push_state()

void yyFlexLexer::yy_push_state ( int new_state )

protected

Definition at line 1518 of file flex_scanner.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_size_t)(yy_start_stack_depth) * sizeof(int);
 
    if (!(yy_start_stack))
      (yy_start_stack) = (int*)yyalloc(new_size);
 
    else
      (yy_start_stack) = (int*)yyrealloc((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);
}

References BEGIN, YY_FATAL_ERROR, yy_push_state(), YY_START, yy_start_stack, yy_start_stack_depth, YY_START_STACK_INCR, yy_start_stack_ptr, yyalloc, and yyrealloc.

Referenced by yy_push_state().

◆ yy_switch_to_buffer()

void yyFlexLexer::yy_switch_to_buffer ( yy_buffer_state * new_buffer )

virtual

Switch to a different input buffer.

Parameters

new_buffer The new input buffer.

Implements FlexLexer.

Definition at line 1290 of file flex_scanner.cpp.

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

References yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, yy_switch_to_buffer(), and yyensure_buffer_stack().

Referenced by switch_streams(), and yy_switch_to_buffer().

◆ yy_top_state()

int yyFlexLexer::yy_top_state ( )

protected

Definition at line 1547 of file flex_scanner.cpp.

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

References yy_start_stack, yy_start_stack_ptr, and yy_top_state().

Referenced by yy_top_state().

◆ yy_try_NUL_trans()

yy_state_type yyFlexLexer::yy_try_NUL_trans ( yy_state_type current_state )

protected

Definition at line 1144 of file flex_scanner.cpp.

                                                                          {
  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[yy_c];
  }
  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  yy_is_jam = (yy_current_state == 76);
 
  return yy_is_jam ? 0 : yy_current_state;
}

References yy_accept, yy_base, yy_c_buf_p, yy_chk, yy_cp, yy_def, yy_last_accepting_cpos, yy_last_accepting_state, yy_meta, yy_nxt, and yy_try_NUL_trans().

Referenced by yy_try_NUL_trans().

◆ yyensure_buffer_stack()

void yyFlexLexer::yyensure_buffer_stack ( void )

protected

Definition at line 1479 of file flex_scanner.cpp.

                                            {
  yy_size_t 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; /* After all that talk, this was set to 1 anyways... */
    (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc(
        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. */
    yy_size_t grow_size = 8 /* arbitrary grow size */;
 
    num_to_alloc = (yy_buffer_stack_max) + grow_size;
    (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc(
        (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;
  }
}

References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, YY_FATAL_ERROR, yyalloc, yyensure_buffer_stack(), and yyrealloc.

Referenced by yy_switch_to_buffer(), yyensure_buffer_stack(), yypush_buffer_state(), and yyrestart().

◆ yyinput()

int yyFlexLexer::yyinput ( )

protected

Definition at line 1199 of file flex_scanner.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 = (int)((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 0;
 
          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;
}

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, YY_END_OF_BUFFER_CHAR, yy_get_next_buffer(), yy_hold_char, yy_n_chars, YY_NEW_FILE, yyin, yyinput(), yyrestart(), yytext_ptr, and yywrap().

Referenced by yyinput(), and yywrap().

◆ yylex()

virtual int yyFlexLexer::yylex ( )

virtual

Implements FlexLexer.

References switch_streams().

◆ 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 1463 of file flex_scanner.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;
  }
}

References yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_did_buffer_switch_on_eof, yy_load_buffer_state(), and yypop_buffer_state().

Referenced by yypop_buffer_state().

◆ yypush_buffer_state()

void yyFlexLexer::yypush_buffer_state ( 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 1437 of file flex_scanner.cpp.

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

References yy_buffer_stack_top, yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, yyensure_buffer_stack(), and yypush_buffer_state().

Referenced by yypush_buffer_state().

◆ yyrestart() [1/2]

void yyFlexLexer::yyrestart ( std::istream & input_file )

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

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

References YY_BUF_SIZE, yy_create_buffer(), YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init_buffer(), yy_load_buffer_state(), yyensure_buffer_stack(), yyin, and yyrestart().

◆ yyrestart() [2/2]

void yyFlexLexer::yyrestart ( std::istream * input_file )

virtual

Delegate to the new version that takes an istream reference.

Parameters

input_file A readable stream.

Note: This function does not reset the start condition to INITIAL .

Implements FlexLexer.

Definition at line 1279 of file flex_scanner.cpp.

                                                  {
  if (!input_file) {
    input_file = &yyin;
  }
  yyrestart(*input_file);
}

References yyin, and yyrestart().

Referenced by yy_get_next_buffer(), yyinput(), yyrestart(), and yyrestart().

◆ yyunput()

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

protected

Definition at line 1164 of file flex_scanner.cpp.

                                            {
  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) =
        (int)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;
}

References yy_bp, yy_c_buf_p, yy_cp, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yy_hold_char, yy_n_chars, yytext_ptr, and yyunput().

Referenced by yyunput(), and yywrap().

◆ yywrap()

virtual int yyFlexLexer::yywrap ( )

virtual

References LexerError(), LexerInput(), LexerOutput(), yy_flush_buffer(), yy_init_buffer(), yy_load_buffer_state(), yyinput(), and yyunput().

Referenced by yyinput().

Member Data Documentation

◆ yy_buffer_stack

yy_buffer_state** yyFlexLexer::yy_buffer_stack

protected

Stack as an array.

Definition at line 186 of file FlexLexer.h.

Referenced by ctor_common(), yyensure_buffer_stack(), and ~yyFlexLexer().

◆ yy_buffer_stack_max

size_t yyFlexLexer::yy_buffer_stack_max

protected

capacity of stack.

Definition at line 185 of file FlexLexer.h.

Referenced by ctor_common(), and yyensure_buffer_stack().

◆ yy_buffer_stack_top

size_t yyFlexLexer::yy_buffer_stack_top

protected

index of top of stack.

Definition at line 184 of file FlexLexer.h.

Referenced by ctor_common(), yyensure_buffer_stack(), yypop_buffer_state(), and yypush_buffer_state().

◆ yy_c_buf_p

char* yyFlexLexer::yy_c_buf_p

protected

Definition at line 175 of file FlexLexer.h.

Referenced by ctor_common(), yy_get_next_buffer(), yy_get_previous_state(), yy_load_buffer_state(), yy_switch_to_buffer(), yy_try_NUL_trans(), yyinput(), yypush_buffer_state(), and yyunput().

◆ yy_did_buffer_switch_on_eof

int yyFlexLexer::yy_did_buffer_switch_on_eof

protected

Definition at line 182 of file FlexLexer.h.

Referenced by ctor_common(), yy_switch_to_buffer(), yyinput(), yypop_buffer_state(), and yypush_buffer_state().

◆ yy_full_lp

int yyFlexLexer::yy_full_lp

protected

Definition at line 200 of file FlexLexer.h.

◆ yy_full_match

char* yyFlexLexer::yy_full_match

protected

Definition at line 198 of file FlexLexer.h.

◆ yy_full_state

int* yyFlexLexer::yy_full_state

protected

Definition at line 199 of file FlexLexer.h.

◆ yy_hold_char

char yyFlexLexer::yy_hold_char

protected

Definition at line 169 of file FlexLexer.h.

Referenced by yy_load_buffer_state(), yy_switch_to_buffer(), yyinput(), yypush_buffer_state(), and yyunput().

◆ yy_init

int yyFlexLexer::yy_init

protected

Definition at line 177 of file FlexLexer.h.

Referenced by ctor_common().

◆ yy_last_accepting_cpos

char* yyFlexLexer::yy_last_accepting_cpos

protected

Definition at line 193 of file FlexLexer.h.

Referenced by yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_last_accepting_state

yy_state_type yyFlexLexer::yy_last_accepting_state

protected

Definition at line 192 of file FlexLexer.h.

Referenced by yy_get_previous_state(), and yy_try_NUL_trans().

◆ yy_looking_for_trail_begin

int yyFlexLexer::yy_looking_for_trail_begin

protected

Definition at line 203 of file FlexLexer.h.

Referenced by ctor_common().

◆ yy_lp

int yyFlexLexer::yy_lp

protected

Definition at line 202 of file FlexLexer.h.

◆ yy_more_flag

int yyFlexLexer::yy_more_flag

protected

Definition at line 205 of file FlexLexer.h.

Referenced by ctor_common().

◆ yy_more_len

int yyFlexLexer::yy_more_len

protected

Definition at line 206 of file FlexLexer.h.

Referenced by ctor_common().

◆ yy_more_offset

int yyFlexLexer::yy_more_offset

protected

Definition at line 207 of file FlexLexer.h.

Referenced by ctor_common().

◆ yy_n_chars

int yyFlexLexer::yy_n_chars

protected

Definition at line 172 of file FlexLexer.h.

Referenced by yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), yyinput(), yypush_buffer_state(), and yyunput().

◆ yy_prev_more_offset

int yyFlexLexer::yy_prev_more_offset

protected

Definition at line 208 of file FlexLexer.h.

Referenced by ctor_common().

◆ yy_start

int yyFlexLexer::yy_start

protected

Definition at line 178 of file FlexLexer.h.

Referenced by ctor_common(), and yy_get_previous_state().

◆ yy_start_stack

int* yyFlexLexer::yy_start_stack

protected

Definition at line 155 of file FlexLexer.h.

Referenced by ctor_common(), yy_pop_state(), yy_push_state(), yy_top_state(), and ~yyFlexLexer().

◆ yy_start_stack_depth

int yyFlexLexer::yy_start_stack_depth

protected

Definition at line 154 of file FlexLexer.h.

Referenced by ctor_common(), and yy_push_state().

◆ yy_start_stack_ptr

int yyFlexLexer::yy_start_stack_ptr

protected

Definition at line 153 of file FlexLexer.h.

Referenced by ctor_common(), yy_pop_state(), yy_push_state(), and yy_top_state().

◆ yy_state_buf

yy_state_type* yyFlexLexer::yy_state_buf

protected

Definition at line 195 of file FlexLexer.h.

Referenced by ctor_common(), and ~yyFlexLexer().

◆ yy_state_ptr

yy_state_type* yyFlexLexer::yy_state_ptr

protected

Definition at line 196 of file FlexLexer.h.

◆ yyin

std::istream yyFlexLexer::yyin

protected

Definition at line 165 of file FlexLexer.h.

Referenced by switch_streams(), yy_get_next_buffer(), yy_load_buffer_state(), yyinput(), yyrestart(), and yyrestart().

◆ yyout

std::ostream yyFlexLexer::yyout

protected

Definition at line 166 of file FlexLexer.h.

Referenced by LexerOutput(), switch_streams(), and switch_streams().

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

/build/reproducible-path/g2o-0~20230806/g2o/examples/interactive_slam/slam_parser/parser/FlexLexer.h
/build/reproducible-path/g2o-0~20230806/g2o/examples/interactive_slam/slam_parser/parser/flex_scanner.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ yyFlexLexer() [1/2]

◆ yyFlexLexer() [2/2]

◆ ~yyFlexLexer()

Member Function Documentation

◆ ctor_common()

◆ LexerError()

◆ LexerInput()

◆ LexerOutput()

◆ switch_streams() [1/2]

◆ switch_streams() [2/2]

◆ yy_create_buffer() [1/2]

◆ yy_create_buffer() [2/2]

◆ yy_delete_buffer()

◆ yy_flush_buffer()

◆ yy_get_next_buffer()

◆ yy_get_previous_state()

◆ yy_init_buffer()

◆ yy_load_buffer_state()

◆ yy_pop_state()

◆ yy_push_state()

◆ yy_switch_to_buffer()

◆ yy_top_state()

◆ yy_try_NUL_trans()

◆ yyensure_buffer_stack()

◆ yyinput()

◆ yylex()

◆ yypop_buffer_state()

◆ yypush_buffer_state()

◆ yyrestart() [1/2]

◆ yyrestart() [2/2]

◆ yyunput()

◆ yywrap()

Member Data Documentation

◆ yy_buffer_stack

◆ yy_buffer_stack_max

◆ yy_buffer_stack_top

◆ yy_c_buf_p

◆ yy_did_buffer_switch_on_eof

◆ yy_full_lp

◆ yy_full_match

◆ yy_full_state

◆ yy_hold_char

◆ yy_init

◆ yy_last_accepting_cpos

◆ yy_last_accepting_state

◆ yy_looking_for_trail_begin

◆ yy_lp

◆ yy_more_flag

◆ yy_more_len

◆ yy_more_offset

◆ yy_n_chars

◆ yy_prev_more_offset

◆ yy_start

◆ yy_start_stack

◆ yy_start_stack_depth

◆ yy_start_stack_ptr

◆ yy_state_buf

◆ yy_state_ptr

◆ yyin

◆ yyout