CEvaluationLexer Class Reference

#include <CEvaluationLexer.h>

Inheritance diagram for CEvaluationLexer:

Collaboration diagram for CEvaluationLexer:

Public Member Functions
	CEvaluationLexer (FLEX_STD istream *arg_yyin=0, FLEX_STD ostream *arg_yyout=0)
virtual void	switch_streams (FLEX_STD istream *new_in, FLEX_STD ostream *new_out)
struct yy_buffer_state *	yy_create_buffer (FLEX_STD istream *s, int size)
void	yy_delete_buffer (struct yy_buffer_state *b)
void	yy_switch_to_buffer (struct yy_buffer_state *new_buffer)
virtual int	yylex ()
void	yypop_buffer_state (void)
void	yypush_buffer_state (struct yy_buffer_state *new_buffer)
void	yyrestart (FLEX_STD istream *s)
virtual int	yywrap ()
virtual	~CEvaluationLexer ()
Public Member Functions inherited from FlexLexer
int	debug () const
int	lineno () const
void	set_debug (int flag)
virtual void	switch_streams (std::istream *new_in=0, std::ostream *new_out=0)=0
virtual struct yy_buffer_state *	yy_create_buffer (std::istream *s, int size)=0
int	YYLeng () const
int	yylex (std::istream *new_in, std::ostream *new_out=0)
virtual void	yyrestart (std::istream *s)=0
const char *	YYText () const
virtual	~FlexLexer ()
Public Member Functions inherited from CEvaluationParserBase
	CEvaluationParserBase ()
size_t	getErrorPosition ()
std::vector< CEvaluationNode * > *	getNodeList ()
CEvaluationNode *	getRootNode ()
bool	isBoolean () const
virtual int	yyparse ()
virtual	~CEvaluationParserBase ()

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

Protected Attributes
struct yy_buffer_state **	yy_buffer_stack
size_t	yy_buffer_stack_max
size_t	yy_buffer_stack_top
char *	yy_c_buf_p
struct yy_buffer_state *	yy_current_buffer
int	yy_did_buffer_switch_on_eof
int	yy_full_lp
char *	yy_full_match
int *	yy_full_state
char	yy_hold_char
int	yy_init
char *	yy_last_accepting_cpos
yy_state_type	yy_last_accepting_state
int	yy_looking_for_trail_begin
int	yy_lp
int	yy_more_flag
int	yy_more_len
int	yy_more_offset
int	yy_n_chars
int	yy_prev_more_offset
int	yy_start
int *	yy_start_stack
int	yy_start_stack_depth
int	yy_start_stack_ptr
yy_state_type *	yy_state_buf
yy_state_type *	yy_state_ptr
std::istream *	yyin
std::ostream *	yyout
Protected Attributes inherited from FlexLexer
int	yy_flex_debug
int	yyleng
int	yylineno
char *	yytext
Protected Attributes inherited from CEvaluationParserBase
bool	mBoolean
CEvaluationNode *	mpNode
std::vector< CEvaluationNode * > *	mpNodeList
size_t	mPosition
CEvaluationNode *	mpRootNode

Additional Inherited Members
Static Public Member Functions inherited from CEvaluationParserBase
static void	freeNodeList (std::vector< CEvaluationNode * > *pNodeList)

Detailed Description

Definition at line 125 of file CEvaluationLexer.h.

Constructor & Destructor Documentation

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

Definition at line 2042 of file CEvaluationLexer_lex.cpp.

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

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

CEvaluationLexer::~CEvaluationLexer ( )

virtual

Definition at line 2071 of file CEvaluationLexer_lex.cpp.

References CEvaluationfree(), yyFlexLexer::yy_buffer_stack, YY_CURRENT_BUFFER, yyFlexLexer::yy_delete_buffer(), yyFlexLexer::yy_start_stack, and yyFlexLexer::yy_state_buf.

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

Member Function Documentation

void CEvaluationLexer::LexerError ( const char *  msg )

protectedvirtual

Definition at line 2758 of file CEvaluationLexer_lex.cpp.

References YY_EXIT_FAILURE.

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

size_t CEvaluationLexer::LexerInput ( char *  buf, size_t  max_size  )

protectedvirtual

Definition at line 2096 of file CEvaluationLexer_lex.cpp.

References void().

{
  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 CEvaluationLexer::LexerOutput ( const char *  buf, size_t  size  )

protectedvirtual

Definition at line 2124 of file CEvaluationLexer_lex.cpp.

References void(), and yyFlexLexer::yyout.

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

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

virtual

Definition at line 2081 of file CEvaluationLexer_lex.cpp.

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

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

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.

Definition at line 2512 of file CEvaluationLexer_lex.cpp.

References CEvaluationalloc(), yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, yyFlexLexer::yy_init_buffer(), and yy_buffer_state::yy_is_our_buffer.

{
  YY_BUFFER_STATE b;

  b = (YY_BUFFER_STATE) CEvaluationalloc(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 *) CEvaluationalloc(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 CEvaluationLexer::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 2542 of file CEvaluationLexer_lex.cpp.

References CEvaluationfree(), 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)
    CEvaluationfree((void *) b->yy_ch_buf);

  CEvaluationfree((void *) b);
}

void CEvaluationLexer::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 2589 of file CEvaluationLexer_lex.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, yyFlexLexer::yy_load_buffer_state(), 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 CEvaluationLexer::yy_get_next_buffer ( )

protected

Definition at line 2136 of file CEvaluationLexer_lex.cpp.

References CEvaluationrealloc(), EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yyFlexLexer::yy_c_buf_p, 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, yyFlexLexer::yy_n_chars, YY_READ_BUF_SIZE, yyFlexLexer::yyin, yyFlexLexer::yyrestart(), and yytext_ptr.

{
  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
    {
      yy_size_t 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)
            {
              yy_size_t 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. */
                             CEvaluationrealloc((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), 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 *) CEvaluationrealloc((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 CEvaluationLexer::yy_get_previous_state ( )

protected

Definition at line 2273 of file CEvaluationLexer_lex.cpp.

References yy_accept, yy_base, yyFlexLexer::yy_c_buf_p, yy_chk, yy_def, yy_ec, yyFlexLexer::yy_last_accepting_cpos, yyFlexLexer::yy_last_accepting_state, yy_meta, YY_MORE_ADJ, yy_nxt, YY_SC_TO_UI, yyFlexLexer::yy_start, and yytext_ptr.

{
  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 >= 380)
            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 CEvaluationLexer::yy_init_buffer ( struct yy_buffer_state *  b, std::istream *  s  )

protected

Definition at line 2561 of file CEvaluationLexer_lex.cpp.

References yy_buffer_state::yy_bs_column, yy_buffer_state::yy_bs_lineno, YY_CURRENT_BUFFER, yy_buffer_state::yy_fill_buffer, yyFlexLexer::yy_flush_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 CEvaluationLexer::yy_load_buffer_state ( )

protected

Definition at line 2498 of file CEvaluationLexer_lex.cpp.

References yyFlexLexer::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yyFlexLexer::yy_hold_char, yyFlexLexer::yy_n_chars, yyFlexLexer::yyin, 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 CEvaluationLexer::yy_pop_state ( )

protected

Definition at line 2741 of file CEvaluationLexer_lex.cpp.

References BEGIN, YY_FATAL_ERROR, yyFlexLexer::yy_start_stack, and yyFlexLexer::yy_start_stack_ptr.

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

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

void CEvaluationLexer::yy_push_state ( int  new_state )

protected

Definition at line 2717 of file CEvaluationLexer_lex.cpp.

References BEGIN, CEvaluationalloc(), CEvaluationrealloc(), YY_FATAL_ERROR, YY_START, yyFlexLexer::yy_start_stack, yyFlexLexer::yy_start_stack_depth, YY_START_STACK_INCR, and yyFlexLexer::yy_start_stack_ptr.

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

      else
        (yy_start_stack) = (int *) CEvaluationrealloc((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 CEvaluationLexer::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 2466 of file CEvaluationLexer_lex.cpp.

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

{

  /* 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 CEvaluationLexer::yy_top_state ( )

protected

Definition at line 2749 of file CEvaluationLexer_lex.cpp.

References yyFlexLexer::yy_start_stack, and yyFlexLexer::yy_start_stack_ptr.

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

yy_state_type CEvaluationLexer::yy_try_NUL_trans ( yy_state_type  current_state )

protected

Definition at line 2309 of file CEvaluationLexer_lex.cpp.

References yy_accept, yy_base, yyFlexLexer::yy_c_buf_p, yy_chk, yy_def, yyFlexLexer::yy_last_accepting_cpos, yyFlexLexer::yy_last_accepting_state, yy_meta, and yy_nxt.

{
  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 >= 380)
        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 == 379);

  return yy_is_jam ? 0 : yy_current_state;
}

void CEvaluationLexer::yyensure_buffer_stack ( void  )

protected

Definition at line 2670 of file CEvaluationLexer_lex.cpp.

References CEvaluationalloc(), CEvaluationrealloc(), yyFlexLexer::yy_buffer_stack, yyFlexLexer::yy_buffer_stack_max, yyFlexLexer::yy_buffer_stack_top, and YY_FATAL_ERROR.

{
  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;
      (yy_buffer_stack) = (struct yy_buffer_state**)CEvaluationalloc
                          (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**)CEvaluationrealloc
                          ((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 CEvaluationLexer::yyinput ( )

protected

Definition at line 2374 of file CEvaluationLexer_lex.cpp.

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

{
  int c;

  *(yy_c_buf_p) = (yy_hold_char);

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

      else
        {
          /* need more input */
          yy_size_t 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 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;
}

int CEvaluationLexer::yylex ( )

virtual

The main scanner function which does all the work.

Implements FlexLexer.

Definition at line 858 of file CEvaluationLexer_lex.cpp.

References CEvaluationNodeConstant::_INFINITY, CEvaluationNodeConstant::_NaN, CEvaluationNodeFunction::ABS, CEvaluationNodeLogical::AND, CEvaluationNodeVariable::ANY, CEvaluationNodeFunction::ARCCOS, CEvaluationNodeFunction::ARCCOSH, CEvaluationNodeFunction::ARCCOT, CEvaluationNodeFunction::ARCCOTH, CEvaluationNodeFunction::ARCCSC, CEvaluationNodeFunction::ARCCSCH, CEvaluationNodeFunction::ARCSEC, CEvaluationNodeFunction::ARCSECH, CEvaluationNodeFunction::ARCSIN, CEvaluationNodeFunction::ARCSINH, CEvaluationNodeFunction::ARCTAN, CEvaluationNodeFunction::ARCTANH, BEGIN, CEvaluationNodeFunction::CEIL, CEvaluationNodeObject::CN, COMMON_ACTION, CEvaluationNodeFunction::COS, CEvaluationNodeFunction::COSH, CEvaluationNodeFunction::COT, CEvaluationNodeFunction::COTH, CEvaluationNodeFunction::CSC, CEvaluationNodeFunction::CSCH, CEvaluationNodeDelay::DELAY, CEvaluationNodeOperator::DIVIDE, CEvaluationNodeNumber::DOUBLE, ECHO, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, CEvaluationNodeLogical::EQ, CCopasiMessage::ERROR, CEvaluationNodeFunction::EXP, CEvaluationNodeConstant::EXPONENTIALE, CEvaluationNodeCall::EXPRESSION, CEvaluationNodeFunction::FACTORIAL, CEvaluationNodeConstant::FALSE, CEvaluationNodeFunction::FLOOR, CEvaluationNodeCall::FUNCTION, CEvaluationNodeLogical::GE, CEvaluationNodeLogical::GT, CEvaluationNodeChoice::IF, INITIAL, CEvaluationNodeLogical::LE, CEvaluationNodeFunction::LOG, CEvaluationNodeFunction::LOG10, CEvaluationNodeLogical::LT, CEvaluationNodeFunction::MAX, MCFunction, CEvaluationNodeFunction::MIN, CEvaluationNodeOperator::MINUS, CEvaluationNodeFunction::MINUS, CEvaluationNodeOperator::MODULUS, mpNode, CEvaluationNodeOperator::MULTIPLY, CEvaluationNodeLogical::NE, CEvaluationNodeFunction::NOT, CEvaluationNodeLogical::OR, CEvaluationNodeConstant::PI, CEvaluationNodeOperator::PLUS, CEvaluationNodeFunction::PLUS, CEvaluationNodeObject::POINTER, CEvaluationNodeOperator::POWER, CEvaluationNodeFunction::RGAMMA, CEvaluationNodeFunction::RNORMAL, CEvaluationNodeFunction::RPOISSON, CEvaluationNodeFunction::RUNIFORM, CEvaluationNodeFunction::SEC, CEvaluationNodeFunction::SECH, CEvaluationNodeFunction::SIN, CEvaluationNodeFunction::SINH, sOPERATOR, CEvaluationNodeFunction::SQRT, sSIGNorVALUE, sVALUE, CEvaluationNodeFunction::TAN, CEvaluationNodeFunction::TANH, TOKEN_CALL, TOKEN_FUNCTION, TOKEN_FUNCTION_2, TOKEN_LOGICAL_AND, TOKEN_LOGICAL_CHOICE, TOKEN_LOGICAL_EQ, TOKEN_LOGICAL_GE, TOKEN_LOGICAL_GT, TOKEN_LOGICAL_LE, TOKEN_LOGICAL_LT, TOKEN_LOGICAL_NE, TOKEN_LOGICAL_NOT, TOKEN_LOGICAL_OR, TOKEN_LOGICAL_VALUE, TOKEN_LOGICAL_XOR, TOKEN_NUMBER, TOKEN_OPERATOR_MODULUS, TOKEN_OPERATOR_MULTIPLY, TOKEN_OPERATOR_PLUS, TOKEN_OPERATOR_POWER, TOKEN_SIGN, TOKEN_STRUCTURE_CLOSE, TOKEN_STRUCTURE_COMMA, TOKEN_STRUCTURE_OPEN, TOKEN_STRUCTURE_VECTOR_CLOSE, TOKEN_STRUCTURE_VECTOR_OPEN, TOKEN_VARIABLE, CEvaluationNodeConstant::TRUE, CEvaluationNodeLogical::XOR, yy_accept, yy_base, YY_BREAK, YY_BUF_SIZE, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_chk, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_def, YY_DO_BEFORE_ACTION, yy_ec, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_meta, YY_MORE_ADJ, YY_NEW_FILE, yy_nxt, YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, YY_STATE_EOF, YY_USER_INIT, YYERRCODE, yyleng, and yytext_ptr.

{
  register yy_state_type yy_current_state;
  register char *yy_cp, *yy_bp;
  register int yy_act;

#line 36 "function/CEvaluationLexer.lpp"

#line 849 "<stdout>"

  if (!(yy_init))
    {
      (yy_init) = 1;

#ifdef YY_USER_INIT
      YY_USER_INIT;
#endif

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

      if (! yyin)
        yyin = & std::cin;

      if (! yyout)
        yyout = & std::cout;

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

      yy_load_buffer_state();
    }

  while (1)      /* loops until end-of-file is reached */
    {
      yy_cp = (yy_c_buf_p);

      /* Support of yytext. */
      *yy_cp = (yy_hold_char);

      /* yy_bp points to the position in yy_ch_buf of the start of
       * the current run.
       */
      yy_bp = yy_cp;

      yy_current_state = (yy_start);
yy_match:

      do
        {
          register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];

          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 >= 380)
                yy_c = yy_meta[(unsigned int) yy_c];
            }

          yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
          ++yy_cp;
        }
      while (yy_current_state != 379);

      yy_cp = (yy_last_accepting_cpos);
      yy_current_state = (yy_last_accepting_state);

yy_find_action:
      yy_act = yy_accept[yy_current_state];

      YY_DO_BEFORE_ACTION;

do_action:  /* This label is used only to access EOF actions. */

      switch (yy_act)
        {
            /* beginning of action switch */
          case 0: /* must back up */
            /* undo the effects of YY_DO_BEFORE_ACTION */
            *yy_cp = (yy_hold_char);
            yy_cp = (yy_last_accepting_cpos);
            yy_current_state = (yy_last_accepting_state);
            goto yy_find_action;

          case 1:
            YY_RULE_SETUP
#line 37 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE,
                                               yytext);
            COMMON_ACTION;
            return TOKEN_NUMBER;

            YY_BREAK
          case 2:
            YY_RULE_SETUP
#line 45 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::EXPONENTIALE,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_NUMBER;

            YY_BREAK
          case 3:
            YY_RULE_SETUP
#line 53 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::PI,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_NUMBER;

            YY_BREAK
          case 4:
            YY_RULE_SETUP
#line 61 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::TRUE,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_VALUE;

            YY_BREAK
          case 5:
            YY_RULE_SETUP
#line 69 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::FALSE,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_VALUE;

            YY_BREAK
          case 6:
            YY_RULE_SETUP
#line 77 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_NUMBER;

            YY_BREAK
          case 7:
            YY_RULE_SETUP
#line 85 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_NUMBER;

            YY_BREAK
          case 8:
            YY_RULE_SETUP
#line 93 "function/CEvaluationLexer.lpp"

            BEGIN(sVALUE);
            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::NOT,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_NOT;

            YY_BREAK
          case 9:
            YY_RULE_SETUP
#line 101 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::LE,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_LE;

            YY_BREAK
          case 10:
            YY_RULE_SETUP
#line 109 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::LT,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_LT;

            YY_BREAK
          case 11:
            YY_RULE_SETUP
#line 117 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::GE,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_GE;

            YY_BREAK
          case 12:
            YY_RULE_SETUP
#line 125 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::GT,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_GT;

            YY_BREAK
          case 13:
            YY_RULE_SETUP
#line 133 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::NE,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_NE;

            YY_BREAK
          case 14:
            YY_RULE_SETUP
#line 141 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::EQ,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_EQ;

            YY_BREAK
          case 15:
            YY_RULE_SETUP
#line 149 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::AND,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_AND;

            YY_BREAK
          case 16:
            YY_RULE_SETUP
#line 157 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::XOR,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_XOR;

            YY_BREAK
          case 17:
            YY_RULE_SETUP
#line 165 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::OR,
                                                yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_OR;

            YY_BREAK
          case 18:
            /* rule 18 can match eol */
            YY_RULE_SETUP
#line 173 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeObject(CEvaluationNodeObject::CN,
                                               yytext);
            COMMON_ACTION;
            return TOKEN_NUMBER;

            YY_BREAK
          case 19:
            YY_RULE_SETUP
#line 181 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeObject(CEvaluationNodeObject::POINTER,
                                               yytext);
            COMMON_ACTION;
            return TOKEN_NUMBER;

            YY_BREAK
          case 20:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 189 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::LOG,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 21:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 196 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::LOG10,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 22:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 203 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::EXP,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 23:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 210 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SIN,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 24:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 217 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 25:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 224 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::TAN,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 26:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 231 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SEC,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 27:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 238 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::CSC,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 28:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 245 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COT,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 29:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 252 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SINH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 30:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 259 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COSH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 31:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 266 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::TANH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 32:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 273 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SECH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 33:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 280 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::CSCH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 34:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 287 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COTH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 35:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 294 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSIN,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 36:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 301 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 37:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 308 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCTAN,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 38:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 315 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSEC,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 39:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 322 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCSC,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 40:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 329 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOT,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 41:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 336 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSINH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 42:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 343 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOSH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 43:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 350 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCTANH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 44:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 357 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSECH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 45:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 364 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCSCH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 46:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 371 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOTH,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 47:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 378 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SQRT,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 48:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 385 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ABS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 49:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 392 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::FLOOR,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 50:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 399 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::CEIL,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 51:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 406 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::FACTORIAL,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 52:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 413 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RUNIFORM,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION_2;

            YY_BREAK
          case 53:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 420 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RGAMMA,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION_2;

            YY_BREAK
          case 54:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 427 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RPOISSON,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION;

            YY_BREAK
          case 55:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 434 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RNORMAL,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION_2;

            YY_BREAK
          case 56:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 441 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MAX,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION_2;

            YY_BREAK
          case 57:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 448 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MIN,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION_2;

            YY_BREAK
          case 58:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 455 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeDelay(CEvaluationNodeDelay::DELAY,
                                              yytext);
            COMMON_ACTION;
            return TOKEN_FUNCTION_2;

            YY_BREAK
          case 59:
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 462 "function/CEvaluationLexer.lpp"

            mpNode = new CEvaluationNodeChoice(CEvaluationNodeChoice::IF,
                                               yytext);
            COMMON_ACTION;
            return TOKEN_LOGICAL_CHOICE;

            YY_BREAK
          case 60:
            /* rule 60 can match eol */
            *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
            (yy_c_buf_p) = yy_cp -= 1;
            YY_DO_BEFORE_ACTION; /* set up yytext again */
            YY_RULE_SETUP
#line 469 "function/CEvaluationLexer.lpp"

            {
              std::string tmp(yytext);
              mpNode = new CEvaluationNodeCall(CEvaluationNodeCall::EXPRESSION,
              tmp.substr(0, tmp.length() - 1));
            }
            COMMON_ACTION;
            return TOKEN_CALL;

            YY_BREAK
          case 61:
            /* rule 61 can match eol */
            YY_RULE_SETUP
#line 479 "function/CEvaluationLexer.lpp"

            {
              std::string tmp(yytext);
              mpNode = new CEvaluationNodeCall(CEvaluationNodeCall::FUNCTION,
              tmp.substr(0, tmp.length() - 1));
            }
            COMMON_ACTION;
            return TOKEN_CALL;

            YY_BREAK
          case 62:
            YY_RULE_SETUP
#line 489 "function/CEvaluationLexer.lpp"

            BEGIN(sVALUE);
            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_SIGN;

            YY_BREAK
          case 63:
            YY_RULE_SETUP
#line 497 "function/CEvaluationLexer.lpp"

            BEGIN(sVALUE);
            mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::PLUS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_SIGN;

            YY_BREAK
          case 64:
            YY_RULE_SETUP
#line 505 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_OPERATOR_POWER;

            YY_BREAK
          case 65:
            YY_RULE_SETUP
#line 513 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_OPERATOR_MULTIPLY;

            YY_BREAK
          case 66:
            YY_RULE_SETUP
#line 521 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_OPERATOR_MULTIPLY;

            YY_BREAK
          case 67:
            YY_RULE_SETUP
#line 529 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MODULUS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_OPERATOR_MODULUS;

            YY_BREAK
          case 68:
            YY_RULE_SETUP
#line 537 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::PLUS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_OPERATOR_PLUS;

            YY_BREAK
          case 69:
            YY_RULE_SETUP
#line 545 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_OPERATOR_PLUS;

            YY_BREAK
          case 70:
            YY_RULE_SETUP
#line 553 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mPosition += yyleng;
            // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::OPEN,
            //                                       yytext);
            // COMMON_ACTION;
            return TOKEN_STRUCTURE_OPEN;

            YY_BREAK
          case 71:
            YY_RULE_SETUP
#line 562 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mPosition += yyleng;
            // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::VECTOR_OPEN,
            //                                       yytext);
            // COMMON_ACTION;
            return TOKEN_STRUCTURE_VECTOR_OPEN;

            YY_BREAK
          case 72:
            YY_RULE_SETUP
#line 571 "function/CEvaluationLexer.lpp"

            BEGIN(sSIGNorVALUE);
            mPosition += yyleng;
            // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::COMMA,
            //                                       yytext);
            // COMMON_ACTION;
            return TOKEN_STRUCTURE_COMMA;

            YY_BREAK
          case 73:
            YY_RULE_SETUP
#line 580 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mPosition += yyleng;
            // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::CLOSE,
            //                                       yytext);
            // COMMON_ACTION;
            return TOKEN_STRUCTURE_CLOSE;

            YY_BREAK
          case 74:
            YY_RULE_SETUP
#line 589 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mPosition += yyleng;
            // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::VECTOR_CLOSE,
            //                                       yytext);
            // COMMON_ACTION;
            return TOKEN_STRUCTURE_VECTOR_CLOSE;

            YY_BREAK
          case 75:
            /* rule 75 can match eol */
            YY_RULE_SETUP
#line 598 "function/CEvaluationLexer.lpp"

            BEGIN(sOPERATOR);
            mpNode = new CEvaluationNodeVariable(CEvaluationNodeVariable::ANY,
                                                 yytext);
            COMMON_ACTION;
            return TOKEN_VARIABLE;

            YY_BREAK
          case 76:
            /* rule 76 can match eol */
            YY_RULE_SETUP
#line 606 "function/CEvaluationLexer.lpp"

            mPosition += yyleng;
            // mpNode = new CEvaluationNodeWhiteSpace(CEvaluationNodeWhiteSpace::ANY,
            //                                        yytext);
            // COMMON_ACTION;

            YY_BREAK
          case YY_STATE_EOF(INITIAL):
          case YY_STATE_EOF(sSIGNorVALUE):
          case YY_STATE_EOF(sOPERATOR):
          case YY_STATE_EOF(sVALUE):
#line 613 "function/CEvaluationLexer.lpp"
            return 0;
            YY_BREAK
          case 77:
            YY_RULE_SETUP
#line 615 "function/CEvaluationLexer.lpp"

            CCopasiMessage(CCopasiMessage::ERROR, MCFunction + 2, mPosition);
            return YYERRCODE;

            YY_BREAK
          case 78:
            YY_RULE_SETUP
#line 620 "function/CEvaluationLexer.lpp"
            ECHO;
            YY_BREAK
#line 1880 "<stdout>"

          case YY_END_OF_BUFFER:
          {
            /* Amount of text matched not including the EOB char. */
            int yy_amount_of_matched_text = (int)(yy_cp - (yytext_ptr)) - 1;

            /* Undo the effects of YY_DO_BEFORE_ACTION. */
            *yy_cp = (yy_hold_char);
            YY_RESTORE_YY_MORE_OFFSET

            if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW)
              {
                /* We're scanning a new file or input source.  It's
                 * possible that this happened because the user
                 * just pointed yyin at a new source and called
                 * yylex().  If so, then we have to assure
                 * consistency between YY_CURRENT_BUFFER and our
                 * globals.  Here is the right place to do so, because
                 * this is the first action (other than possibly a
                 * back-up) that will match for the new input source.
                 */
                (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
                YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
                YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
              }

            /* Note that here we test for yy_c_buf_p "<=" to the position
             * of the first EOB in the buffer, since yy_c_buf_p will
             * already have been incremented past the NUL character
             * (since all states make transitions on EOB to the
             * end-of-buffer state).  Contrast this with the test
             * in input().
             */
            if ((yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)])
              {
                /* This was really a NUL. */
                yy_state_type yy_next_state;

                (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

                yy_current_state = yy_get_previous_state();

                /* Okay, we're now positioned to make the NUL
                 * transition.  We couldn't have
                 * yy_get_previous_state() go ahead and do it
                 * for us because it doesn't know how to deal
                 * with the possibility of jamming (and we don't
                 * want to build jamming into it because then it
                 * will run more slowly).
                 */

                yy_next_state = yy_try_NUL_trans(yy_current_state);

                yy_bp = (yytext_ptr) + YY_MORE_ADJ;

                if (yy_next_state)
                  {
                    /* Consume the NUL. */
                    yy_cp = ++(yy_c_buf_p);
                    yy_current_state = yy_next_state;
                    goto yy_match;
                  }

                else
                  {
                    yy_cp = (yy_last_accepting_cpos);
                    yy_current_state = (yy_last_accepting_state);
                    goto yy_find_action;
                  }
              }

            else switch (yy_get_next_buffer())
                {
                  case EOB_ACT_END_OF_FILE:
                  {
                    (yy_did_buffer_switch_on_eof) = 0;

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

                        yy_act = YY_STATE_EOF(YY_START);
                        goto do_action;
                      }

                    else
                      {
                        if (!(yy_did_buffer_switch_on_eof))
                          YY_NEW_FILE;
                      }

                    break;
                  }

                  case EOB_ACT_CONTINUE_SCAN:
                    (yy_c_buf_p) =
                      (yytext_ptr) + yy_amount_of_matched_text;

                    yy_current_state = yy_get_previous_state();

                    yy_cp = (yy_c_buf_p);
                    yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                    goto yy_match;

                  case EOB_ACT_LAST_MATCH:
                    (yy_c_buf_p) =
                      &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];

                    yy_current_state = yy_get_previous_state();

                    yy_cp = (yy_c_buf_p);
                    yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                    goto yy_find_action;
                }

            break;
          }

          default:
            YY_FATAL_ERROR(
              "fatal flex scanner internal error--no action found");
        } /* end of action switch */
    } /* end of scanning one token */
} /* end of yylex */

void CEvaluationLexer::yypop_buffer_state

(

void

)

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

Definition at line 2649 of file CEvaluationLexer_lex.cpp.

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

{
  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 CEvaluationLexer::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 2618 of file CEvaluationLexer_lex.cpp.

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

{
  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 CEvaluationLexer::yyrestart

(

FLEX_STD istream *

s

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Definition at line 2448 of file CEvaluationLexer_lex.cpp.

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

{

  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 CEvaluationLexer::yyunput ( int  c, char *  buf_ptr  )

protected

Definition at line 2336 of file CEvaluationLexer_lex.cpp.

References if(), yyFlexLexer::yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yyFlexLexer::yy_hold_char, yyFlexLexer::yy_n_chars, and yytext_ptr.

{
  register 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. */
      register yy_size_t number_to_move = (yy_n_chars) + 2;
      register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
                              YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
      register 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 CEvaluationLexer::yywrap ( )

inlinevirtual

Definition at line 144 of file CEvaluationLexer.h.

{return 1;}

Member Data Documentation

struct yy_buffer_state** CEvaluationLexer::yy_buffer_stack

protected

Stack as an array.

Definition at line 195 of file CEvaluationLexer.h.

size_t CEvaluationLexer::yy_buffer_stack_max

protected

capacity of stack.

Definition at line 194 of file CEvaluationLexer.h.

size_t CEvaluationLexer::yy_buffer_stack_top

protected

index of top of stack.

Definition at line 193 of file CEvaluationLexer.h.

char* CEvaluationLexer::yy_c_buf_p

protected

Definition at line 184 of file CEvaluationLexer.h.

struct yy_buffer_state* CEvaluationLexer::yy_current_buffer

protected

Definition at line 175 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_did_buffer_switch_on_eof

protected

Definition at line 191 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_full_lp

protected

Definition at line 209 of file CEvaluationLexer.h.

char* CEvaluationLexer::yy_full_match

protected

Definition at line 207 of file CEvaluationLexer.h.

int* CEvaluationLexer::yy_full_state

protected

Definition at line 208 of file CEvaluationLexer.h.

char CEvaluationLexer::yy_hold_char

protected

Definition at line 178 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_init

protected

Definition at line 186 of file CEvaluationLexer.h.

char* CEvaluationLexer::yy_last_accepting_cpos

protected

Definition at line 202 of file CEvaluationLexer.h.

yy_state_type CEvaluationLexer::yy_last_accepting_state

protected

Definition at line 201 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_looking_for_trail_begin

protected

Definition at line 212 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_lp

protected

Definition at line 211 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_more_flag

protected

Definition at line 214 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_more_len

protected

Definition at line 215 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_more_offset

protected

Definition at line 216 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_n_chars

protected

Definition at line 181 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_prev_more_offset

protected

Definition at line 217 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_start

protected

Definition at line 187 of file CEvaluationLexer.h.

int* CEvaluationLexer::yy_start_stack

protected

Definition at line 162 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_start_stack_depth

protected

Definition at line 161 of file CEvaluationLexer.h.

int CEvaluationLexer::yy_start_stack_ptr

protected

Definition at line 160 of file CEvaluationLexer.h.

yy_state_type* CEvaluationLexer::yy_state_buf

protected

Definition at line 204 of file CEvaluationLexer.h.

yy_state_type* CEvaluationLexer::yy_state_ptr

protected

Definition at line 205 of file CEvaluationLexer.h.

std::istream* CEvaluationLexer::yyin

protected

Definition at line 172 of file CEvaluationLexer.h.

std::ostream* CEvaluationLexer::yyout

protected

Definition at line 173 of file CEvaluationLexer.h.

---

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

• CEvaluationLexer.h
• CEvaluationLexer_lex.cpp