COPASI API  4.16.103
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
CEvaluationLexer Class Reference

#include <CEvaluationLexer.h>

Inheritance diagram for CEvaluationLexer:
Inheritance graph
[legend]
Collaboration diagram for CEvaluationLexer:
Collaboration graph
[legend]

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_stateyy_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_stateyy_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 ()
 
CEvaluationNodegetRootNode ()
 
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_stateyy_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_typeyy_state_buf
 
yy_state_typeyy_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
 
CEvaluationNodempNode
 
std::vector< CEvaluationNode * > * mpNodeList
 
size_t mPosition
 
CEvaluationNodempRootNode
 

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.

2043 {
2044  yyin = arg_yyin;
2045  yyout = arg_yyout;
2046  yy_c_buf_p = 0;
2047  yy_init = 0;
2048  yy_start = 0;
2049  yy_flex_debug = 0;
2050  yylineno = 1; // this will only get updated if %option yylineno
2051 
2053 
2055  yy_more_flag = 0;
2056  yy_more_len = 0;
2058 
2060  yy_start_stack = NULL;
2061 
2062  yy_buffer_stack = 0;
2063  yy_buffer_stack_top = 0;
2064  yy_buffer_stack_max = 0;
2065 
2066  yy_state_buf = 0;
2067 }
int yy_flex_debug
Definition: FlexLexer.h:113
yy_state_type * yy_state_buf
int yylineno
Definition: FlexLexer.h:112
std::ostream * yyout
std::istream * yyin
struct yy_buffer_state ** yy_buffer_stack
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.

2072 {
2073  delete [] yy_state_buf;
2077 }
yy_state_type * yy_state_buf
void CEvaluationfree(void *)
#define YY_CURRENT_BUFFER
void yy_delete_buffer(struct yy_buffer_state *b)
struct yy_buffer_state ** 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.

2759 {
2760  std::cerr << msg << std::endl;
2761  exit(YY_EXIT_FAILURE);
2762 }
#define 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().

2098 {
2099  if (yyin->eof() || yyin->fail())
2100  return 0;
2101 
2102 #ifdef YY_INTERACTIVE
2103  yyin->get(buf[0]);
2104 
2105  if (yyin->eof())
2106  return 0;
2107 
2108  if (yyin->bad())
2109  return -1;
2110 
2111  return 1;
2112 
2113 #else
2114  (void) yyin->read(buf, max_size);
2115 
2116  if (yyin->bad())
2117  return -1;
2118  else
2119  return yyin->gcount();
2120 
2121 #endif
2122 }
std::istream * yyin
() void(yyvaluep))
void CEvaluationLexer::LexerOutput ( const char *  buf,
size_t  size 
)
protectedvirtual

Definition at line 2124 of file CEvaluationLexer_lex.cpp.

References void(), and yyFlexLexer::yyout.

2125 {
2126  (void) yyout->write(buf, size);
2127 }
std::ostream * yyout
() void(yyvaluep))
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.

2082 {
2083  if (new_in)
2084  {
2087  }
2088 
2089  if (new_out)
2090  yyout = new_out;
2091 }
#define YY_BUF_SIZE
void yy_switch_to_buffer(struct yy_buffer_state *new_buffer)
#define YY_CURRENT_BUFFER
struct yy_buffer_state * yy_create_buffer(FLEX_STD istream *s, int size)
void yy_delete_buffer(struct yy_buffer_state *b)
std::ostream * yyout
YY_BUFFER_STATE CEvaluationLexer::yy_create_buffer ( FLEX_STD istream *  s,
int  size 
)

Allocate and initialize an input buffer state.

Parameters
fileA readable stream.
sizeThe 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.

2513 {
2514  YY_BUFFER_STATE b;
2515 
2516  b = (YY_BUFFER_STATE) CEvaluationalloc(sizeof(struct yy_buffer_state));
2517 
2518  if (! b)
2519  YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
2520 
2521  b->yy_buf_size = size;
2522 
2523  /* yy_ch_buf has to be 2 characters longer than the size given because
2524  * we need to put in 2 end-of-buffer characters.
2525  */
2526  b->yy_ch_buf = (char *) CEvaluationalloc(b->yy_buf_size + 2);
2527 
2528  if (! b->yy_ch_buf)
2529  YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
2530 
2531  b->yy_is_our_buffer = 1;
2532 
2533  yy_init_buffer(b, file);
2534 
2535  return b;
2536 }
void yy_init_buffer(struct yy_buffer_state *b, std::istream *s)
void * CEvaluationalloc(yy_size_t)
#define YY_FATAL_ERROR(msg)
struct yy_buffer_state * YY_BUFFER_STATE
void CEvaluationLexer::yy_delete_buffer ( struct yy_buffer_state b)
virtual

Destroy the buffer.

Parameters
ba 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.

2543 {
2544 
2545  if (! b)
2546  return;
2547 
2548  if (b == YY_CURRENT_BUFFER) /* Not sure if we should pop here. */
2550 
2551  if (b->yy_is_our_buffer)
2552  CEvaluationfree((void *) b->yy_ch_buf);
2553 
2554  CEvaluationfree((void *) b);
2555 }
void CEvaluationfree(void *)
struct yy_buffer_state * YY_BUFFER_STATE
#define YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER
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
bthe 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.

2590 {
2591  if (! b)
2592  return;
2593 
2594  b->yy_n_chars = 0;
2595 
2596  /* We always need two end-of-buffer characters. The first causes
2597  * a transition to the end-of-buffer state. The second causes
2598  * a jam in that state.
2599  */
2602 
2603  b->yy_buf_pos = &b->yy_ch_buf[0];
2604 
2605  b->yy_at_bol = 1;
2607 
2608  if (b == YY_CURRENT_BUFFER)
2610 }
#define YY_BUFFER_NEW
#define YY_END_OF_BUFFER_CHAR
#define YY_CURRENT_BUFFER
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.

2137 {
2138  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2139  register char *source = (yytext_ptr);
2140  register int number_to_move, i;
2141  int ret_val;
2142 
2143  if ((yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1])
2145  "fatal flex scanner internal error--end of buffer missed");
2146 
2147  if (YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0)
2148  {
2149  /* Don't try to fill the buffer, so this is an EOF. */
2150  if ((yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1)
2151  {
2152  /* We matched a single character, the EOB, so
2153  * treat this as a final EOF.
2154  */
2155  return EOB_ACT_END_OF_FILE;
2156  }
2157 
2158  else
2159  {
2160  /* We matched some text prior to the EOB, first
2161  * process it.
2162  */
2163  return EOB_ACT_LAST_MATCH;
2164  }
2165  }
2166 
2167  /* Try to read more data. */
2168 
2169  /* First move last chars to start of buffer. */
2170  number_to_move = (int)((yy_c_buf_p) - (yytext_ptr)) - 1;
2171 
2172  for (i = 0; i < number_to_move; ++i)
2173  *(dest++) = *(source++);
2174 
2175  if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING)
2176  /* don't do the read, it's not guaranteed to return an EOF,
2177  * just force an EOF
2178  */
2179  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2180 
2181  else
2182  {
2183  yy_size_t num_to_read =
2184  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2185 
2186  while (num_to_read <= 0)
2187  {
2188  /* Not enough room in the buffer - grow it. */
2189 
2190  /* just a shorter name for the current buffer */
2192 
2193  int yy_c_buf_p_offset =
2194  (int)((yy_c_buf_p) - b->yy_ch_buf);
2195 
2196  if (b->yy_is_our_buffer)
2197  {
2198  yy_size_t new_size = b->yy_buf_size * 2;
2199 
2200  if (new_size <= 0)
2201  b->yy_buf_size += b->yy_buf_size / 8;
2202  else
2203  b->yy_buf_size *= 2;
2204 
2205  b->yy_ch_buf = (char *)
2206  /* Include room in for 2 EOB chars. */
2207  CEvaluationrealloc((void *) b->yy_ch_buf, b->yy_buf_size + 2);
2208  }
2209  else
2210  /* Can't grow it, we don't own it. */
2211  b->yy_ch_buf = 0;
2212 
2213  if (! b->yy_ch_buf)
2215  "fatal error - scanner input buffer overflow");
2216 
2217  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2218 
2219  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2220  number_to_move - 1;
2221  }
2222 
2223  if (num_to_read > YY_READ_BUF_SIZE)
2224  num_to_read = YY_READ_BUF_SIZE;
2225 
2226  /* Read in more data. */
2227  YY_INPUT((&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2228  (yy_n_chars), num_to_read);
2229 
2230  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2231  }
2232 
2233  if ((yy_n_chars) == 0)
2234  {
2235  if (number_to_move == YY_MORE_ADJ)
2236  {
2237  ret_val = EOB_ACT_END_OF_FILE;
2238  yyrestart(yyin);
2239  }
2240 
2241  else
2242  {
2243  ret_val = EOB_ACT_LAST_MATCH;
2244  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2246  }
2247  }
2248 
2249  else
2250  ret_val = EOB_ACT_CONTINUE_SCAN;
2251 
2252  if ((yy_size_t)((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size)
2253  {
2254  /* Extend the array by 50%, plus the number we really need. */
2255  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2256  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) CEvaluationrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size);
2257 
2258  if (! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
2259  YY_FATAL_ERROR("out of dynamic memory in yy_get_next_buffer()");
2260  }
2261 
2262  (yy_n_chars) += number_to_move;
2265 
2266  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2267 
2268  return ret_val;
2269 }
#define EOB_ACT_CONTINUE_SCAN
size_t yy_size_t
#define YY_MORE_ADJ
#define YY_READ_BUF_SIZE
#define YY_INPUT(buf, result, max_size)
#define EOB_ACT_LAST_MATCH
#define YY_FATAL_ERROR(msg)
#define YY_END_OF_BUFFER_CHAR
void yyrestart(FLEX_STD istream *s)
#define YY_BUFFER_EOF_PENDING
#define YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER
void * CEvaluationrealloc(void *, yy_size_t)
#define yytext_ptr
std::istream * yyin
#define EOB_ACT_END_OF_FILE
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.

2274 {
2275  register yy_state_type yy_current_state;
2276  register char *yy_cp;
2277 
2278  yy_current_state = (yy_start);
2279 
2280  for (yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp)
2281  {
2282  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2283 
2284  if (yy_accept[yy_current_state])
2285  {
2286  (yy_last_accepting_state) = yy_current_state;
2287  (yy_last_accepting_cpos) = yy_cp;
2288  }
2289 
2290  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
2291  {
2292  yy_current_state = (int) yy_def[yy_current_state];
2293 
2294  if (yy_current_state >= 380)
2295  yy_c = yy_meta[(unsigned int) yy_c];
2296  }
2297 
2298  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2299  }
2300 
2301  return yy_current_state;
2302 }
#define YY_SC_TO_UI(c)
unsigned char YY_CHAR
#define YY_MORE_ADJ
int yy_state_type
Definition: FlexLexer.h:72
static flex_int16_t yy_nxt[879]
static flex_int32_t yy_ec[256]
static flex_int16_t yy_def[384]
#define yytext_ptr
static flex_int32_t yy_meta[70]
static flex_int16_t yy_accept[380]
yy_state_type yy_last_accepting_state
static flex_int16_t yy_chk[879]
static flex_int16_t yy_base[384]
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.

2563 {
2564  int oerrno = errno;
2565 
2566  yy_flush_buffer(b);
2567 
2568  b->yy_input_file = file;
2569  b->yy_fill_buffer = 1;
2570 
2571  /* If b is the current buffer, then yy_init_buffer was _probably_
2572  * called from yyrestart() or through yy_get_next_buffer.
2573  * In that case, we don't want to reset the lineno or column.
2574  */
2575  if (b != YY_CURRENT_BUFFER)
2576  {
2577  b->yy_bs_lineno = 1;
2578  b->yy_bs_column = 0;
2579  }
2580 
2581  b->yy_is_interactive = 0;
2582  errno = oerrno;
2583 }
void yy_flush_buffer(struct yy_buffer_state *b)
std::istream * yy_input_file
#define YY_CURRENT_BUFFER
void CEvaluationLexer::yy_load_buffer_state ( )
protected
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.

2742 {
2743  if (--(yy_start_stack_ptr) < 0)
2744  YY_FATAL_ERROR("start-condition stack underflow");
2745 
2747 }
#define BEGIN
#define YY_FATAL_ERROR(msg)
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.

2718 {
2720  {
2721  yy_size_t new_size;
2722 
2724  new_size = (yy_start_stack_depth) * sizeof(int);
2725 
2726  if (!(yy_start_stack))
2727  (yy_start_stack) = (int *) CEvaluationalloc(new_size);
2728 
2729  else
2730  (yy_start_stack) = (int *) CEvaluationrealloc((void *)(yy_start_stack), new_size);
2731 
2732  if (!(yy_start_stack))
2733  YY_FATAL_ERROR("out of memory expanding start-condition stack");
2734  }
2735 
2737 
2738  BEGIN(new_state);
2739 }
size_t yy_size_t
void * CEvaluationalloc(yy_size_t)
#define YY_START_STACK_INCR
#define BEGIN
#define YY_FATAL_ERROR(msg)
void * CEvaluationrealloc(void *, yy_size_t)
#define YY_START
void CEvaluationLexer::yy_switch_to_buffer ( struct yy_buffer_state new_buffer)
virtual

Switch to a different input buffer.

Parameters
new_bufferThe 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().

2467 {
2468 
2469  /* TODO. We should be able to replace this entire function body
2470  * with
2471  * yypop_buffer_state();
2472  * yypush_buffer_state(new_buffer);
2473  */
2475 
2476  if (YY_CURRENT_BUFFER == new_buffer)
2477  return;
2478 
2479  if (YY_CURRENT_BUFFER)
2480  {
2481  /* Flush out information for old buffer. */
2482  *(yy_c_buf_p) = (yy_hold_char);
2483  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2484  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2485  }
2486 
2487  YY_CURRENT_BUFFER_LVALUE = new_buffer;
2489 
2490  /* We don't actually know whether we did this switch during
2491  * EOF (yywrap()) processing, but the only time this flag
2492  * is looked at is after yywrap() is called, so it's safe
2493  * to go ahead and always set it.
2494  */
2496 }
#define YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER
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.

2750 {
2751  return (yy_start_stack)[(yy_start_stack_ptr) - 1];
2752 }
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.

2310 {
2311  register int yy_is_jam;
2312  register char *yy_cp = (yy_c_buf_p);
2313 
2314  register YY_CHAR yy_c = 1;
2315 
2316  if (yy_accept[yy_current_state])
2317  {
2318  (yy_last_accepting_state) = yy_current_state;
2319  (yy_last_accepting_cpos) = yy_cp;
2320  }
2321 
2322  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
2323  {
2324  yy_current_state = (int) yy_def[yy_current_state];
2325 
2326  if (yy_current_state >= 380)
2327  yy_c = yy_meta[(unsigned int) yy_c];
2328  }
2329 
2330  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2331  yy_is_jam = (yy_current_state == 379);
2332 
2333  return yy_is_jam ? 0 : yy_current_state;
2334 }
unsigned char YY_CHAR
static flex_int16_t yy_nxt[879]
static flex_int16_t yy_def[384]
static flex_int32_t yy_meta[70]
static flex_int16_t yy_accept[380]
yy_state_type yy_last_accepting_state
static flex_int16_t yy_chk[879]
static flex_int16_t yy_base[384]
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.

2671 {
2672  yy_size_t num_to_alloc;
2673 
2674  if (!(yy_buffer_stack))
2675  {
2676 
2677  /* First allocation is just for 2 elements, since we don't know if this
2678  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2679  * immediate realloc on the next call.
2680  */
2681  num_to_alloc = 1;
2683  (num_to_alloc * sizeof(struct yy_buffer_state*)
2684  );
2685 
2686  if (!(yy_buffer_stack))
2687  YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()");
2688 
2689  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2690 
2691  (yy_buffer_stack_max) = num_to_alloc;
2692  (yy_buffer_stack_top) = 0;
2693  return;
2694  }
2695 
2696  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1)
2697  {
2698 
2699  /* Increase the buffer to prepare for a possible push. */
2700  int grow_size = 8 /* arbitrary grow size */;
2701 
2702  num_to_alloc = (yy_buffer_stack_max) + grow_size;
2704  ((yy_buffer_stack),
2705  num_to_alloc * sizeof(struct yy_buffer_state*)
2706  );
2707 
2708  if (!(yy_buffer_stack))
2709  YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()");
2710 
2711  /* zero only the new slots.*/
2712  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2713  (yy_buffer_stack_max) = num_to_alloc;
2714  }
2715 }
size_t yy_size_t
void * CEvaluationalloc(yy_size_t)
#define YY_FATAL_ERROR(msg)
void * CEvaluationrealloc(void *, yy_size_t)
struct yy_buffer_state ** yy_buffer_stack
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().

2375 {
2376  int c;
2377 
2378  *(yy_c_buf_p) = (yy_hold_char);
2379 
2381  {
2382  /* yy_c_buf_p now points to the character we want to return.
2383  * If this occurs *before* the EOB characters, then it's a
2384  * valid NUL; if not, then we've hit the end of the buffer.
2385  */
2386  if ((yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)])
2387  /* This was really a NUL. */
2388  *(yy_c_buf_p) = '\0';
2389 
2390  else
2391  {
2392  /* need more input */
2393  yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2394  ++(yy_c_buf_p);
2395 
2396  switch (yy_get_next_buffer())
2397  {
2398  case EOB_ACT_LAST_MATCH:
2399  /* This happens because yy_g_n_b()
2400  * sees that we've accumulated a
2401  * token and flags that we need to
2402  * try matching the token before
2403  * proceeding. But for input(),
2404  * there's no matching to consider.
2405  * So convert the EOB_ACT_LAST_MATCH
2406  * to EOB_ACT_END_OF_FILE.
2407  */
2408 
2409  /* Reset buffer status. */
2410  yyrestart(yyin);
2411 
2412  /*FALLTHROUGH*/
2413 
2414  case EOB_ACT_END_OF_FILE:
2415  {
2416  if (yywrap())
2417  return 0;
2418 
2420  YY_NEW_FILE;
2421 
2422 #ifdef __cplusplus
2423  return yyinput();
2424 #else
2425  return input();
2426 #endif
2427  }
2428 
2429  case EOB_ACT_CONTINUE_SCAN:
2430  (yy_c_buf_p) = (yytext_ptr) + offset;
2431  break;
2432  }
2433  }
2434  }
2435 
2436  c = *(unsigned char *)(yy_c_buf_p); /* cast for 8-bit char's */
2437  *(yy_c_buf_p) = '\0'; /* preserve yytext */
2438  (yy_hold_char) = *++(yy_c_buf_p);
2439 
2440  return c;
2441 }
#define EOB_ACT_CONTINUE_SCAN
size_t yy_size_t
virtual int yywrap()
#define EOB_ACT_LAST_MATCH
#define YY_END_OF_BUFFER_CHAR
void yyrestart(FLEX_STD istream *s)
#define YY_CURRENT_BUFFER_LVALUE
#define yytext_ptr
std::istream * yyin
#define EOB_ACT_END_OF_FILE
#define YY_NEW_FILE
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.

859 {
860  register yy_state_type yy_current_state;
861  register char *yy_cp, *yy_bp;
862  register int yy_act;
863 
864 #line 36 "function/CEvaluationLexer.lpp"
865 
866 #line 849 "<stdout>"
867 
868  if (!(yy_init))
869  {
870  (yy_init) = 1;
871 
872 #ifdef YY_USER_INIT
873  YY_USER_INIT;
874 #endif
875 
876  if (!(yy_start))
877  (yy_start) = 1; /* first start state */
878 
879  if (! yyin)
880  yyin = & std::cin;
881 
882  if (! yyout)
883  yyout = & std::cout;
884 
885  if (! YY_CURRENT_BUFFER)
886  {
890  }
891 
893  }
894 
895  while (1) /* loops until end-of-file is reached */
896  {
897  yy_cp = (yy_c_buf_p);
898 
899  /* Support of yytext. */
900  *yy_cp = (yy_hold_char);
901 
902  /* yy_bp points to the position in yy_ch_buf of the start of
903  * the current run.
904  */
905  yy_bp = yy_cp;
906 
907  yy_current_state = (yy_start);
908 yy_match:
909 
910  do
911  {
912  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
913 
914  if (yy_accept[yy_current_state])
915  {
916  (yy_last_accepting_state) = yy_current_state;
917  (yy_last_accepting_cpos) = yy_cp;
918  }
919 
920  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
921  {
922  yy_current_state = (int) yy_def[yy_current_state];
923 
924  if (yy_current_state >= 380)
925  yy_c = yy_meta[(unsigned int) yy_c];
926  }
927 
928  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
929  ++yy_cp;
930  }
931  while (yy_current_state != 379);
932 
933  yy_cp = (yy_last_accepting_cpos);
934  yy_current_state = (yy_last_accepting_state);
935 
936 yy_find_action:
937  yy_act = yy_accept[yy_current_state];
938 
940 
941 do_action: /* This label is used only to access EOF actions. */
942 
943  switch (yy_act)
944  {
945  /* beginning of action switch */
946  case 0: /* must back up */
947  /* undo the effects of YY_DO_BEFORE_ACTION */
948  *yy_cp = (yy_hold_char);
949  yy_cp = (yy_last_accepting_cpos);
950  yy_current_state = (yy_last_accepting_state);
951  goto yy_find_action;
952 
953  case 1:
955 #line 37 "function/CEvaluationLexer.lpp"
956 
957  BEGIN(sOPERATOR);
959  yytext);
961  return TOKEN_NUMBER;
962 
963  YY_BREAK
964  case 2:
966 #line 45 "function/CEvaluationLexer.lpp"
967 
968  BEGIN(sOPERATOR);
970  yytext);
972  return TOKEN_NUMBER;
973 
974  YY_BREAK
975  case 3:
977 #line 53 "function/CEvaluationLexer.lpp"
978 
979  BEGIN(sOPERATOR);
981  yytext);
983  return TOKEN_NUMBER;
984 
985  YY_BREAK
986  case 4:
988 #line 61 "function/CEvaluationLexer.lpp"
989 
990  BEGIN(sOPERATOR);
992  yytext);
994  return TOKEN_LOGICAL_VALUE;
995 
996  YY_BREAK
997  case 5:
999 #line 69 "function/CEvaluationLexer.lpp"
1000 
1001  BEGIN(sOPERATOR);
1003  yytext);
1004  COMMON_ACTION;
1005  return TOKEN_LOGICAL_VALUE;
1006 
1007  YY_BREAK
1008  case 6:
1010 #line 77 "function/CEvaluationLexer.lpp"
1011 
1012  BEGIN(sOPERATOR);
1014  yytext);
1015  COMMON_ACTION;
1016  return TOKEN_NUMBER;
1017 
1018  YY_BREAK
1019  case 7:
1021 #line 85 "function/CEvaluationLexer.lpp"
1022 
1023  BEGIN(sOPERATOR);
1025  yytext);
1026  COMMON_ACTION;
1027  return TOKEN_NUMBER;
1028 
1029  YY_BREAK
1030  case 8:
1032 #line 93 "function/CEvaluationLexer.lpp"
1033 
1034  BEGIN(sVALUE);
1036  yytext);
1037  COMMON_ACTION;
1038  return TOKEN_LOGICAL_NOT;
1039 
1040  YY_BREAK
1041  case 9:
1043 #line 101 "function/CEvaluationLexer.lpp"
1044 
1047  yytext);
1048  COMMON_ACTION;
1049  return TOKEN_LOGICAL_LE;
1050 
1051  YY_BREAK
1052  case 10:
1054 #line 109 "function/CEvaluationLexer.lpp"
1055 
1058  yytext);
1059  COMMON_ACTION;
1060  return TOKEN_LOGICAL_LT;
1061 
1062  YY_BREAK
1063  case 11:
1065 #line 117 "function/CEvaluationLexer.lpp"
1066 
1069  yytext);
1070  COMMON_ACTION;
1071  return TOKEN_LOGICAL_GE;
1072 
1073  YY_BREAK
1074  case 12:
1076 #line 125 "function/CEvaluationLexer.lpp"
1077 
1080  yytext);
1081  COMMON_ACTION;
1082  return TOKEN_LOGICAL_GT;
1083 
1084  YY_BREAK
1085  case 13:
1087 #line 133 "function/CEvaluationLexer.lpp"
1088 
1091  yytext);
1092  COMMON_ACTION;
1093  return TOKEN_LOGICAL_NE;
1094 
1095  YY_BREAK
1096  case 14:
1098 #line 141 "function/CEvaluationLexer.lpp"
1099 
1102  yytext);
1103  COMMON_ACTION;
1104  return TOKEN_LOGICAL_EQ;
1105 
1106  YY_BREAK
1107  case 15:
1109 #line 149 "function/CEvaluationLexer.lpp"
1110 
1113  yytext);
1114  COMMON_ACTION;
1115  return TOKEN_LOGICAL_AND;
1116 
1117  YY_BREAK
1118  case 16:
1120 #line 157 "function/CEvaluationLexer.lpp"
1121 
1124  yytext);
1125  COMMON_ACTION;
1126  return TOKEN_LOGICAL_XOR;
1127 
1128  YY_BREAK
1129  case 17:
1131 #line 165 "function/CEvaluationLexer.lpp"
1132 
1135  yytext);
1136  COMMON_ACTION;
1137  return TOKEN_LOGICAL_OR;
1138 
1139  YY_BREAK
1140  case 18:
1141  /* rule 18 can match eol */
1143 #line 173 "function/CEvaluationLexer.lpp"
1144 
1145  BEGIN(sOPERATOR);
1147  yytext);
1148  COMMON_ACTION;
1149  return TOKEN_NUMBER;
1150 
1151  YY_BREAK
1152  case 19:
1154 #line 181 "function/CEvaluationLexer.lpp"
1155 
1156  BEGIN(sOPERATOR);
1158  yytext);
1159  COMMON_ACTION;
1160  return TOKEN_NUMBER;
1161 
1162  YY_BREAK
1163  case 20:
1164  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1165  (yy_c_buf_p) = yy_cp -= 1;
1166  YY_DO_BEFORE_ACTION; /* set up yytext again */
1168 #line 189 "function/CEvaluationLexer.lpp"
1169 
1171  yytext);
1172  COMMON_ACTION;
1173  return TOKEN_FUNCTION;
1174 
1175  YY_BREAK
1176  case 21:
1177  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1178  (yy_c_buf_p) = yy_cp -= 1;
1179  YY_DO_BEFORE_ACTION; /* set up yytext again */
1181 #line 196 "function/CEvaluationLexer.lpp"
1182 
1184  yytext);
1185  COMMON_ACTION;
1186  return TOKEN_FUNCTION;
1187 
1188  YY_BREAK
1189  case 22:
1190  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1191  (yy_c_buf_p) = yy_cp -= 1;
1192  YY_DO_BEFORE_ACTION; /* set up yytext again */
1194 #line 203 "function/CEvaluationLexer.lpp"
1195 
1197  yytext);
1198  COMMON_ACTION;
1199  return TOKEN_FUNCTION;
1200 
1201  YY_BREAK
1202  case 23:
1203  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1204  (yy_c_buf_p) = yy_cp -= 1;
1205  YY_DO_BEFORE_ACTION; /* set up yytext again */
1207 #line 210 "function/CEvaluationLexer.lpp"
1208 
1210  yytext);
1211  COMMON_ACTION;
1212  return TOKEN_FUNCTION;
1213 
1214  YY_BREAK
1215  case 24:
1216  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1217  (yy_c_buf_p) = yy_cp -= 1;
1218  YY_DO_BEFORE_ACTION; /* set up yytext again */
1220 #line 217 "function/CEvaluationLexer.lpp"
1221 
1223  yytext);
1224  COMMON_ACTION;
1225  return TOKEN_FUNCTION;
1226 
1227  YY_BREAK
1228  case 25:
1229  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1230  (yy_c_buf_p) = yy_cp -= 1;
1231  YY_DO_BEFORE_ACTION; /* set up yytext again */
1233 #line 224 "function/CEvaluationLexer.lpp"
1234 
1236  yytext);
1237  COMMON_ACTION;
1238  return TOKEN_FUNCTION;
1239 
1240  YY_BREAK
1241  case 26:
1242  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1243  (yy_c_buf_p) = yy_cp -= 1;
1244  YY_DO_BEFORE_ACTION; /* set up yytext again */
1246 #line 231 "function/CEvaluationLexer.lpp"
1247 
1249  yytext);
1250  COMMON_ACTION;
1251  return TOKEN_FUNCTION;
1252 
1253  YY_BREAK
1254  case 27:
1255  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1256  (yy_c_buf_p) = yy_cp -= 1;
1257  YY_DO_BEFORE_ACTION; /* set up yytext again */
1259 #line 238 "function/CEvaluationLexer.lpp"
1260 
1262  yytext);
1263  COMMON_ACTION;
1264  return TOKEN_FUNCTION;
1265 
1266  YY_BREAK
1267  case 28:
1268  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1269  (yy_c_buf_p) = yy_cp -= 1;
1270  YY_DO_BEFORE_ACTION; /* set up yytext again */
1272 #line 245 "function/CEvaluationLexer.lpp"
1273 
1275  yytext);
1276  COMMON_ACTION;
1277  return TOKEN_FUNCTION;
1278 
1279  YY_BREAK
1280  case 29:
1281  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1282  (yy_c_buf_p) = yy_cp -= 1;
1283  YY_DO_BEFORE_ACTION; /* set up yytext again */
1285 #line 252 "function/CEvaluationLexer.lpp"
1286 
1288  yytext);
1289  COMMON_ACTION;
1290  return TOKEN_FUNCTION;
1291 
1292  YY_BREAK
1293  case 30:
1294  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1295  (yy_c_buf_p) = yy_cp -= 1;
1296  YY_DO_BEFORE_ACTION; /* set up yytext again */
1298 #line 259 "function/CEvaluationLexer.lpp"
1299 
1301  yytext);
1302  COMMON_ACTION;
1303  return TOKEN_FUNCTION;
1304 
1305  YY_BREAK
1306  case 31:
1307  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1308  (yy_c_buf_p) = yy_cp -= 1;
1309  YY_DO_BEFORE_ACTION; /* set up yytext again */
1311 #line 266 "function/CEvaluationLexer.lpp"
1312 
1314  yytext);
1315  COMMON_ACTION;
1316  return TOKEN_FUNCTION;
1317 
1318  YY_BREAK
1319  case 32:
1320  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1321  (yy_c_buf_p) = yy_cp -= 1;
1322  YY_DO_BEFORE_ACTION; /* set up yytext again */
1324 #line 273 "function/CEvaluationLexer.lpp"
1325 
1327  yytext);
1328  COMMON_ACTION;
1329  return TOKEN_FUNCTION;
1330 
1331  YY_BREAK
1332  case 33:
1333  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1334  (yy_c_buf_p) = yy_cp -= 1;
1335  YY_DO_BEFORE_ACTION; /* set up yytext again */
1337 #line 280 "function/CEvaluationLexer.lpp"
1338 
1340  yytext);
1341  COMMON_ACTION;
1342  return TOKEN_FUNCTION;
1343 
1344  YY_BREAK
1345  case 34:
1346  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1347  (yy_c_buf_p) = yy_cp -= 1;
1348  YY_DO_BEFORE_ACTION; /* set up yytext again */
1350 #line 287 "function/CEvaluationLexer.lpp"
1351 
1353  yytext);
1354  COMMON_ACTION;
1355  return TOKEN_FUNCTION;
1356 
1357  YY_BREAK
1358  case 35:
1359  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1360  (yy_c_buf_p) = yy_cp -= 1;
1361  YY_DO_BEFORE_ACTION; /* set up yytext again */
1363 #line 294 "function/CEvaluationLexer.lpp"
1364 
1366  yytext);
1367  COMMON_ACTION;
1368  return TOKEN_FUNCTION;
1369 
1370  YY_BREAK
1371  case 36:
1372  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1373  (yy_c_buf_p) = yy_cp -= 1;
1374  YY_DO_BEFORE_ACTION; /* set up yytext again */
1376 #line 301 "function/CEvaluationLexer.lpp"
1377 
1379  yytext);
1380  COMMON_ACTION;
1381  return TOKEN_FUNCTION;
1382 
1383  YY_BREAK
1384  case 37:
1385  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1386  (yy_c_buf_p) = yy_cp -= 1;
1387  YY_DO_BEFORE_ACTION; /* set up yytext again */
1389 #line 308 "function/CEvaluationLexer.lpp"
1390 
1392  yytext);
1393  COMMON_ACTION;
1394  return TOKEN_FUNCTION;
1395 
1396  YY_BREAK
1397  case 38:
1398  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1399  (yy_c_buf_p) = yy_cp -= 1;
1400  YY_DO_BEFORE_ACTION; /* set up yytext again */
1402 #line 315 "function/CEvaluationLexer.lpp"
1403 
1405  yytext);
1406  COMMON_ACTION;
1407  return TOKEN_FUNCTION;
1408 
1409  YY_BREAK
1410  case 39:
1411  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1412  (yy_c_buf_p) = yy_cp -= 1;
1413  YY_DO_BEFORE_ACTION; /* set up yytext again */
1415 #line 322 "function/CEvaluationLexer.lpp"
1416 
1418  yytext);
1419  COMMON_ACTION;
1420  return TOKEN_FUNCTION;
1421 
1422  YY_BREAK
1423  case 40:
1424  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1425  (yy_c_buf_p) = yy_cp -= 1;
1426  YY_DO_BEFORE_ACTION; /* set up yytext again */
1428 #line 329 "function/CEvaluationLexer.lpp"
1429 
1431  yytext);
1432  COMMON_ACTION;
1433  return TOKEN_FUNCTION;
1434 
1435  YY_BREAK
1436  case 41:
1437  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1438  (yy_c_buf_p) = yy_cp -= 1;
1439  YY_DO_BEFORE_ACTION; /* set up yytext again */
1441 #line 336 "function/CEvaluationLexer.lpp"
1442 
1444  yytext);
1445  COMMON_ACTION;
1446  return TOKEN_FUNCTION;
1447 
1448  YY_BREAK
1449  case 42:
1450  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1451  (yy_c_buf_p) = yy_cp -= 1;
1452  YY_DO_BEFORE_ACTION; /* set up yytext again */
1454 #line 343 "function/CEvaluationLexer.lpp"
1455 
1457  yytext);
1458  COMMON_ACTION;
1459  return TOKEN_FUNCTION;
1460 
1461  YY_BREAK
1462  case 43:
1463  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1464  (yy_c_buf_p) = yy_cp -= 1;
1465  YY_DO_BEFORE_ACTION; /* set up yytext again */
1467 #line 350 "function/CEvaluationLexer.lpp"
1468 
1470  yytext);
1471  COMMON_ACTION;
1472  return TOKEN_FUNCTION;
1473 
1474  YY_BREAK
1475  case 44:
1476  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1477  (yy_c_buf_p) = yy_cp -= 1;
1478  YY_DO_BEFORE_ACTION; /* set up yytext again */
1480 #line 357 "function/CEvaluationLexer.lpp"
1481 
1483  yytext);
1484  COMMON_ACTION;
1485  return TOKEN_FUNCTION;
1486 
1487  YY_BREAK
1488  case 45:
1489  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1490  (yy_c_buf_p) = yy_cp -= 1;
1491  YY_DO_BEFORE_ACTION; /* set up yytext again */
1493 #line 364 "function/CEvaluationLexer.lpp"
1494 
1496  yytext);
1497  COMMON_ACTION;
1498  return TOKEN_FUNCTION;
1499 
1500  YY_BREAK
1501  case 46:
1502  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1503  (yy_c_buf_p) = yy_cp -= 1;
1504  YY_DO_BEFORE_ACTION; /* set up yytext again */
1506 #line 371 "function/CEvaluationLexer.lpp"
1507 
1509  yytext);
1510  COMMON_ACTION;
1511  return TOKEN_FUNCTION;
1512 
1513  YY_BREAK
1514  case 47:
1515  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1516  (yy_c_buf_p) = yy_cp -= 1;
1517  YY_DO_BEFORE_ACTION; /* set up yytext again */
1519 #line 378 "function/CEvaluationLexer.lpp"
1520 
1522  yytext);
1523  COMMON_ACTION;
1524  return TOKEN_FUNCTION;
1525 
1526  YY_BREAK
1527  case 48:
1528  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1529  (yy_c_buf_p) = yy_cp -= 1;
1530  YY_DO_BEFORE_ACTION; /* set up yytext again */
1532 #line 385 "function/CEvaluationLexer.lpp"
1533 
1535  yytext);
1536  COMMON_ACTION;
1537  return TOKEN_FUNCTION;
1538 
1539  YY_BREAK
1540  case 49:
1541  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1542  (yy_c_buf_p) = yy_cp -= 1;
1543  YY_DO_BEFORE_ACTION; /* set up yytext again */
1545 #line 392 "function/CEvaluationLexer.lpp"
1546 
1548  yytext);
1549  COMMON_ACTION;
1550  return TOKEN_FUNCTION;
1551 
1552  YY_BREAK
1553  case 50:
1554  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1555  (yy_c_buf_p) = yy_cp -= 1;
1556  YY_DO_BEFORE_ACTION; /* set up yytext again */
1558 #line 399 "function/CEvaluationLexer.lpp"
1559 
1561  yytext);
1562  COMMON_ACTION;
1563  return TOKEN_FUNCTION;
1564 
1565  YY_BREAK
1566  case 51:
1567  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1568  (yy_c_buf_p) = yy_cp -= 1;
1569  YY_DO_BEFORE_ACTION; /* set up yytext again */
1571 #line 406 "function/CEvaluationLexer.lpp"
1572 
1574  yytext);
1575  COMMON_ACTION;
1576  return TOKEN_FUNCTION;
1577 
1578  YY_BREAK
1579  case 52:
1580  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1581  (yy_c_buf_p) = yy_cp -= 1;
1582  YY_DO_BEFORE_ACTION; /* set up yytext again */
1584 #line 413 "function/CEvaluationLexer.lpp"
1585 
1587  yytext);
1588  COMMON_ACTION;
1589  return TOKEN_FUNCTION_2;
1590 
1591  YY_BREAK
1592  case 53:
1593  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1594  (yy_c_buf_p) = yy_cp -= 1;
1595  YY_DO_BEFORE_ACTION; /* set up yytext again */
1597 #line 420 "function/CEvaluationLexer.lpp"
1598 
1600  yytext);
1601  COMMON_ACTION;
1602  return TOKEN_FUNCTION_2;
1603 
1604  YY_BREAK
1605  case 54:
1606  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1607  (yy_c_buf_p) = yy_cp -= 1;
1608  YY_DO_BEFORE_ACTION; /* set up yytext again */
1610 #line 427 "function/CEvaluationLexer.lpp"
1611 
1613  yytext);
1614  COMMON_ACTION;
1615  return TOKEN_FUNCTION;
1616 
1617  YY_BREAK
1618  case 55:
1619  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1620  (yy_c_buf_p) = yy_cp -= 1;
1621  YY_DO_BEFORE_ACTION; /* set up yytext again */
1623 #line 434 "function/CEvaluationLexer.lpp"
1624 
1626  yytext);
1627  COMMON_ACTION;
1628  return TOKEN_FUNCTION_2;
1629 
1630  YY_BREAK
1631  case 56:
1632  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1633  (yy_c_buf_p) = yy_cp -= 1;
1634  YY_DO_BEFORE_ACTION; /* set up yytext again */
1636 #line 441 "function/CEvaluationLexer.lpp"
1637 
1639  yytext);
1640  COMMON_ACTION;
1641  return TOKEN_FUNCTION_2;
1642 
1643  YY_BREAK
1644  case 57:
1645  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1646  (yy_c_buf_p) = yy_cp -= 1;
1647  YY_DO_BEFORE_ACTION; /* set up yytext again */
1649 #line 448 "function/CEvaluationLexer.lpp"
1650 
1652  yytext);
1653  COMMON_ACTION;
1654  return TOKEN_FUNCTION_2;
1655 
1656  YY_BREAK
1657  case 58:
1658  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1659  (yy_c_buf_p) = yy_cp -= 1;
1660  YY_DO_BEFORE_ACTION; /* set up yytext again */
1662 #line 455 "function/CEvaluationLexer.lpp"
1663 
1665  yytext);
1666  COMMON_ACTION;
1667  return TOKEN_FUNCTION_2;
1668 
1669  YY_BREAK
1670  case 59:
1671  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1672  (yy_c_buf_p) = yy_cp -= 1;
1673  YY_DO_BEFORE_ACTION; /* set up yytext again */
1675 #line 462 "function/CEvaluationLexer.lpp"
1676 
1678  yytext);
1679  COMMON_ACTION;
1680  return TOKEN_LOGICAL_CHOICE;
1681 
1682  YY_BREAK
1683  case 60:
1684  /* rule 60 can match eol */
1685  *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1686  (yy_c_buf_p) = yy_cp -= 1;
1687  YY_DO_BEFORE_ACTION; /* set up yytext again */
1689 #line 469 "function/CEvaluationLexer.lpp"
1690 
1691  {
1692  std::string tmp(yytext);
1694  tmp.substr(0, tmp.length() - 1));
1695  }
1696  COMMON_ACTION;
1697  return TOKEN_CALL;
1698 
1699  YY_BREAK
1700  case 61:
1701  /* rule 61 can match eol */
1703 #line 479 "function/CEvaluationLexer.lpp"
1704 
1705  {
1706  std::string tmp(yytext);
1708  tmp.substr(0, tmp.length() - 1));
1709  }
1710  COMMON_ACTION;
1711  return TOKEN_CALL;
1712 
1713  YY_BREAK
1714  case 62:
1716 #line 489 "function/CEvaluationLexer.lpp"
1717 
1718  BEGIN(sVALUE);
1720  yytext);
1721  COMMON_ACTION;
1722  return TOKEN_SIGN;
1723 
1724  YY_BREAK
1725  case 63:
1727 #line 497 "function/CEvaluationLexer.lpp"
1728 
1729  BEGIN(sVALUE);
1731  yytext);
1732  COMMON_ACTION;
1733  return TOKEN_SIGN;
1734 
1735  YY_BREAK
1736  case 64:
1738 #line 505 "function/CEvaluationLexer.lpp"
1739 
1742  yytext);
1743  COMMON_ACTION;
1744  return TOKEN_OPERATOR_POWER;
1745 
1746  YY_BREAK
1747  case 65:
1749 #line 513 "function/CEvaluationLexer.lpp"
1750 
1753  yytext);
1754  COMMON_ACTION;
1755  return TOKEN_OPERATOR_MULTIPLY;
1756 
1757  YY_BREAK
1758  case 66:
1760 #line 521 "function/CEvaluationLexer.lpp"
1761 
1764  yytext);
1765  COMMON_ACTION;
1766  return TOKEN_OPERATOR_MULTIPLY;
1767 
1768  YY_BREAK
1769  case 67:
1771 #line 529 "function/CEvaluationLexer.lpp"
1772 
1775  yytext);
1776  COMMON_ACTION;
1777  return TOKEN_OPERATOR_MODULUS;
1778 
1779  YY_BREAK
1780  case 68:
1782 #line 537 "function/CEvaluationLexer.lpp"
1783 
1786  yytext);
1787  COMMON_ACTION;
1788  return TOKEN_OPERATOR_PLUS;
1789 
1790  YY_BREAK
1791  case 69:
1793 #line 545 "function/CEvaluationLexer.lpp"
1794 
1797  yytext);
1798  COMMON_ACTION;
1799  return TOKEN_OPERATOR_PLUS;
1800 
1801  YY_BREAK
1802  case 70:
1804 #line 553 "function/CEvaluationLexer.lpp"
1805 
1807  mPosition += yyleng;
1808  // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::OPEN,
1809  // yytext);
1810  // COMMON_ACTION;
1811  return TOKEN_STRUCTURE_OPEN;
1812 
1813  YY_BREAK
1814  case 71:
1816 #line 562 "function/CEvaluationLexer.lpp"
1817 
1819  mPosition += yyleng;
1820  // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::VECTOR_OPEN,
1821  // yytext);
1822  // COMMON_ACTION;
1824 
1825  YY_BREAK
1826  case 72:
1828 #line 571 "function/CEvaluationLexer.lpp"
1829 
1831  mPosition += yyleng;
1832  // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::COMMA,
1833  // yytext);
1834  // COMMON_ACTION;
1835  return TOKEN_STRUCTURE_COMMA;
1836 
1837  YY_BREAK
1838  case 73:
1840 #line 580 "function/CEvaluationLexer.lpp"
1841 
1842  BEGIN(sOPERATOR);
1843  mPosition += yyleng;
1844  // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::CLOSE,
1845  // yytext);
1846  // COMMON_ACTION;
1847  return TOKEN_STRUCTURE_CLOSE;
1848 
1849  YY_BREAK
1850  case 74:
1852 #line 589 "function/CEvaluationLexer.lpp"
1853 
1854  BEGIN(sOPERATOR);
1855  mPosition += yyleng;
1856  // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::VECTOR_CLOSE,
1857  // yytext);
1858  // COMMON_ACTION;
1860 
1861  YY_BREAK
1862  case 75:
1863  /* rule 75 can match eol */
1865 #line 598 "function/CEvaluationLexer.lpp"
1866 
1867  BEGIN(sOPERATOR);
1869  yytext);
1870  COMMON_ACTION;
1871  return TOKEN_VARIABLE;
1872 
1873  YY_BREAK
1874  case 76:
1875  /* rule 76 can match eol */
1877 #line 606 "function/CEvaluationLexer.lpp"
1878 
1879  mPosition += yyleng;
1880  // mpNode = new CEvaluationNodeWhiteSpace(CEvaluationNodeWhiteSpace::ANY,
1881  // yytext);
1882  // COMMON_ACTION;
1883 
1884  YY_BREAK
1885  case YY_STATE_EOF(INITIAL):
1886  case YY_STATE_EOF(sSIGNorVALUE):
1887  case YY_STATE_EOF(sOPERATOR):
1888  case YY_STATE_EOF(sVALUE):
1889 #line 613 "function/CEvaluationLexer.lpp"
1890  return 0;
1891  YY_BREAK
1892  case 77:
1894 #line 615 "function/CEvaluationLexer.lpp"
1895 
1897  return YYERRCODE;
1898 
1899  YY_BREAK
1900  case 78:
1902 #line 620 "function/CEvaluationLexer.lpp"
1903  ECHO;
1904  YY_BREAK
1905 #line 1880 "<stdout>"
1906 
1907  case YY_END_OF_BUFFER:
1908  {
1909  /* Amount of text matched not including the EOB char. */
1910  int yy_amount_of_matched_text = (int)(yy_cp - (yytext_ptr)) - 1;
1911 
1912  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1913  *yy_cp = (yy_hold_char);
1915 
1916  if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW)
1917  {
1918  /* We're scanning a new file or input source. It's
1919  * possible that this happened because the user
1920  * just pointed yyin at a new source and called
1921  * yylex(). If so, then we have to assure
1922  * consistency between YY_CURRENT_BUFFER and our
1923  * globals. Here is the right place to do so, because
1924  * this is the first action (other than possibly a
1925  * back-up) that will match for the new input source.
1926  */
1927  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1928  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1929  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1930  }
1931 
1932  /* Note that here we test for yy_c_buf_p "<=" to the position
1933  * of the first EOB in the buffer, since yy_c_buf_p will
1934  * already have been incremented past the NUL character
1935  * (since all states make transitions on EOB to the
1936  * end-of-buffer state). Contrast this with the test
1937  * in input().
1938  */
1939  if ((yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)])
1940  {
1941  /* This was really a NUL. */
1942  yy_state_type yy_next_state;
1943 
1944  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1945 
1946  yy_current_state = yy_get_previous_state();
1947 
1948  /* Okay, we're now positioned to make the NUL
1949  * transition. We couldn't have
1950  * yy_get_previous_state() go ahead and do it
1951  * for us because it doesn't know how to deal
1952  * with the possibility of jamming (and we don't
1953  * want to build jamming into it because then it
1954  * will run more slowly).
1955  */
1956 
1957  yy_next_state = yy_try_NUL_trans(yy_current_state);
1958 
1959  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1960 
1961  if (yy_next_state)
1962  {
1963  /* Consume the NUL. */
1964  yy_cp = ++(yy_c_buf_p);
1965  yy_current_state = yy_next_state;
1966  goto yy_match;
1967  }
1968 
1969  else
1970  {
1971  yy_cp = (yy_last_accepting_cpos);
1972  yy_current_state = (yy_last_accepting_state);
1973  goto yy_find_action;
1974  }
1975  }
1976 
1977  else switch (yy_get_next_buffer())
1978  {
1979  case EOB_ACT_END_OF_FILE:
1980  {
1982 
1983  if (yywrap())
1984  {
1985  /* Note: because we've taken care in
1986  * yy_get_next_buffer() to have set up
1987  * yytext, we can now set up
1988  * yy_c_buf_p so that if some total
1989  * hoser (like flex itself) wants to
1990  * call the scanner after we return the
1991  * YY_NULL, it'll still work - another
1992  * YY_NULL will get returned.
1993  */
1995 
1996  yy_act = YY_STATE_EOF(YY_START);
1997  goto do_action;
1998  }
1999 
2000  else
2001  {
2003  YY_NEW_FILE;
2004  }
2005 
2006  break;
2007  }
2008 
2009  case EOB_ACT_CONTINUE_SCAN:
2010  (yy_c_buf_p) =
2011  (yytext_ptr) + yy_amount_of_matched_text;
2012 
2013  yy_current_state = yy_get_previous_state();
2014 
2015  yy_cp = (yy_c_buf_p);
2016  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2017  goto yy_match;
2018 
2019  case EOB_ACT_LAST_MATCH:
2020  (yy_c_buf_p) =
2021  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2022 
2023  yy_current_state = yy_get_previous_state();
2024 
2025  yy_cp = (yy_c_buf_p);
2026  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2027  goto yy_find_action;
2028  }
2029 
2030  break;
2031  }
2032 
2033  default:
2035  "fatal flex scanner internal error--no action found");
2036  } /* end of action switch */
2037  } /* end of scanning one token */
2038 } /* end of yylex */
#define EOB_ACT_CONTINUE_SCAN
#define YY_SC_TO_UI(c)
#define YY_BUF_SIZE
#define YY_RESTORE_YY_MORE_OFFSET
#define MCFunction
#define YY_BREAK
#define sSIGNorVALUE
unsigned char YY_CHAR
#define YY_MORE_ADJ
#define sOPERATOR
int yyleng
Definition: FlexLexer.h:111
#define YY_BUFFER_NEW
#define YY_USER_INIT
#define YY_BUFFER_NORMAL
#define ECHO
virtual int yywrap()
#define sVALUE
#define YY_STATE_EOF(state)
#define BEGIN
int yy_state_type
Definition: FlexLexer.h:72
#define COMMON_ACTION
static flex_int16_t yy_nxt[879]
#define EOB_ACT_LAST_MATCH
#define YY_FATAL_ERROR(msg)
char * yytext
Definition: FlexLexer.h:110
yy_state_type yy_get_previous_state()
#define YY_RULE_SETUP
#define YY_CURRENT_BUFFER_LVALUE
static flex_int32_t yy_ec[256]
#define YY_CURRENT_BUFFER
#define INITIAL
static flex_int16_t yy_def[384]
struct yy_buffer_state * yy_create_buffer(FLEX_STD istream *s, int size)
#define yytext_ptr
#define TOKEN_NUMBER
#define YY_START
std::ostream * yyout
static flex_int32_t yy_meta[70]
#define YY_DO_BEFORE_ACTION
std::istream * yyin
static flex_int16_t yy_accept[380]
#define YYERRCODE
CEvaluationNode * mpNode
yy_state_type yy_last_accepting_state
static flex_int16_t yy_chk[879]
yy_state_type yy_try_NUL_trans(yy_state_type current_state)
#define EOB_ACT_END_OF_FILE
#define YY_NEW_FILE
static flex_int16_t yy_base[384]
#define YY_END_OF_BUFFER
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().

2650 {
2651  if (!YY_CURRENT_BUFFER)
2652  return;
2653 
2655  YY_CURRENT_BUFFER_LVALUE = NULL;
2656 
2657  if ((yy_buffer_stack_top) > 0)
2658  --(yy_buffer_stack_top);
2659 
2660  if (YY_CURRENT_BUFFER)
2661  {
2664  }
2665 }
#define YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER
void yy_delete_buffer(struct yy_buffer_state *b)
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_bufferThe 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().

2619 {
2620  if (new_buffer == NULL)
2621  return;
2622 
2624 
2625  /* This block is copied from yy_switch_to_buffer. */
2626  if (YY_CURRENT_BUFFER)
2627  {
2628  /* Flush out information for old buffer. */
2629  *(yy_c_buf_p) = (yy_hold_char);
2630  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2631  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2632  }
2633 
2634  /* Only push if top exists. Otherwise, replace top. */
2635  if (YY_CURRENT_BUFFER)
2636  (yy_buffer_stack_top)++;
2637 
2638  YY_CURRENT_BUFFER_LVALUE = new_buffer;
2639 
2640  /* copied from yy_switch_to_buffer. */
2643 }
#define YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER
void CEvaluationLexer::yyrestart ( FLEX_STD istream *  s)

Immediately switch to a different input stream.

Parameters
input_fileA 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.

2449 {
2450 
2451  if (! YY_CURRENT_BUFFER)
2452  {
2456  }
2457 
2458  yy_init_buffer(YY_CURRENT_BUFFER, input_file);
2460 }
#define YY_BUF_SIZE
void yy_init_buffer(struct yy_buffer_state *b, std::istream *s)
#define YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER
struct yy_buffer_state * yy_create_buffer(FLEX_STD istream *s, int size)
std::istream * yyin
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.

2337 {
2338  register char *yy_cp;
2339 
2340  yy_cp = (yy_c_buf_p);
2341 
2342  /* undo effects of setting up yytext */
2343  *yy_cp = (yy_hold_char);
2344 
2345  if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2)
2346  {
2347  /* need to shift things up to make room */
2348  /* +2 for EOB chars. */
2349  register yy_size_t number_to_move = (yy_n_chars) + 2;
2350  register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2351  YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2352  register char *source =
2353  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2354 
2355  while (source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
2356  *--dest = *--source;
2357 
2358  yy_cp += (int)(dest - source);
2359  yy_bp += (int)(dest - source);
2360  YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2361  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2362 
2363  if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2)
2364  YY_FATAL_ERROR("flex scanner push-back overflow");
2365  }
2366 
2367  *--yy_cp = (char) c;
2368 
2369  (yytext_ptr) = yy_bp;
2370  (yy_hold_char) = *yy_cp;
2371  (yy_c_buf_p) = yy_cp;
2372 }
size_t yy_size_t
#define YY_FATAL_ERROR(msg)
#define YY_CURRENT_BUFFER_LVALUE
#define yytext_ptr
if(!yymsg) yymsg
virtual int CEvaluationLexer::yywrap ( )
inlinevirtual

Definition at line 144 of file CEvaluationLexer.h.

144 {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: