COPASI API  4.16.103
CEvaluationLexer_lex.cpp
Go to the documentation of this file.
1 // Copyright (C) 2010 - 2015 by Pedro Mendes, Virginia Tech Intellectual
2 // Properties, Inc., University of Heidelberg, and The University
3 // of Manchester.
4 // All rights reserved.
5 
6 // Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual
7 // Properties, Inc., EML Research, gGmbH, University of Heidelberg,
8 // and The University of Manchester.
9 // All rights reserved.
10 
11 // Copyright (C) 2005 - 2007 by Pedro Mendes, Virginia Tech Intellectual
12 // Properties, Inc. and EML Research, gGmbH.
13 // All rights reserved.
14 
15 #line 3 "<stdout>"
16 
17 #define YY_INT_ALIGNED short int
18 
19 /* A lexical scanner generated by flex */
20 
21 #define FLEX_SCANNER
22 #define YY_FLEX_MAJOR_VERSION 2
23 #define YY_FLEX_MINOR_VERSION 5
24 #define YY_FLEX_SUBMINOR_VERSION 35
25 #if YY_FLEX_SUBMINOR_VERSION > 0
26 #define FLEX_BETA
27 #endif
28 
29 /* The c++ scanner is a mess. The FlexLexer.h header file relies on the
30  * following macro. This is required in order to pass the c++-multiple-scanners
31  * test in the regression suite. We get reports that it breaks inheritance.
32  * We will address this in a future release of flex, or omit the C++ scanner
33  * altogether.
34  */
35 #define yyFlexLexer CEvaluationFlexLexer
36 
37 /* First, we deal with platform-specific or compiler-specific issues. */
38 
39 /* begin standard C headers. */
40 
41 /* end standard C headers. */
42 
43 /* flex integer type definitions */
44 
45 #ifndef FLEXINT_H
46 #define FLEXINT_H
47 
48 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
49 
50 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
51 
52 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
53  * if you want the limit (max/min) macros for int types.
54  */
55 #ifndef __STDC_LIMIT_MACROS
56 #define __STDC_LIMIT_MACROS 1
57 #endif
58 
59 #include <inttypes.h>
60 typedef int8_t flex_int8_t;
61 typedef uint8_t flex_uint8_t;
62 typedef int16_t flex_int16_t;
63 typedef uint16_t flex_uint16_t;
64 typedef int32_t flex_int32_t;
65 typedef uint32_t flex_uint32_t;
66 typedef uint64_t flex_uint64_t;
67 #else
68 typedef signed char flex_int8_t;
69 typedef short int flex_int16_t;
70 typedef int flex_int32_t;
71 typedef unsigned char flex_uint8_t;
72 typedef unsigned short int flex_uint16_t;
73 typedef unsigned int flex_uint32_t;
74 #endif /* ! C99 */
75 
76 /* Limits of integral types. */
77 #ifndef INT8_MIN
78 #define INT8_MIN (-128)
79 #endif
80 #ifndef INT16_MIN
81 #define INT16_MIN (-32767-1)
82 #endif
83 #ifndef INT32_MIN
84 #define INT32_MIN (-2147483647-1)
85 #endif
86 #ifndef INT8_MAX
87 #define INT8_MAX (127)
88 #endif
89 #ifndef INT16_MAX
90 #define INT16_MAX (32767)
91 #endif
92 #ifndef INT32_MAX
93 #define INT32_MAX (2147483647)
94 #endif
95 #ifndef UINT8_MAX
96 #define UINT8_MAX (255U)
97 #endif
98 #ifndef UINT16_MAX
99 #define UINT16_MAX (65535U)
100 #endif
101 #ifndef UINT32_MAX
102 #define UINT32_MAX (4294967295U)
103 #endif
104 
105 #endif /* ! FLEXINT_H */
106 
107 /* begin standard C++ headers. */
108 #include <iostream>
109 #include <errno.h>
110 #include <cstdlib>
111 #include <cstring>
112 /* end standard C++ headers. */
113 
114 #ifdef __cplusplus
115 
116 /* The "const" storage-class-modifier is valid. */
117 #define YY_USE_CONST
118 
119 #else /* ! __cplusplus */
120 
121 /* C99 requires __STDC__ to be defined as 1. */
122 #if defined (__STDC__)
123 
124 #define YY_USE_CONST
125 
126 #endif /* defined (__STDC__) */
127 #endif /* ! __cplusplus */
128 
129 #ifdef YY_USE_CONST
130 #define yyconst const
131 #else
132 #define yyconst
133 #endif
134 
135 /* Returned upon end-of-file. */
136 #define YY_NULL 0
137 
138 /* Promotes a possibly negative, possibly signed char to an unsigned
139  * integer for use as an array index. If the signed char is negative,
140  * we want to instead treat it as an 8-bit unsigned char, hence the
141  * double cast.
142  */
143 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
144 
145 /* Enter a start condition. This macro really ought to take a parameter,
146  * but we do it the disgusting crufty way forced on us by the ()-less
147  * definition of BEGIN.
148  */
149 #define BEGIN (yy_start) = 1 + 2 *
150 
151 /* Translate the current start state into a value that can be later handed
152  * to BEGIN to return to the state. The YYSTATE alias is for lex
153  * compatibility.
154  */
155 #define YY_START (((yy_start) - 1) / 2)
156 #define YYSTATE YY_START
157 
158 /* Action number for EOF rule of a given start state. */
159 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
160 
161 /* Special action meaning "start processing a new file". */
162 #define YY_NEW_FILE yyrestart(yyin)
163 
164 #define YY_END_OF_BUFFER_CHAR 0
165 
166 /* Size of default input buffer. */
167 #ifndef YY_BUF_SIZE
168 #define YY_BUF_SIZE 16384
169 #endif
170 
171 /* The state buf must be large enough to hold one state per character in the main buffer.
172  */
173 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
174 
175 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
176 #define YY_TYPEDEF_YY_BUFFER_STATE
177 typedef struct yy_buffer_state *YY_BUFFER_STATE;
178 #endif
179 
180 #ifndef YY_TYPEDEF_YY_SIZE_T
181 #define YY_TYPEDEF_YY_SIZE_T
182 typedef size_t yy_size_t;
183 #endif
184 
185 extern yy_size_t yyleng;
186 
187 #define EOB_ACT_CONTINUE_SCAN 0
188 #define EOB_ACT_END_OF_FILE 1
189 #define EOB_ACT_LAST_MATCH 2
190 
191 #define YY_LESS_LINENO(n)
192 
193 /* Return all but the first "n" matched characters back to the input stream. */
194 #define yyless(n) \
195  do \
196  {\
197  /* Undo effects of setting up yytext. */ \
198  int yyless_macro_arg = (n); \
199  YY_LESS_LINENO(yyless_macro_arg);\
200  *yy_cp = (yy_hold_char); \
201  YY_RESTORE_YY_MORE_OFFSET \
202  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
203  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
204  } \
205  while (0)
206 
207 #define unput(c) yyunput(c, (yytext_ptr))
208 
209 #ifndef YY_STRUCT_YY_BUFFER_STATE
210 #define YY_STRUCT_YY_BUFFER_STATE
211 struct yy_buffer_state
212 {
213 
214  std::istream* yy_input_file;
215 
216  char *yy_ch_buf; /* input buffer */
217  char *yy_buf_pos; /* current position in input buffer */
218 
219  /* Size of input buffer in bytes, not including room for EOB
220  * characters.
221  */
222  yy_size_t yy_buf_size;
223 
224  /* Number of characters read into yy_ch_buf, not including EOB
225  * characters.
226  */
227  yy_size_t yy_n_chars;
228 
229  /* Whether we "own" the buffer - i.e., we know we created it,
230  * and can realloc() it to grow it, and should free() it to
231  * delete it.
232  */
233  int yy_is_our_buffer;
234 
235  /* Whether this is an "interactive" input source; if so, and
236  * if we're using stdio for input, then we want to use getc()
237  * instead of fread(), to make sure we stop fetching input after
238  * each newline.
239  */
240  int yy_is_interactive;
241 
242  /* Whether we're considered to be at the beginning of a line.
243  * If so, '^' rules will be active on the next match, otherwise
244  * not.
245  */
246  int yy_at_bol;
247 
248  int yy_bs_lineno; /**< The line count. */
249  int yy_bs_column; /**< The column count. */
250 
251  /* Whether to try to fill the input buffer when we reach the
252  * end of it.
253  */
254  int yy_fill_buffer;
255 
256  int yy_buffer_status;
257 
258 #define YY_BUFFER_NEW 0
259 #define YY_BUFFER_NORMAL 1
260  /* When an EOF's been seen but there's still some text to process
261  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
262  * shouldn't try reading from the input source any more. We might
263  * still have a bunch of tokens to match, though, because of
264  * possible backing-up.
265  *
266  * When we actually see the EOF, we change the status to "new"
267  * (via yyrestart()), so that the user can continue scanning by
268  * just pointing yyin at a new input file.
269  */
270 #define YY_BUFFER_EOF_PENDING 2
271 };
272 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
273 
274 /* We provide macros for accessing buffer states in case in the
275  * future we want to put the buffer states in a more general
276  * "scanner state".
277  *
278  * Returns the top of the stack, or NULL.
279  */
280 #define YY_CURRENT_BUFFER ((yy_buffer_stack) \
281  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
282  : NULL)
283 
284 /* Same as previous macro, but useful when we know that the buffer stack is not
285  * NULL or when we need an lvalue. For internal use only.
286  */
287 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
288 
289 void *CEvaluationalloc(yy_size_t);
290 void *CEvaluationrealloc(void *, yy_size_t);
291 void CEvaluationfree(void *);
292 
293 #define yy_new_buffer yy_create_buffer
294 
295 #define yy_set_interactive(is_interactive) \
296  {\
297  if (! YY_CURRENT_BUFFER ){\
298  yyensure_buffer_stack (); \
299  YY_CURRENT_BUFFER_LVALUE = \
300  yy_create_buffer(yyin, YY_BUF_SIZE ); \
301  } \
302  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
303  }
304 
305 #define yy_set_bol(at_bol) \
306  {\
307  if (! YY_CURRENT_BUFFER ){\
308  yyensure_buffer_stack (); \
309  YY_CURRENT_BUFFER_LVALUE = \
310  yy_create_buffer(yyin, YY_BUF_SIZE ); \
311  } \
312  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
313  }
314 
315 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
316 
317 /* Begin user sect3 */
318 
319 typedef unsigned char YY_CHAR;
320 
321 #define yytext_ptr yytext
322 
323 #include "copasi/FlexLexer.h"
324 
325 /* Done after the current pattern has been matched and before the
326  * corresponding action - sets up yytext.
327  */
328 #define YY_DO_BEFORE_ACTION \
329  (yytext_ptr) = yy_bp; \
330  yyleng = (yy_size_t) (yy_cp - yy_bp); \
331  (yy_hold_char) = *yy_cp; \
332  *yy_cp = '\0'; \
333  (yy_c_buf_p) = yy_cp;
334 
335 #define YY_NUM_RULES 78
336 #define YY_END_OF_BUFFER 79
337 /* This struct is not used in this scanner,
338  but its presence is necessary. */
339 struct yy_trans_info
340 {
341  flex_int32_t yy_verify;
342  flex_int32_t yy_nxt;
343 };
344 static yyconst flex_int16_t yy_accept[380] =
345 {
346  0,
347  0, 0, 0, 0, 0, 0, 0, 0, 79, 77,
348  76, 76, 8, 77, 70, 73, 63, 72, 62, 1,
349  1, 77, 75, 75, 75, 75, 75, 75, 75, 75,
350  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
351  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
352  75, 71, 74, 77, 67, 77, 65, 68, 69, 66,
353  10, 77, 12, 77, 77, 77, 77, 77, 77, 77,
354  64, 77, 77, 77, 77, 77, 77, 77, 77, 75,
355  75, 76, 0, 75, 0, 1, 1, 0, 0, 0,
356  18, 0, 61, 75, 75, 75, 75, 75, 75, 75,
357 
358  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
359  75, 75, 75, 75, 3, 75, 75, 75, 75, 75,
360  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
361  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
362  75, 75, 75, 75, 75, 75, 75, 75, 13, 15,
363  9, 14, 11, 0, 12, 10, 17, 0, 0, 0,
364  75, 75, 1, 0, 1, 19, 60, 75, 75, 75,
365  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
366  75, 75, 59, 75, 75, 75, 75, 7, 75, 8,
367  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
368 
369  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
370  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
371  75, 16, 48, 75, 75, 75, 75, 75, 75, 75,
372  24, 75, 28, 75, 27, 75, 75, 22, 75, 75,
373  75, 75, 75, 75, 20, 75, 56, 57, 75, 75,
374  26, 75, 23, 75, 75, 25, 75, 4, 75, 75,
375  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
376  75, 75, 75, 36, 75, 75, 75, 75, 75, 35,
377  37, 50, 30, 34, 33, 75, 75, 75, 5, 75,
378  75, 75, 75, 75, 75, 32, 29, 47, 31, 75,
379 
380  75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
381  75, 75, 75, 75, 75, 75, 75, 58, 75, 75,
382  49, 53, 75, 21, 75, 75, 75, 75, 75, 75,
383  75, 75, 75, 75, 75, 75, 75, 75, 75, 40,
384  75, 39, 75, 38, 75, 75, 75, 75, 75, 75,
385  55, 75, 75, 75, 75, 75, 42, 46, 45, 44,
386  41, 43, 75, 75, 6, 54, 52, 75, 75, 75,
387  75, 75, 75, 51, 75, 75, 75, 2, 0
388 };
389 
390 static yyconst flex_int32_t yy_ec[256] =
391 {
392  0,
393  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
394  1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
395  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
396  1, 2, 4, 5, 1, 1, 6, 7, 1, 8,
397  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
398  18, 18, 18, 18, 18, 18, 18, 1, 1, 19,
399  20, 21, 1, 1, 22, 23, 24, 25, 26, 27,
400  28, 29, 30, 31, 31, 32, 33, 34, 35, 36,
401  37, 38, 39, 40, 41, 31, 31, 42, 43, 31,
402  1, 44, 1, 45, 31, 1, 46, 47, 48, 49,
403 
404  50, 51, 52, 53, 54, 31, 31, 55, 56, 57,
405  58, 59, 60, 61, 62, 63, 64, 31, 31, 65,
406  66, 31, 67, 68, 69, 1, 1, 1, 1, 1,
407  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
410  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
411  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
412  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
413  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
414 
415  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
416  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
417  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
419  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
420  1, 1, 1, 1, 1
421 };
422 
423 static yyconst flex_int32_t yy_meta[70] =
424 {
425  0,
426  1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
427  1, 1, 1, 1, 1, 3, 3, 3, 1, 1,
428  1, 3, 3, 3, 3, 3, 3, 2, 2, 2,
429  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
430  2, 2, 2, 1, 1, 3, 3, 3, 3, 3,
431  3, 2, 2, 2, 2, 2, 2, 2, 2, 2,
432  2, 2, 2, 2, 2, 2, 1, 1, 1
433 };
434 
435 static yyconst flex_int16_t yy_base[384] =
436 {
437  0,
438  0, 0, 0, 0, 69, 0, 135, 136, 808, 809,
439  139, 141, 809, 140, 809, 809, 809, 809, 809, 136,
440  141, 130, 156, 799, 163, 152, 148, 153, 155, 173,
441  164, 175, 195, 174, 198, 200, 179, 202, 165, 168,
442  160, 206, 180, 203, 158, 212, 211, 213, 223, 224,
443  221, 809, 809, 786, 809, 798, 809, 809, 809, 809,
444  784, 783, 782, 767, 763, 207, 208, 773, 760, 762,
445  809, 739, 735, 190, 192, 744, 732, 734, 723, 237,
446  228, 241, 207, 782, 786, 263, 274, 285, 0, 218,
447  809, 785, 778, 778, 229, 274, 286, 267, 285, 276,
448 
449  279, 287, 291, 268, 297, 300, 304, 777, 306, 308,
450  307, 309, 312, 314, 776, 317, 318, 319, 320, 322,
451  323, 330, 324, 326, 331, 333, 332, 336, 337, 340,
452  342, 343, 353, 347, 351, 355, 357, 349, 354, 358,
453  359, 362, 364, 360, 363, 361, 365, 367, 809, 809,
454  809, 809, 809, 758, 809, 809, 809, 744, 732, 719,
455  366, 369, 377, 364, 415, 0, 809, 771, 384, 402,
456  405, 411, 417, 426, 427, 428, 429, 430, 388, 432,
457  435, 436, 769, 368, 442, 769, 768, 767, 439, 766,
458  438, 444, 445, 440, 446, 450, 452, 453, 454, 455,
459 
460  456, 459, 458, 470, 473, 460, 474, 475, 477, 476,
461  479, 482, 478, 481, 480, 488, 490, 483, 491, 495,
462  489, 809, 764, 764, 485, 492, 486, 763, 762, 761,
463  759, 759, 757, 757, 755, 755, 484, 753, 496, 493,
464  499, 511, 525, 497, 752, 375, 751, 750, 540, 513,
465  749, 749, 747, 747, 746, 744, 744, 743, 521, 501,
466  542, 543, 502, 545, 546, 547, 549, 552, 550, 553,
467  557, 556, 558, 741, 566, 559, 562, 565, 567, 740,
468  739, 738, 737, 736, 735, 735, 564, 570, 734, 733,
469  732, 563, 731, 568, 574, 729, 728, 727, 726, 573,
470 
471  569, 571, 572, 576, 577, 579, 580, 583, 587, 586,
472  604, 606, 607, 609, 614, 616, 617, 725, 605, 618,
473  724, 723, 613, 722, 722, 615, 619, 620, 622, 632,
474  639, 642, 643, 646, 647, 648, 649, 651, 710, 706,
475  705, 703, 702, 699, 697, 696, 691, 650, 652, 654,
476  685, 685, 681, 653, 656, 655, 678, 677, 675, 673,
477  672, 670, 658, 659, 669, 380, 376, 660, 662, 661,
478  248, 663, 668, 237, 664, 672, 670, 233, 809, 721,
479  724, 726, 162
480 };
481 
482 static yyconst flex_int16_t yy_def[384] =
483 {
484  0,
485  379, 1, 1, 1, 379, 5, 1, 1, 379, 379,
486  379, 379, 379, 380, 379, 379, 379, 379, 379, 379,
487  379, 381, 382, 382, 382, 382, 382, 382, 382, 382,
488  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
489  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
490  382, 379, 379, 379, 379, 379, 379, 379, 379, 379,
491  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
492  379, 379, 379, 379, 379, 379, 379, 379, 379, 382,
493  382, 379, 380, 379, 380, 379, 379, 379, 383, 381,
494  379, 381, 379, 382, 382, 382, 382, 382, 382, 382,
495 
496  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
497  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
498  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
499  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
500  382, 382, 382, 382, 382, 382, 382, 382, 379, 379,
501  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
502  382, 382, 379, 379, 379, 383, 379, 382, 382, 382,
503  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
504  382, 382, 379, 382, 382, 382, 382, 382, 382, 382,
505  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
506 
507  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
508  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
509  382, 379, 379, 382, 382, 382, 382, 382, 382, 382,
510  379, 382, 379, 382, 379, 382, 382, 379, 382, 382,
511  382, 382, 382, 382, 379, 382, 379, 379, 382, 382,
512  379, 382, 379, 382, 382, 379, 382, 382, 382, 382,
513  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
514  382, 382, 382, 379, 382, 382, 382, 382, 382, 379,
515  379, 379, 379, 379, 379, 382, 382, 382, 382, 382,
516  382, 382, 382, 382, 382, 379, 379, 379, 379, 382,
517 
518  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
519  382, 382, 382, 382, 382, 382, 382, 379, 382, 382,
520  379, 379, 382, 379, 382, 382, 382, 382, 382, 382,
521  382, 382, 382, 382, 382, 382, 382, 382, 382, 379,
522  382, 379, 382, 379, 382, 382, 382, 382, 382, 382,
523  379, 382, 382, 382, 382, 382, 379, 379, 379, 379,
524  379, 379, 382, 382, 382, 379, 379, 382, 382, 382,
525  382, 382, 382, 379, 382, 382, 382, 382, 0, 379,
526  379, 379, 379
527 };
528 
529 static yyconst flex_int16_t yy_nxt[879] =
530 {
531  0,
532  10, 11, 12, 13, 14, 10, 10, 15, 16, 10,
533  17, 18, 19, 10, 10, 20, 21, 21, 22, 10,
534  10, 23, 24, 25, 26, 27, 28, 29, 24, 30,
535  24, 31, 32, 33, 24, 34, 24, 24, 35, 36,
536  37, 24, 24, 10, 10, 38, 24, 39, 40, 41,
537  42, 43, 24, 44, 45, 46, 47, 24, 48, 24,
538  24, 49, 50, 51, 24, 24, 52, 10, 53, 10,
539  11, 12, 54, 10, 55, 56, 15, 16, 57, 58,
540  18, 59, 10, 60, 10, 10, 10, 61, 62, 63,
541  64, 10, 10, 10, 65, 10, 66, 10, 10, 10,
542 
543  67, 10, 68, 69, 10, 10, 10, 10, 10, 10,
544  70, 10, 10, 71, 72, 10, 10, 10, 73, 10,
545  74, 10, 10, 75, 10, 76, 77, 10, 10, 10,
546  10, 10, 10, 78, 10, 52, 79, 53, 10, 10,
547  82, 82, 82, 82, 84, 10, 10, 10, 10, 86,
548  91, 87, 87, 87, 86, 93, 87, 87, 87, 93,
549  93, 88, 93, 93, 166, 93, 88, 93, 80, 80,
550  93, 93, 93, 92, 105, 93, 107, 103, 95, 96,
551  93, 93, 93, 85, 106, 88, 93, 93, 100, 104,
552  88, 81, 81, 97, 98, 99, 111, 101, 110, 108,
553 
554  89, 102, 93, 115, 112, 93, 109, 93, 116, 93,
555  93, 84, 122, 93, 128, 137, 113, 131, 93, 93,
556  93, 120, 129, 117, 132, 135, 130, 118, 93, 114,
557  93, 93, 153, 151, 119, 93, 93, 121, 91, 153,
558  93, 151, 82, 82, 93, 167, 155, 156, 123, 124,
559  85, 133, 155, 108, 156, 374, 140, 138, 113, 136,
560  134, 92, 125, 126, 127, 139, 115, 168, 141, 146,
561  142, 161, 143, 140, 93, 93, 144, 148, 163, 163,
562  163, 93, 145, 93, 147, 162, 93, 86, 88, 87,
563  87, 87, 93, 93, 93, 164, 171, 164, 93, 88,
564 
565  165, 165, 165, 178, 93, 173, 172, 93, 169, 170,
566  176, 93, 88, 93, 93, 93, 93, 174, 175, 93,
567  179, 93, 177, 88, 93, 93, 93, 93, 180, 93,
568  93, 93, 184, 93, 181, 185, 182, 93, 93, 93,
569  93, 192, 187, 93, 93, 188, 191, 93, 186, 93,
570  93, 189, 193, 190, 93, 195, 93, 194, 93, 197,
571  93, 93, 93, 196, 93, 93, 93, 93, 93, 93,
572  93, 93, 93, 93, 93, 93, 93, 201, 199, 165,
573  165, 165, 93, 198, 167, 168, 200, 205, 167, 202,
574  293, 93, 163, 163, 163, 93, 206, 244, 203, 204,
575 
576  208, 207, 88, 189, 210, 212, 211, 209, 213, 93,
577  187, 216, 93, 186, 188, 215, 217, 219, 93, 214,
578  221, 190, 224, 218, 93, 225, 88, 240, 220, 214,
579  165, 165, 165, 231, 233, 235, 93, 238, 228, 93,
580  226, 227, 93, 93, 229, 93, 93, 93, 230, 245,
581  237, 251, 253, 256, 232, 234, 236, 93, 246, 93,
582  93, 93, 93, 93, 239, 231, 93, 93, 243, 242,
583  241, 249, 252, 254, 257, 258, 250, 233, 259, 255,
584  235, 238, 93, 93, 93, 245, 93, 93, 93, 93,
585  93, 93, 93, 93, 270, 251, 93, 253, 256, 93,
586 
587  93, 260, 93, 93, 93, 263, 93, 279, 93, 93,
588  232, 228, 229, 230, 224, 261, 262, 277, 93, 275,
589  93, 278, 234, 276, 289, 236, 286, 288, 93, 287,
590  292, 264, 93, 267, 268, 269, 271, 265, 266, 273,
591  252, 272, 254, 257, 258, 255, 291, 93, 290, 93,
592  93, 295, 93, 93, 93, 300, 93, 93, 301, 93,
593  93, 294, 302, 93, 93, 93, 93, 286, 293, 93,
594  93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
595  93, 93, 314, 93, 93, 315, 93, 93, 305, 319,
596  93, 303, 323, 93, 93, 304, 289, 291, 316, 325,
597 
598  317, 306, 309, 307, 312, 313, 308, 320, 326, 290,
599  327, 93, 93, 93, 340, 311, 342, 310, 330, 331,
600  93, 344, 93, 93, 93, 93, 93, 93, 334, 340,
601  328, 329, 332, 333, 339, 341, 336, 343, 348, 342,
602  335, 325, 345, 337, 346, 347, 344, 349, 352, 93,
603  93, 353, 350, 93, 93, 93, 93, 93, 93, 93,
604  93, 93, 93, 93, 338, 93, 93, 93, 93, 93,
605  93, 93, 339, 364, 341, 93, 93, 93, 167, 93,
606  167, 167, 373, 167, 343, 167, 167, 370, 367, 363,
607  371, 345, 366, 167, 346, 347, 365, 378, 362, 376,
608 
609  355, 369, 354, 361, 360, 352, 353, 167, 375, 359,
610  356, 167, 358, 372, 167, 368, 371, 357, 377, 378,
611  365, 83, 83, 83, 90, 90, 90, 94, 94, 351,
612  167, 167, 167, 167, 167, 167, 167, 167, 324, 322,
613  321, 93, 318, 167, 167, 167, 167, 167, 167, 167,
614  93, 299, 167, 298, 297, 167, 296, 167, 167, 167,
615  167, 167, 285, 167, 284, 167, 283, 167, 282, 281,
616  280, 274, 167, 93, 93, 248, 247, 167, 223, 222,
617  150, 222, 150, 93, 183, 93, 167, 379, 379, 93,
618  157, 160, 157, 149, 152, 159, 158, 157, 149, 152,
619 
620  154, 153, 152, 151, 150, 149, 93, 379, 9, 379,
621  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
622  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
623  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
624  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
625  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
626  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
627  379, 379, 379, 379, 379, 379, 379, 379
628 };
629 
630 static yyconst flex_int16_t yy_chk[879] =
631 {
632  0,
633  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
634  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
635  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
636  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
637  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
638  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
639  1, 1, 1, 1, 1, 1, 1, 1, 1, 5,
640  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
641  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
642  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
643 
644  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
645  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
646  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
647  5, 5, 5, 5, 5, 5, 5, 5, 7, 8,
648  11, 11, 12, 12, 14, 7, 8, 7, 8, 20,
649  22, 20, 20, 20, 21, 27, 21, 21, 21, 26,
650  28, 20, 29, 23, 383, 45, 21, 41, 7, 8,
651  25, 31, 39, 22, 28, 40, 29, 26, 23, 23,
652  30, 34, 32, 14, 28, 20, 37, 43, 25, 27,
653  21, 7, 8, 23, 23, 23, 32, 25, 31, 30,
654 
655  20, 25, 33, 34, 32, 35, 30, 36, 34, 38,
656  44, 83, 37, 42, 39, 45, 33, 40, 47, 46,
657  48, 36, 39, 35, 41, 43, 39, 35, 51, 33,
658  49, 50, 66, 67, 35, 81, 95, 36, 90, 74,
659  378, 75, 82, 82, 80, 374, 66, 67, 38, 38,
660  83, 42, 74, 44, 75, 371, 47, 46, 80, 44,
661  42, 90, 38, 38, 38, 46, 48, 95, 47, 50,
662  48, 80, 49, 81, 98, 104, 49, 51, 86, 86,
663  86, 96, 49, 100, 50, 81, 101, 87, 86, 87,
664  87, 87, 99, 97, 102, 88, 98, 88, 103, 87,
665 
666  88, 88, 88, 104, 105, 100, 99, 106, 96, 97,
667  102, 107, 86, 109, 111, 110, 112, 101, 101, 113,
668  105, 114, 103, 87, 116, 117, 118, 119, 105, 120,
669  121, 123, 109, 124, 106, 110, 107, 122, 125, 127,
670  126, 117, 112, 128, 129, 113, 116, 130, 111, 131,
671  132, 114, 118, 114, 134, 120, 138, 119, 135, 122,
672  133, 139, 136, 121, 137, 140, 141, 144, 146, 142,
673  145, 143, 147, 161, 148, 184, 162, 127, 125, 164,
674  164, 164, 246, 124, 367, 123, 126, 130, 366, 128,
675  246, 169, 163, 163, 163, 179, 131, 184, 129, 129,
676 
677  133, 132, 163, 161, 134, 136, 135, 133, 137, 170,
678  139, 143, 171, 138, 140, 142, 144, 146, 172, 141,
679  148, 141, 169, 145, 173, 170, 163, 179, 147, 162,
680  165, 165, 165, 174, 175, 176, 177, 178, 171, 180,
681  170, 170, 181, 182, 172, 191, 189, 194, 173, 185,
682  177, 192, 193, 195, 174, 175, 176, 196, 185, 197,
683  198, 199, 200, 201, 178, 203, 202, 206, 182, 181,
684  180, 189, 192, 193, 195, 196, 191, 204, 197, 194,
685  205, 207, 208, 210, 209, 213, 211, 215, 214, 212,
686  218, 237, 225, 227, 213, 216, 221, 217, 219, 226,
687 
688  240, 199, 220, 239, 244, 206, 241, 227, 260, 263,
689  203, 200, 201, 202, 198, 199, 199, 226, 242, 225,
690  250, 226, 204, 225, 241, 205, 237, 240, 259, 239,
691  244, 207, 243, 210, 211, 212, 214, 208, 209, 221,
692  216, 215, 217, 219, 220, 218, 243, 249, 242, 261,
693  262, 250, 264, 265, 266, 259, 267, 269, 260, 268,
694  270, 249, 260, 272, 271, 273, 276, 263, 270, 277,
695  292, 287, 278, 275, 279, 294, 301, 288, 302, 303,
696  300, 295, 276, 304, 305, 277, 306, 307, 262, 287,
697  308, 261, 292, 310, 309, 261, 266, 268, 278, 294,
698 
699  279, 264, 271, 265, 275, 275, 269, 288, 295, 267,
700  300, 311, 319, 312, 313, 273, 314, 272, 302, 303,
701  323, 315, 326, 316, 317, 320, 327, 328, 306, 329,
702  301, 301, 304, 305, 312, 313, 308, 314, 319, 330,
703  307, 309, 315, 310, 316, 317, 331, 320, 326, 332,
704  333, 327, 323, 334, 335, 336, 337, 348, 338, 349,
705  354, 350, 356, 355, 311, 363, 364, 368, 370, 369,
706  372, 375, 328, 349, 329, 373, 365, 377, 362, 376,
707  361, 360, 370, 359, 330, 358, 357, 363, 353, 348,
708  364, 331, 352, 351, 332, 333, 350, 376, 347, 373,
709 
710  335, 355, 334, 346, 345, 337, 338, 344, 372, 343,
711  336, 342, 341, 368, 340, 354, 369, 339, 375, 377,
712  356, 380, 380, 380, 381, 381, 381, 382, 382, 325,
713  324, 322, 321, 318, 299, 298, 297, 296, 293, 291,
714  290, 289, 286, 285, 284, 283, 282, 281, 280, 274,
715  258, 257, 256, 255, 254, 253, 252, 251, 248, 247,
716  245, 238, 236, 235, 234, 233, 232, 231, 230, 229,
717  228, 224, 223, 190, 188, 187, 186, 183, 168, 160,
718  159, 158, 154, 115, 108, 94, 93, 92, 85, 84,
719  79, 78, 77, 76, 73, 72, 70, 69, 68, 65,
720 
721  64, 63, 62, 61, 56, 54, 24, 9, 379, 379,
722  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
723  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
724  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
725  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
726  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
727  379, 379, 379, 379, 379, 379, 379, 379, 379, 379,
728  379, 379, 379, 379, 379, 379, 379, 379
729 };
730 
731 /* The intent behind this definition is that it'll catch
732  * any uses of REJECT which flex missed.
733  */
734 #define REJECT reject_used_but_not_detected
735 #define yymore() yymore_used_but_not_detected
736 #define YY_MORE_ADJ 0
737 #define YY_RESTORE_YY_MORE_OFFSET
738 #line 1 "function/CEvaluationLexer.lpp"
739 /* scanner for kinetic functions */
740 
741 #line 10 "function/CEvaluationLexer.lpp"
742 #include <vector>
743 
744 #include "copasi.h"
745 #include "CEvaluationNode.h"
746 #include "CEvaluationLexer.h"
747 #include "CEvaluationParser_yacc.hpp"
748 
749 #ifndef YYERRCODE
750 #define YYERRCODE 256
751 #endif
752 
753 #define YY_USER_INIT \
754  mpNode = NULL;\
755  mPosition = 0;\
756  mpNodeList = new std::vector< CEvaluationNode * >;
757 
758 #define COMMON_ACTION \
759  mPosition += yyleng;\
760  mpNodeList->push_back(mpNode);
761 
762 #line 744 "<stdout>"
763 
764 #define INITIAL 0
765 #define sSIGNorVALUE 1
766 #define sOPERATOR 2
767 #define sVALUE 3
768 
769 #ifndef YY_NO_UNISTD_H
770 /* Special case for "unistd.h", since it is non-ANSI. We include it way
771  * down here because we want the user's section 1 to have been scanned first.
772  * The user has a chance to override it with an option.
773  */
774 #endif
775 
776 #ifndef YY_EXTRA_TYPE
777 #define YY_EXTRA_TYPE void *
778 #endif
779 
780 #ifndef yytext_ptr
781 static void yy_flex_strncpy(char *, yyconst char *, int);
782 #endif
783 
784 #ifdef YY_NEED_STRLEN
785 static int yy_flex_strlen(yyconst char *);
786 #endif
787 
788 #ifndef YY_NO_INPUT
789 
790 #endif
791 
792 /* Amount of stuff to slurp up with each read. */
793 #ifndef YY_READ_BUF_SIZE
794 #define YY_READ_BUF_SIZE 8192
795 #endif
796 
797 /* Copy whatever the last rule matched to the standard output. */
798 #ifndef ECHO
799 #define ECHO LexerOutput(yytext, yyleng)
800 #endif
801 
802 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
803  * is returned in "result".
804  */
805 #ifndef YY_INPUT
806 #define YY_INPUT(buf,result,max_size) \
807  \
808  if ((result = LexerInput((char *) buf, max_size )) < 0 ) \
809  YY_FATAL_ERROR("input in flex scanner failed" );
810 
811 #endif
812 
813 /* No semi-colon after return; correct usage is to write "yyterminate();" -
814  * we don't want an extra ';' after the "return" because that will cause
815  * some compilers to complain about unreachable statements.
816  */
817 #ifndef yyterminate
818 #define yyterminate() return YY_NULL
819 #endif
820 
821 /* Number of entries by which start-condition stack grows. */
822 #ifndef YY_START_STACK_INCR
823 #define YY_START_STACK_INCR 25
824 #endif
825 
826 /* Report a fatal error. */
827 #ifndef YY_FATAL_ERROR
828 #define YY_FATAL_ERROR(msg) LexerError(msg)
829 #endif
830 
831 /* end tables serialization structures and prototypes */
832 
833 /* Default declaration of generated scanner - a define so the user can
834  * easily add parameters.
835  */
836 #ifndef YY_DECL
837 #define YY_DECL_IS_OURS 1
838 #define YY_DECL int yyFlexLexer::yylex()
839 #endif /* !YY_DECL */
840 
841 /* Code executed at the beginning of each rule, after yytext and yyleng
842  * have been set up.
843  */
844 #ifndef YY_USER_ACTION
845 #define YY_USER_ACTION
846 #endif
847 
848 /* Code executed at the end of each rule. */
849 #ifndef YY_BREAK
850 #define YY_BREAK break;
851 #endif
852 
853 #define YY_RULE_SETUP \
854  YY_USER_ACTION
855 
856 /** The main scanner function which does all the work.
857  */
858 YY_DECL
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  {
887  yyensure_buffer_stack();
888  YY_CURRENT_BUFFER_LVALUE =
889  yy_create_buffer(yyin, YY_BUF_SIZE);
890  }
891 
892  yy_load_buffer_state();
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 
939  YY_DO_BEFORE_ACTION;
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:
954  YY_RULE_SETUP
955 #line 37 "function/CEvaluationLexer.lpp"
956 
957  BEGIN(sOPERATOR);
958  mpNode = new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE,
959  yytext);
960  COMMON_ACTION;
961  return TOKEN_NUMBER;
962 
963  YY_BREAK
964  case 2:
965  YY_RULE_SETUP
966 #line 45 "function/CEvaluationLexer.lpp"
967 
968  BEGIN(sOPERATOR);
969  mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::EXPONENTIALE,
970  yytext);
971  COMMON_ACTION;
972  return TOKEN_NUMBER;
973 
974  YY_BREAK
975  case 3:
976  YY_RULE_SETUP
977 #line 53 "function/CEvaluationLexer.lpp"
978 
979  BEGIN(sOPERATOR);
980  mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::PI,
981  yytext);
982  COMMON_ACTION;
983  return TOKEN_NUMBER;
984 
985  YY_BREAK
986  case 4:
987  YY_RULE_SETUP
988 #line 61 "function/CEvaluationLexer.lpp"
989 
990  BEGIN(sOPERATOR);
991  mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::TRUE,
992  yytext);
993  COMMON_ACTION;
994  return TOKEN_LOGICAL_VALUE;
995 
996  YY_BREAK
997  case 5:
998  YY_RULE_SETUP
999 #line 69 "function/CEvaluationLexer.lpp"
1000 
1001  BEGIN(sOPERATOR);
1002  mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::FALSE,
1003  yytext);
1004  COMMON_ACTION;
1005  return TOKEN_LOGICAL_VALUE;
1006 
1007  YY_BREAK
1008  case 6:
1009  YY_RULE_SETUP
1010 #line 77 "function/CEvaluationLexer.lpp"
1011 
1012  BEGIN(sOPERATOR);
1013  mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY,
1014  yytext);
1015  COMMON_ACTION;
1016  return TOKEN_NUMBER;
1017 
1018  YY_BREAK
1019  case 7:
1020  YY_RULE_SETUP
1021 #line 85 "function/CEvaluationLexer.lpp"
1022 
1023  BEGIN(sOPERATOR);
1024  mpNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN,
1025  yytext);
1026  COMMON_ACTION;
1027  return TOKEN_NUMBER;
1028 
1029  YY_BREAK
1030  case 8:
1031  YY_RULE_SETUP
1032 #line 93 "function/CEvaluationLexer.lpp"
1033 
1034  BEGIN(sVALUE);
1035  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::NOT,
1036  yytext);
1037  COMMON_ACTION;
1038  return TOKEN_LOGICAL_NOT;
1039 
1040  YY_BREAK
1041  case 9:
1042  YY_RULE_SETUP
1043 #line 101 "function/CEvaluationLexer.lpp"
1044 
1045  BEGIN(sSIGNorVALUE);
1046  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::LE,
1047  yytext);
1048  COMMON_ACTION;
1049  return TOKEN_LOGICAL_LE;
1050 
1051  YY_BREAK
1052  case 10:
1053  YY_RULE_SETUP
1054 #line 109 "function/CEvaluationLexer.lpp"
1055 
1056  BEGIN(sSIGNorVALUE);
1057  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::LT,
1058  yytext);
1059  COMMON_ACTION;
1060  return TOKEN_LOGICAL_LT;
1061 
1062  YY_BREAK
1063  case 11:
1064  YY_RULE_SETUP
1065 #line 117 "function/CEvaluationLexer.lpp"
1066 
1067  BEGIN(sSIGNorVALUE);
1068  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::GE,
1069  yytext);
1070  COMMON_ACTION;
1071  return TOKEN_LOGICAL_GE;
1072 
1073  YY_BREAK
1074  case 12:
1075  YY_RULE_SETUP
1076 #line 125 "function/CEvaluationLexer.lpp"
1077 
1078  BEGIN(sSIGNorVALUE);
1079  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::GT,
1080  yytext);
1081  COMMON_ACTION;
1082  return TOKEN_LOGICAL_GT;
1083 
1084  YY_BREAK
1085  case 13:
1086  YY_RULE_SETUP
1087 #line 133 "function/CEvaluationLexer.lpp"
1088 
1089  BEGIN(sSIGNorVALUE);
1090  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::NE,
1091  yytext);
1092  COMMON_ACTION;
1093  return TOKEN_LOGICAL_NE;
1094 
1095  YY_BREAK
1096  case 14:
1097  YY_RULE_SETUP
1098 #line 141 "function/CEvaluationLexer.lpp"
1099 
1100  BEGIN(sSIGNorVALUE);
1101  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::EQ,
1102  yytext);
1103  COMMON_ACTION;
1104  return TOKEN_LOGICAL_EQ;
1105 
1106  YY_BREAK
1107  case 15:
1108  YY_RULE_SETUP
1109 #line 149 "function/CEvaluationLexer.lpp"
1110 
1111  BEGIN(sSIGNorVALUE);
1112  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::AND,
1113  yytext);
1114  COMMON_ACTION;
1115  return TOKEN_LOGICAL_AND;
1116 
1117  YY_BREAK
1118  case 16:
1119  YY_RULE_SETUP
1120 #line 157 "function/CEvaluationLexer.lpp"
1121 
1122  BEGIN(sSIGNorVALUE);
1123  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::XOR,
1124  yytext);
1125  COMMON_ACTION;
1126  return TOKEN_LOGICAL_XOR;
1127 
1128  YY_BREAK
1129  case 17:
1130  YY_RULE_SETUP
1131 #line 165 "function/CEvaluationLexer.lpp"
1132 
1133  BEGIN(sSIGNorVALUE);
1134  mpNode = new CEvaluationNodeLogical(CEvaluationNodeLogical::OR,
1135  yytext);
1136  COMMON_ACTION;
1137  return TOKEN_LOGICAL_OR;
1138 
1139  YY_BREAK
1140  case 18:
1141  /* rule 18 can match eol */
1142  YY_RULE_SETUP
1143 #line 173 "function/CEvaluationLexer.lpp"
1144 
1145  BEGIN(sOPERATOR);
1146  mpNode = new CEvaluationNodeObject(CEvaluationNodeObject::CN,
1147  yytext);
1148  COMMON_ACTION;
1149  return TOKEN_NUMBER;
1150 
1151  YY_BREAK
1152  case 19:
1153  YY_RULE_SETUP
1154 #line 181 "function/CEvaluationLexer.lpp"
1155 
1156  BEGIN(sOPERATOR);
1157  mpNode = new CEvaluationNodeObject(CEvaluationNodeObject::POINTER,
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 */
1167  YY_RULE_SETUP
1168 #line 189 "function/CEvaluationLexer.lpp"
1169 
1170  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::LOG,
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 */
1180  YY_RULE_SETUP
1181 #line 196 "function/CEvaluationLexer.lpp"
1182 
1183  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::LOG10,
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 */
1193  YY_RULE_SETUP
1194 #line 203 "function/CEvaluationLexer.lpp"
1195 
1196  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::EXP,
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 */
1206  YY_RULE_SETUP
1207 #line 210 "function/CEvaluationLexer.lpp"
1208 
1209  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SIN,
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 */
1219  YY_RULE_SETUP
1220 #line 217 "function/CEvaluationLexer.lpp"
1221 
1222  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COS,
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 */
1232  YY_RULE_SETUP
1233 #line 224 "function/CEvaluationLexer.lpp"
1234 
1235  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::TAN,
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 */
1245  YY_RULE_SETUP
1246 #line 231 "function/CEvaluationLexer.lpp"
1247 
1248  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SEC,
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 */
1258  YY_RULE_SETUP
1259 #line 238 "function/CEvaluationLexer.lpp"
1260 
1261  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::CSC,
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 */
1271  YY_RULE_SETUP
1272 #line 245 "function/CEvaluationLexer.lpp"
1273 
1274  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COT,
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 */
1284  YY_RULE_SETUP
1285 #line 252 "function/CEvaluationLexer.lpp"
1286 
1287  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SINH,
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 */
1297  YY_RULE_SETUP
1298 #line 259 "function/CEvaluationLexer.lpp"
1299 
1300  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COSH,
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 */
1310  YY_RULE_SETUP
1311 #line 266 "function/CEvaluationLexer.lpp"
1312 
1313  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::TANH,
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 */
1323  YY_RULE_SETUP
1324 #line 273 "function/CEvaluationLexer.lpp"
1325 
1326  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SECH,
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 */
1336  YY_RULE_SETUP
1337 #line 280 "function/CEvaluationLexer.lpp"
1338 
1339  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::CSCH,
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 */
1349  YY_RULE_SETUP
1350 #line 287 "function/CEvaluationLexer.lpp"
1351 
1352  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::COTH,
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 */
1362  YY_RULE_SETUP
1363 #line 294 "function/CEvaluationLexer.lpp"
1364 
1365  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSIN,
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 */
1375  YY_RULE_SETUP
1376 #line 301 "function/CEvaluationLexer.lpp"
1377 
1378  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOS,
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 */
1388  YY_RULE_SETUP
1389 #line 308 "function/CEvaluationLexer.lpp"
1390 
1391  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCTAN,
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 */
1401  YY_RULE_SETUP
1402 #line 315 "function/CEvaluationLexer.lpp"
1403 
1404  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSEC,
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 */
1414  YY_RULE_SETUP
1415 #line 322 "function/CEvaluationLexer.lpp"
1416 
1417  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCSC,
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 */
1427  YY_RULE_SETUP
1428 #line 329 "function/CEvaluationLexer.lpp"
1429 
1430  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOT,
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 */
1440  YY_RULE_SETUP
1441 #line 336 "function/CEvaluationLexer.lpp"
1442 
1443  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSINH,
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 */
1453  YY_RULE_SETUP
1454 #line 343 "function/CEvaluationLexer.lpp"
1455 
1456  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOSH,
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 */
1466  YY_RULE_SETUP
1467 #line 350 "function/CEvaluationLexer.lpp"
1468 
1469  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCTANH,
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 */
1479  YY_RULE_SETUP
1480 #line 357 "function/CEvaluationLexer.lpp"
1481 
1482  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCSECH,
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 */
1492  YY_RULE_SETUP
1493 #line 364 "function/CEvaluationLexer.lpp"
1494 
1495  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCSCH,
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 */
1505  YY_RULE_SETUP
1506 #line 371 "function/CEvaluationLexer.lpp"
1507 
1508  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ARCCOTH,
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 */
1518  YY_RULE_SETUP
1519 #line 378 "function/CEvaluationLexer.lpp"
1520 
1521  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::SQRT,
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 */
1531  YY_RULE_SETUP
1532 #line 385 "function/CEvaluationLexer.lpp"
1533 
1534  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::ABS,
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 */
1544  YY_RULE_SETUP
1545 #line 392 "function/CEvaluationLexer.lpp"
1546 
1547  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::FLOOR,
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 */
1557  YY_RULE_SETUP
1558 #line 399 "function/CEvaluationLexer.lpp"
1559 
1560  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::CEIL,
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 */
1570  YY_RULE_SETUP
1571 #line 406 "function/CEvaluationLexer.lpp"
1572 
1573  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::FACTORIAL,
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 */
1583  YY_RULE_SETUP
1584 #line 413 "function/CEvaluationLexer.lpp"
1585 
1586  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RUNIFORM,
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 */
1596  YY_RULE_SETUP
1597 #line 420 "function/CEvaluationLexer.lpp"
1598 
1599  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RGAMMA,
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 */
1609  YY_RULE_SETUP
1610 #line 427 "function/CEvaluationLexer.lpp"
1611 
1612  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RPOISSON,
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 */
1622  YY_RULE_SETUP
1623 #line 434 "function/CEvaluationLexer.lpp"
1624 
1625  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::RNORMAL,
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 */
1635  YY_RULE_SETUP
1636 #line 441 "function/CEvaluationLexer.lpp"
1637 
1638  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MAX,
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 */
1648  YY_RULE_SETUP
1649 #line 448 "function/CEvaluationLexer.lpp"
1650 
1651  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MIN,
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 */
1661  YY_RULE_SETUP
1662 #line 455 "function/CEvaluationLexer.lpp"
1663 
1664  mpNode = new CEvaluationNodeDelay(CEvaluationNodeDelay::DELAY,
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 */
1674  YY_RULE_SETUP
1675 #line 462 "function/CEvaluationLexer.lpp"
1676 
1677  mpNode = new CEvaluationNodeChoice(CEvaluationNodeChoice::IF,
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 */
1688  YY_RULE_SETUP
1689 #line 469 "function/CEvaluationLexer.lpp"
1690 
1691  {
1692  std::string tmp(yytext);
1693  mpNode = new CEvaluationNodeCall(CEvaluationNodeCall::EXPRESSION,
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 */
1702  YY_RULE_SETUP
1703 #line 479 "function/CEvaluationLexer.lpp"
1704 
1705  {
1706  std::string tmp(yytext);
1707  mpNode = new CEvaluationNodeCall(CEvaluationNodeCall::FUNCTION,
1708  tmp.substr(0, tmp.length() - 1));
1709  }
1710  COMMON_ACTION;
1711  return TOKEN_CALL;
1712 
1713  YY_BREAK
1714  case 62:
1715  YY_RULE_SETUP
1716 #line 489 "function/CEvaluationLexer.lpp"
1717 
1718  BEGIN(sVALUE);
1719  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS,
1720  yytext);
1721  COMMON_ACTION;
1722  return TOKEN_SIGN;
1723 
1724  YY_BREAK
1725  case 63:
1726  YY_RULE_SETUP
1727 #line 497 "function/CEvaluationLexer.lpp"
1728 
1729  BEGIN(sVALUE);
1730  mpNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::PLUS,
1731  yytext);
1732  COMMON_ACTION;
1733  return TOKEN_SIGN;
1734 
1735  YY_BREAK
1736  case 64:
1737  YY_RULE_SETUP
1738 #line 505 "function/CEvaluationLexer.lpp"
1739 
1740  BEGIN(sSIGNorVALUE);
1741  mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER,
1742  yytext);
1743  COMMON_ACTION;
1744  return TOKEN_OPERATOR_POWER;
1745 
1746  YY_BREAK
1747  case 65:
1748  YY_RULE_SETUP
1749 #line 513 "function/CEvaluationLexer.lpp"
1750 
1751  BEGIN(sSIGNorVALUE);
1752  mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY,
1753  yytext);
1754  COMMON_ACTION;
1755  return TOKEN_OPERATOR_MULTIPLY;
1756 
1757  YY_BREAK
1758  case 66:
1759  YY_RULE_SETUP
1760 #line 521 "function/CEvaluationLexer.lpp"
1761 
1762  BEGIN(sSIGNorVALUE);
1763  mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE,
1764  yytext);
1765  COMMON_ACTION;
1766  return TOKEN_OPERATOR_MULTIPLY;
1767 
1768  YY_BREAK
1769  case 67:
1770  YY_RULE_SETUP
1771 #line 529 "function/CEvaluationLexer.lpp"
1772 
1773  BEGIN(sSIGNorVALUE);
1774  mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MODULUS,
1775  yytext);
1776  COMMON_ACTION;
1777  return TOKEN_OPERATOR_MODULUS;
1778 
1779  YY_BREAK
1780  case 68:
1781  YY_RULE_SETUP
1782 #line 537 "function/CEvaluationLexer.lpp"
1783 
1784  BEGIN(sSIGNorVALUE);
1785  mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::PLUS,
1786  yytext);
1787  COMMON_ACTION;
1788  return TOKEN_OPERATOR_PLUS;
1789 
1790  YY_BREAK
1791  case 69:
1792  YY_RULE_SETUP
1793 #line 545 "function/CEvaluationLexer.lpp"
1794 
1795  BEGIN(sSIGNorVALUE);
1796  mpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS,
1797  yytext);
1798  COMMON_ACTION;
1799  return TOKEN_OPERATOR_PLUS;
1800 
1801  YY_BREAK
1802  case 70:
1803  YY_RULE_SETUP
1804 #line 553 "function/CEvaluationLexer.lpp"
1805 
1806  BEGIN(sSIGNorVALUE);
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:
1815  YY_RULE_SETUP
1816 #line 562 "function/CEvaluationLexer.lpp"
1817 
1818  BEGIN(sSIGNorVALUE);
1819  mPosition += yyleng;
1820  // mpNode = new CEvaluationNodeStructure(CEvaluationNodeStructure::VECTOR_OPEN,
1821  // yytext);
1822  // COMMON_ACTION;
1823  return TOKEN_STRUCTURE_VECTOR_OPEN;
1824 
1825  YY_BREAK
1826  case 72:
1827  YY_RULE_SETUP
1828 #line 571 "function/CEvaluationLexer.lpp"
1829 
1830  BEGIN(sSIGNorVALUE);
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:
1839  YY_RULE_SETUP
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:
1851  YY_RULE_SETUP
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;
1859  return TOKEN_STRUCTURE_VECTOR_CLOSE;
1860 
1861  YY_BREAK
1862  case 75:
1863  /* rule 75 can match eol */
1864  YY_RULE_SETUP
1865 #line 598 "function/CEvaluationLexer.lpp"
1866 
1867  BEGIN(sOPERATOR);
1868  mpNode = new CEvaluationNodeVariable(CEvaluationNodeVariable::ANY,
1869  yytext);
1870  COMMON_ACTION;
1871  return TOKEN_VARIABLE;
1872 
1873  YY_BREAK
1874  case 76:
1875  /* rule 76 can match eol */
1876  YY_RULE_SETUP
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:
1893  YY_RULE_SETUP
1894 #line 615 "function/CEvaluationLexer.lpp"
1895 
1896  CCopasiMessage(CCopasiMessage::ERROR, MCFunction + 2, mPosition);
1897  return YYERRCODE;
1898 
1899  YY_BREAK
1900  case 78:
1901  YY_RULE_SETUP
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);
1914  YY_RESTORE_YY_MORE_OFFSET
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  {
1981  (yy_did_buffer_switch_on_eof) = 0;
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  */
1994  (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1995 
1996  yy_act = YY_STATE_EOF(YY_START);
1997  goto do_action;
1998  }
1999 
2000  else
2001  {
2002  if (!(yy_did_buffer_switch_on_eof))
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:
2034  YY_FATAL_ERROR(
2035  "fatal flex scanner internal error--no action found");
2036  } /* end of action switch */
2037  } /* end of scanning one token */
2038 } /* end of yylex */
2039 
2040 /* The contents of this function are C++ specific, so the () macro is not used.
2041  */
2042 yyFlexLexer::yyFlexLexer(std::istream* arg_yyin, std::ostream* arg_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 
2052  yy_did_buffer_switch_on_eof = 0;
2053 
2054  yy_looking_for_trail_begin = 0;
2055  yy_more_flag = 0;
2056  yy_more_len = 0;
2057  yy_more_offset = yy_prev_more_offset = 0;
2058 
2059  yy_start_stack_ptr = yy_start_stack_depth = 0;
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 }
2068 
2069 /* The contents of this function are C++ specific, so the () macro is not used.
2070  */
2071 yyFlexLexer::~yyFlexLexer()
2072 {
2073  delete [] yy_state_buf;
2074  CEvaluationfree(yy_start_stack);
2075  yy_delete_buffer(YY_CURRENT_BUFFER);
2076  CEvaluationfree(yy_buffer_stack);
2077 }
2078 
2079 /* The contents of this function are C++ specific, so the () macro is not used.
2080  */
2081 void yyFlexLexer::switch_streams(std::istream* new_in, std::ostream* new_out)
2082 {
2083  if (new_in)
2084  {
2085  yy_delete_buffer(YY_CURRENT_BUFFER);
2086  yy_switch_to_buffer(yy_create_buffer(new_in, YY_BUF_SIZE));
2087  }
2088 
2089  if (new_out)
2090  yyout = new_out;
2091 }
2092 
2093 #ifdef YY_INTERACTIVE
2094 size_t yyFlexLexer::LexerInput(char* buf, size_t /* max_size */)
2095 #else
2096 size_t yyFlexLexer::LexerInput(char* buf, size_t max_size)
2097 #endif
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 }
2123 
2124 void yyFlexLexer::LexerOutput(const char* buf, size_t size)
2125 {
2126  (void) yyout->write(buf, size);
2127 }
2128 
2129 /* yy_get_next_buffer - try to read in a new buffer
2130  *
2131  * Returns a code representing an action:
2132  * EOB_ACT_LAST_MATCH -
2133  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2134  * EOB_ACT_END_OF_FILE - end of file
2135  */
2136 int yyFlexLexer::yy_get_next_buffer()
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])
2144  YY_FATAL_ERROR(
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 */
2191  YY_BUFFER_STATE b = YY_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)
2214  YY_FATAL_ERROR(
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 =
2245  YY_BUFFER_EOF_PENDING;
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;
2263  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2264  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2265 
2266  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2267 
2268  return ret_val;
2269 }
2270 
2271 /* yy_get_previous_state - get the state just before the EOB char was reached */
2272 
2273 yy_state_type yyFlexLexer::yy_get_previous_state()
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 }
2303 
2304 /* yy_try_NUL_trans - try to make a transition on the NUL character
2305  *
2306  * synopsis
2307  * next_state = yy_try_NUL_trans(current_state );
2308  */
2309 yy_state_type yyFlexLexer::yy_try_NUL_trans(yy_state_type yy_current_state)
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 }
2335 
2336 void yyFlexLexer::yyunput(int c, register char* yy_bp)
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 }
2373 
2374 int yyFlexLexer::yyinput()
2375 {
2376  int c;
2377 
2378  *(yy_c_buf_p) = (yy_hold_char);
2379 
2380  if (*(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR)
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 
2419  if (!(yy_did_buffer_switch_on_eof))
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 }
2442 
2443 /** Immediately switch to a different input stream.
2444  * @param input_file A readable stream.
2445  *
2446  * @note This function does not reset the start condition to @c INITIAL .
2447  */
2448 void yyFlexLexer::yyrestart(std::istream* input_file)
2449 {
2450 
2451  if (! YY_CURRENT_BUFFER)
2452  {
2453  yyensure_buffer_stack();
2454  YY_CURRENT_BUFFER_LVALUE =
2455  yy_create_buffer(yyin, YY_BUF_SIZE);
2456  }
2457 
2458  yy_init_buffer(YY_CURRENT_BUFFER, input_file);
2459  yy_load_buffer_state();
2460 }
2461 
2462 /** Switch to a different input buffer.
2463  * @param new_buffer The new input buffer.
2464  *
2465  */
2466 void yyFlexLexer::yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
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  */
2474  yyensure_buffer_stack();
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;
2488  yy_load_buffer_state();
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  */
2495  (yy_did_buffer_switch_on_eof) = 1;
2496 }
2497 
2498 void yyFlexLexer::yy_load_buffer_state()
2499 {
2500  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2501  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2502  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2503  (yy_hold_char) = *(yy_c_buf_p);
2504 }
2505 
2506 /** Allocate and initialize an input buffer state.
2507  * @param file A readable stream.
2508  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2509  *
2510  * @return the allocated buffer state.
2511  */
2512 YY_BUFFER_STATE yyFlexLexer::yy_create_buffer(std::istream* file, int size)
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 }
2537 
2538 /** Destroy the buffer.
2539  * @param b a buffer created with yy_create_buffer()
2540  *
2541  */
2542 void yyFlexLexer::yy_delete_buffer(YY_BUFFER_STATE b)
2543 {
2544 
2545  if (! b)
2546  return;
2547 
2548  if (b == YY_CURRENT_BUFFER) /* Not sure if we should pop here. */
2549  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2550 
2551  if (b->yy_is_our_buffer)
2552  CEvaluationfree((void *) b->yy_ch_buf);
2553 
2554  CEvaluationfree((void *) b);
2555 }
2556 
2557 /* Initializes or reinitializes a buffer.
2558  * This function is sometimes called more than once on the same buffer,
2559  * such as during a yyrestart() or at EOF.
2560  */
2561 void yyFlexLexer::yy_init_buffer(YY_BUFFER_STATE b, std::istream* file)
2562 
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 }
2584 
2585 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2586  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2587  *
2588  */
2589 void yyFlexLexer::yy_flush_buffer(YY_BUFFER_STATE b)
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  */
2600  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2601  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2602 
2603  b->yy_buf_pos = &b->yy_ch_buf[0];
2604 
2605  b->yy_at_bol = 1;
2606  b->yy_buffer_status = YY_BUFFER_NEW;
2607 
2608  if (b == YY_CURRENT_BUFFER)
2609  yy_load_buffer_state();
2610 }
2611 
2612 /** Pushes the new state onto the stack. The new state becomes
2613  * the current state. This function will allocate the stack
2614  * if necessary.
2615  * @param new_buffer The new state.
2616  *
2617  */
2618 void yyFlexLexer::yypush_buffer_state(YY_BUFFER_STATE new_buffer)
2619 {
2620  if (new_buffer == NULL)
2621  return;
2622 
2623  yyensure_buffer_stack();
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. */
2641  yy_load_buffer_state();
2642  (yy_did_buffer_switch_on_eof) = 1;
2643 }
2644 
2645 /** Removes and deletes the top of the stack, if present.
2646  * The next element becomes the new top.
2647  *
2648  */
2649 void yyFlexLexer::yypop_buffer_state(void)
2650 {
2651  if (!YY_CURRENT_BUFFER)
2652  return;
2653 
2654  yy_delete_buffer(YY_CURRENT_BUFFER);
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  {
2662  yy_load_buffer_state();
2663  (yy_did_buffer_switch_on_eof) = 1;
2664  }
2665 }
2666 
2667 /* Allocates the stack if it does not exist.
2668  * Guarantees space for at least one push.
2669  */
2670 void yyFlexLexer::yyensure_buffer_stack(void)
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;
2682  (yy_buffer_stack) = (struct yy_buffer_state**)CEvaluationalloc
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;
2703  (yy_buffer_stack) = (struct yy_buffer_state**)CEvaluationrealloc
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 }
2716 
2717 void yyFlexLexer::yy_push_state(int new_state)
2718 {
2719  if ((yy_start_stack_ptr) >= (yy_start_stack_depth))
2720  {
2721  yy_size_t new_size;
2722 
2723  (yy_start_stack_depth) += YY_START_STACK_INCR;
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 
2736  (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
2737 
2738  BEGIN(new_state);
2739 }
2740 
2741 void yyFlexLexer::yy_pop_state()
2742 {
2743  if (--(yy_start_stack_ptr) < 0)
2744  YY_FATAL_ERROR("start-condition stack underflow");
2745 
2746  BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
2747 }
2748 
2749 int yyFlexLexer::yy_top_state()
2750 {
2751  return (yy_start_stack)[(yy_start_stack_ptr) - 1];
2752 }
2753 
2754 #ifndef YY_EXIT_FAILURE
2755 #define YY_EXIT_FAILURE 2
2756 #endif
2757 
2758 void yyFlexLexer::LexerError(yyconst char msg[])
2759 {
2760  std::cerr << msg << std::endl;
2761  exit(YY_EXIT_FAILURE);
2762 }
2763 
2764 /* Redefine yyless() so it works in section 3 code. */
2765 
2766 #undef yyless
2767 #define yyless(n) \
2768  do \
2769  {\
2770  /* Undo effects of setting up yytext. */ \
2771  int yyless_macro_arg = (n); \
2772  YY_LESS_LINENO(yyless_macro_arg);\
2773  yytext[yyleng] = (yy_hold_char); \
2774  (yy_c_buf_p) = yytext + yyless_macro_arg; \
2775  (yy_hold_char) = *(yy_c_buf_p); \
2776  *(yy_c_buf_p) = '\0'; \
2777  yyleng = yyless_macro_arg; \
2778  } \
2779  while (0)
2780 
2781 /* Accessor methods (get/set functions) to struct members. */
2782 
2783 /*
2784  * Internal utility routines.
2785  */
2786 
2787 #ifndef yytext_ptr
2788 static void yy_flex_strncpy(char* s1, yyconst char * s2, int n)
2789 {
2790  register int i;
2791 
2792  for (i = 0; i < n; ++i)
2793  s1[i] = s2[i];
2794 }
2795 #endif
2796 
2797 #ifdef YY_NEED_STRLEN
2798 static int yy_flex_strlen(yyconst char * s)
2799 {
2800  register int n;
2801 
2802  for (n = 0; s[n]; ++n)
2803  ;
2804 
2805  return n;
2806 }
2807 #endif
2808 
2809 void *CEvaluationalloc(yy_size_t size)
2810 {
2811  return (void *) malloc(size);
2812 }
2813 
2814 void *CEvaluationrealloc(void * ptr, yy_size_t size)
2815 {
2816  /* The cast to (char *) in the following accommodates both
2817  * implementations that use char* generic pointers, and those
2818  * that use void* generic pointers. It works with the latter
2819  * because both ANSI C and C++ allow castless assignment from
2820  * any pointer type to void*, and deal with argument conversions
2821  * as though doing an assignment.
2822  */
2823  return (void *) realloc((char *) ptr, size);
2824 }
2825 
2826 void CEvaluationfree(void * ptr)
2827 {
2828  free((char *) ptr); /* see CEvaluationrealloc() for (char *) cast */
2829 }
2830 
2831 #define YYTABLES_NAME "yytables"
2832 
2833 #line 620 "function/CEvaluationLexer.lpp"
yyFlexLexer::yy_switch_to_buffer
void yy_switch_to_buffer(struct yy_buffer_state *new_buffer)
TOKEN_STRUCTURE_OPEN
Definition: CEvaluationParser_yacc.cpp:176
FlexLexer::yy_flex_debug
int yy_flex_debug
Definition: FlexLexer.h:113
yyFlexLexer::yypush_buffer_state
void yypush_buffer_state(struct yy_buffer_state *new_buffer)
yy_buffer_state::yy_buf_pos
char * yy_buf_pos
Definition: CEvaluationLexer_lex.cpp:217
yyFlexLexer::yy_start_stack_ptr
int yy_start_stack_ptr
Definition: FlexLexer.h:161
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: CEvaluationLexer_lex.cpp:187
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: CEvaluationLexer_lex.cpp:143
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: CEvaluationLexer_lex.cpp:168
yyFlexLexer::yy_push_state
void yy_push_state(int new_state)
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: CEvaluationLexer_lex.cpp:737
yyFlexLexer::yy_try_NUL_trans
yy_state_type yy_try_NUL_trans(yy_state_type current_state)
MCFunction
#define MCFunction
Definition: CCopasiMessage.h:49
YY_BREAK
#define YY_BREAK
Definition: CEvaluationLexer_lex.cpp:850
yy_buffer_state::yy_fill_buffer
int yy_fill_buffer
Definition: CEvaluationLexer_lex.cpp:254
yy_size_t
size_t yy_size_t
Definition: CEvaluationLexer_lex.cpp:182
yyFlexLexer::yy_buffer_stack_top
size_t yy_buffer_stack_top
Definition: FlexLexer.h:193
sSIGNorVALUE
#define sSIGNorVALUE
Definition: CEvaluationLexer_lex.cpp:765
TOKEN_LOGICAL_GT
Definition: CEvaluationParser_yacc.cpp:172
yyFlexLexer::yy_prev_more_offset
int yy_prev_more_offset
Definition: FlexLexer.h:217
YY_CHAR
unsigned char YY_CHAR
Definition: CEvaluationLexer_lex.cpp:319
yyconst
#define yyconst
Definition: CEvaluationLexer_lex.cpp:132
flex_int8_t
signed char flex_int8_t
Definition: CEvaluationLexer_lex.cpp:68
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: CEvaluationLexer_lex.cpp:736
yyFlexLexer::yy_start_stack
int * yy_start_stack
Definition: FlexLexer.h:163
sOPERATOR
#define sOPERATOR
Definition: CEvaluationLexer_lex.cpp:766
CEvaluationalloc
void * CEvaluationalloc(yy_size_t)
Definition: CEvaluationLexer_lex.cpp:2809
yyFlexLexer::yyFlexLexer
yyFlexLexer(std::istream *arg_yyin=0, std::ostream *arg_yyout=0)
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: CEvaluationLexer_lex.cpp:2755
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: CEvaluationLexer_lex.cpp:258
yyFlexLexer::yy_state_buf
yy_state_type * yy_state_buf
Definition: FlexLexer.h:204
yyFlexLexer::yy_flush_buffer
void yy_flush_buffer(struct yy_buffer_state *b)
yyFlexLexer::switch_streams
virtual void switch_streams(std::istream *new_in, std::ostream *new_out=0)
yy_buffer_state::yy_bs_lineno
int yy_bs_lineno
Definition: CEvaluationLexer_lex.cpp:248
TOKEN_OPERATOR_PLUS
Definition: CEvaluationParser_yacc.cpp:163
YY_USER_INIT
#define YY_USER_INIT
Definition: CEvaluationLexer_lex.cpp:753
yyFlexLexer::yy_hold_char
char yy_hold_char
Definition: FlexLexer.h:177
yyFlexLexer::yy_last_accepting_state
yy_state_type yy_last_accepting_state
Definition: FlexLexer.h:201
yyFlexLexer::yy_more_offset
int yy_more_offset
Definition: FlexLexer.h:216
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: CEvaluationLexer_lex.cpp:259
yyFlexLexer::yy_more_flag
int yy_more_flag
Definition: FlexLexer.h:214
yy_buffer_state::yy_buf_size
yy_size_t yy_buf_size
Definition: CEvaluationLexer_lex.cpp:222
yyFlexLexer::~yyFlexLexer
virtual ~yyFlexLexer()
TOKEN_LOGICAL_LT
Definition: CEvaluationParser_yacc.cpp:174
TOKEN_CALL
Definition: CEvaluationParser_yacc.cpp:156
mpNode
CEvaluationNode * mpNode
Definition: CEvaluationParser_yacc.cpp:1298
TOKEN_LOGICAL_EQ
Definition: CEvaluationParser_yacc.cpp:170
ECHO
#define ECHO
Definition: CEvaluationLexer_lex.cpp:799
yy_buffer_state::yy_n_chars
yy_size_t yy_n_chars
Definition: CEvaluationLexer_lex.cpp:227
TOKEN_OPERATOR_MODULUS
Definition: CEvaluationParser_yacc.cpp:162
TOKEN_FUNCTION
Definition: CEvaluationParser_yacc.cpp:157
sVALUE
#define sVALUE
Definition: CEvaluationLexer_lex.cpp:767
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: CEvaluationLexer_lex.cpp:794
yyFlexLexer::yyunput
void yyunput(int c, char *buf_ptr)
TOKEN_OPERATOR_MULTIPLY
Definition: CEvaluationParser_yacc.cpp:161
TOKEN_LOGICAL_CHOICE
Definition: CEvaluationParser_yacc.cpp:164
TOKEN_LOGICAL_NE
Definition: CEvaluationParser_yacc.cpp:171
yyFlexLexer::yypop_buffer_state
void yypop_buffer_state()
TOKEN_LOGICAL_GE
Definition: CEvaluationParser_yacc.cpp:173
yyFlexLexer::LexerError
virtual void LexerError(const char *msg)
YY_START_STACK_INCR
#define YY_START_STACK_INCR
Definition: CEvaluationLexer_lex.cpp:823
yyFlexLexer::yy_last_accepting_cpos
char * yy_last_accepting_cpos
Definition: FlexLexer.h:202
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: CEvaluationLexer_lex.cpp:246
yyFlexLexer::yy_load_buffer_state
void yy_load_buffer_state()
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: CEvaluationLexer_lex.cpp:159
BEGIN
#define BEGIN
Definition: CEvaluationLexer_lex.cpp:149
yy_state_type
int yy_state_type
Definition: FlexLexer.h:72
yy_buffer_state::yy_bs_column
int yy_bs_column
Definition: CEvaluationLexer_lex.cpp:249
FlexLexer::yylineno
int yylineno
Definition: FlexLexer.h:112
COMMON_ACTION
#define COMMON_ACTION
Definition: CEvaluationLexer_lex.cpp:758
yyFlexLexer::yy_create_buffer
struct yy_buffer_state * yy_create_buffer(std::istream *s, int size)
yy_nxt
static flex_int16_t yy_nxt[879]
Definition: CEvaluationLexer_lex.cpp:529
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: CEvaluationLexer_lex.cpp:806
yyFlexLexer::yyrestart
void yyrestart(std::istream *s)
yyFlexLexer::yy_looking_for_trail_begin
int yy_looking_for_trail_begin
Definition: FlexLexer.h:212
TOKEN_STRUCTURE_VECTOR_OPEN
Definition: CEvaluationParser_yacc.cpp:177
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: CEvaluationLexer_lex.cpp:189
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: CEvaluationLexer_lex.cpp:828
CEvaluationfree
void CEvaluationfree(void *)
Definition: CEvaluationLexer_lex.cpp:2826
TOKEN_LOGICAL_NOT
Definition: CEvaluationParser_yacc.cpp:166
yyFlexLexer::yy_buffer_stack_max
size_t yy_buffer_stack_max
Definition: FlexLexer.h:194
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: CEvaluationLexer_lex.cpp:164
yyFlexLexer::yy_did_buffer_switch_on_eof
int yy_did_buffer_switch_on_eof
Definition: FlexLexer.h:190
yy_buffer_state::yy_input_file
std::istream * yy_input_file
Definition: CEvaluationLexer_lex.cpp:214
TOKEN_SIGN
Definition: CEvaluationParser_yacc.cpp:159
flex_int32_t
int flex_int32_t
Definition: CEvaluationLexer_lex.cpp:70
yy_buffer_state::yy_ch_buf
char * yy_ch_buf
Definition: CEvaluationLexer_lex.cpp:216
yyFlexLexer::yy_init_buffer
void yy_init_buffer(struct yy_buffer_state *b, std::istream *s)
TOKEN_OPERATOR_POWER
Definition: CEvaluationParser_yacc.cpp:160
TOKEN_VARIABLE
Definition: CEvaluationParser_yacc.cpp:155
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: CEvaluationLexer_lex.cpp:853
yyFlexLexer::yy_buffer_stack
struct yy_buffer_state ** yy_buffer_stack
Definition: FlexLexer.h:195
flex_uint8_t
unsigned char flex_uint8_t
Definition: CEvaluationLexer_lex.cpp:71
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: CEvaluationLexer_lex.cpp:270
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: CEvaluationLexer_lex.cpp:177
yyFlexLexer::yyin
std::istream * yyin
Definition: FlexLexer.h:173
yyFlexLexer::yy_c_buf_p
char * yy_c_buf_p
Definition: FlexLexer.h:183
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: CEvaluationLexer_lex.cpp:287
yy_buffer_state
Definition: CEvaluationLexer_lex.cpp:211
yy_ec
static flex_int32_t yy_ec[256]
Definition: CEvaluationLexer_lex.cpp:390
yyFlexLexer::yy_get_next_buffer
int yy_get_next_buffer()
yyFlexLexer::yyout
std::ostream * yyout
Definition: FlexLexer.h:174
yy_buffer_state::yy_is_our_buffer
int yy_is_our_buffer
Definition: CEvaluationLexer_lex.cpp:233
yyFlexLexer::yyensure_buffer_stack
void yyensure_buffer_stack(void)
TOKEN_LOGICAL_AND
Definition: CEvaluationParser_yacc.cpp:169
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: CEvaluationLexer_lex.cpp:280
INITIAL
#define INITIAL
Definition: CEvaluationLexer_lex.cpp:764
yy_def
static flex_int16_t yy_def[384]
Definition: CEvaluationLexer_lex.cpp:482
CEvaluationrealloc
void * CEvaluationrealloc(void *, yy_size_t)
Definition: CEvaluationLexer_lex.cpp:2814
YY_DECL
#define YY_DECL
Definition: CEvaluationLexer_lex.cpp:838
TOKEN_STRUCTURE_VECTOR_CLOSE
Definition: CEvaluationParser_yacc.cpp:180
yyFlexLexer::LexerOutput
virtual void LexerOutput(const char *buf, int size)
TOKEN_FUNCTION_2
Definition: CEvaluationParser_yacc.cpp:158
yyFlexLexer::LexerInput
virtual int LexerInput(char *buf, int max_size)
yytext_ptr
#define yytext_ptr
Definition: CEvaluationLexer_lex.cpp:321
TOKEN_NUMBER
#define TOKEN_NUMBER
Definition: CChemEqParser_yacc.cpp:101
yy_trans_info::yy_verify
flex_int32_t yy_verify
Definition: CEvaluationLexer_lex.cpp:341
YY_START
#define YY_START
Definition: CEvaluationLexer_lex.cpp:155
yy_meta
static flex_int32_t yy_meta[70]
Definition: CEvaluationLexer_lex.cpp:423
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: CEvaluationLexer_lex.cpp:328
yyFlexLexer::yy_start
int yy_start
Definition: FlexLexer.h:186
yyFlexLexer::yy_delete_buffer
void yy_delete_buffer(struct yy_buffer_state *b)
TOKEN_STRUCTURE_COMMA
Definition: CEvaluationParser_yacc.cpp:178
yyFlexLexer::yy_n_chars
int yy_n_chars
Definition: FlexLexer.h:180
yyFlexLexer::yy_top_state
int yy_top_state()
TOKEN_LOGICAL_VALUE
Definition: CEvaluationParser_yacc.cpp:165
yyleng
yy_size_t yyleng
yy_accept
static flex_int16_t yy_accept[380]
Definition: CEvaluationLexer_lex.cpp:344
YYERRCODE
#define YYERRCODE
Definition: CEvaluationLexer_lex.cpp:750
yy_trans_info::yy_nxt
flex_int32_t yy_nxt
Definition: CEvaluationLexer_lex.cpp:342
void
() void(yyvaluep))
yyFlexLexer::yy_start_stack_depth
int yy_start_stack_depth
Definition: FlexLexer.h:162
yyFlexLexer::yy_pop_state
void yy_pop_state()
yy_buffer_state::yy_is_interactive
int yy_is_interactive
Definition: CEvaluationLexer_lex.cpp:240
flex_uint32_t
unsigned int flex_uint32_t
Definition: CEvaluationLexer_lex.cpp:73
TOKEN_LOGICAL_OR
Definition: CEvaluationParser_yacc.cpp:167
TOKEN_LOGICAL_LE
Definition: CEvaluationParser_yacc.cpp:175
if
if(!yymsg) yymsg
yy_chk
static flex_int16_t yy_chk[879]
Definition: CEvaluationLexer_lex.cpp:630
yyFlexLexer::yy_get_previous_state
yy_state_type yy_get_previous_state()
TOKEN_STRUCTURE_CLOSE
Definition: CEvaluationParser_yacc.cpp:179
yyFlexLexer::yywrap
virtual int yywrap()
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: CEvaluationLexer_lex.cpp:188
TOKEN_LOGICAL_XOR
Definition: CEvaluationParser_yacc.cpp:168
YY_NEW_FILE
#define YY_NEW_FILE
Definition: CEvaluationLexer_lex.cpp:162
yy_trans_info
Definition: CEvaluationLexer_lex.cpp:339
yy_buffer_state::yy_buffer_status
int yy_buffer_status
Definition: CEvaluationLexer_lex.cpp:256
yy_base
static flex_int16_t yy_base[384]
Definition: CEvaluationLexer_lex.cpp:435
yyFlexLexer::yy_more_len
int yy_more_len
Definition: FlexLexer.h:215
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: CEvaluationLexer_lex.cpp:336
flex_int16_t
short int flex_int16_t
Definition: CEvaluationLexer_lex.cpp:69
flex_uint16_t
unsigned short int flex_uint16_t
Definition: CEvaluationLexer_lex.cpp:72
Generated on Thu Jul 2 2015 14:50:11 for COPASI API by   doxygen 1.8.6