source: palm/trunk/UTIL/chemistry/gasphase_preproc/kpp/src/lex.yy.c @ 2696

Last change on this file since 2696 was 2696, checked in by kanani, 4 years ago

Merge of branch palm4u into trunk

File size: 74.1 KB
Line 
1#line 2 "lex.yy.c"
2
3#line 4 "lex.yy.c"
4
5#define  YY_INT_ALIGNED short int
6
7/* A lexical scanner generated by flex */
8
9#define FLEX_SCANNER
10#define YY_FLEX_MAJOR_VERSION 2
11#define YY_FLEX_MINOR_VERSION 5
12#define YY_FLEX_SUBMINOR_VERSION 37
13#if YY_FLEX_SUBMINOR_VERSION > 0
14#define FLEX_BETA
15#endif
16
17/* First, we deal with  platform-specific or compiler-specific issues. */
18
19/* begin standard C headers. */
20#include <stdio.h>
21#include <string.h>
22#include <errno.h>
23#include <stdlib.h>
24
25/* end standard C headers. */
26
27/* flex integer type definitions */
28
29#ifndef FLEXINT_H
30#define FLEXINT_H
31
32/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
33
34#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
35
36/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
37 * if you want the limit (max/min) macros for int types.
38 */
39#ifndef __STDC_LIMIT_MACROS
40#define __STDC_LIMIT_MACROS 1
41#endif
42
43#include <inttypes.h>
44typedef int8_t flex_int8_t;
45typedef uint8_t flex_uint8_t;
46typedef int16_t flex_int16_t;
47typedef uint16_t flex_uint16_t;
48typedef int32_t flex_int32_t;
49typedef uint32_t flex_uint32_t;
50#else
51typedef signed char flex_int8_t;
52typedef short int flex_int16_t;
53typedef int flex_int32_t;
54typedef unsigned char flex_uint8_t; 
55typedef unsigned short int flex_uint16_t;
56typedef unsigned int flex_uint32_t;
57
58/* Limits of integral types. */
59#ifndef INT8_MIN
60#define INT8_MIN               (-128)
61#endif
62#ifndef INT16_MIN
63#define INT16_MIN              (-32767-1)
64#endif
65#ifndef INT32_MIN
66#define INT32_MIN              (-2147483647-1)
67#endif
68#ifndef INT8_MAX
69#define INT8_MAX               (127)
70#endif
71#ifndef INT16_MAX
72#define INT16_MAX              (32767)
73#endif
74#ifndef INT32_MAX
75#define INT32_MAX              (2147483647)
76#endif
77#ifndef UINT8_MAX
78#define UINT8_MAX              (255U)
79#endif
80#ifndef UINT16_MAX
81#define UINT16_MAX             (65535U)
82#endif
83#ifndef UINT32_MAX
84#define UINT32_MAX             (4294967295U)
85#endif
86
87#endif /* ! C99 */
88
89#endif /* ! FLEXINT_H */
90
91#ifdef __cplusplus
92
93/* The "const" storage-class-modifier is valid. */
94#define YY_USE_CONST
95
96#else   /* ! __cplusplus */
97
98/* C99 requires __STDC__ to be defined as 1. */
99#if defined (__STDC__)
100
101#define YY_USE_CONST
102
103#endif  /* defined (__STDC__) */
104#endif  /* ! __cplusplus */
105
106#ifdef YY_USE_CONST
107#define yyconst const
108#else
109#define yyconst
110#endif
111
112/* Returned upon end-of-file. */
113#define YY_NULL 0
114
115/* Promotes a possibly negative, possibly signed char to an unsigned
116 * integer for use as an array index.  If the signed char is negative,
117 * we want to instead treat it as an 8-bit unsigned char, hence the
118 * double cast.
119 */
120#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
121
122/* Enter a start condition.  This macro really ought to take a parameter,
123 * but we do it the disgusting crufty way forced on us by the ()-less
124 * definition of BEGIN.
125 */
126#define BEGIN (yy_start) = 1 + 2 *
127
128/* Translate the current start state into a value that can be later handed
129 * to BEGIN to return to the state.  The YYSTATE alias is for lex
130 * compatibility.
131 */
132#define YY_START (((yy_start) - 1) / 2)
133#define YYSTATE YY_START
134
135/* Action number for EOF rule of a given start state. */
136#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
137
138/* Special action meaning "start processing a new file". */
139#define YY_NEW_FILE yyrestart(yyin  )
140
141#define YY_END_OF_BUFFER_CHAR 0
142
143/* Size of default input buffer. */
144#ifndef YY_BUF_SIZE
145#define YY_BUF_SIZE 16384
146#endif
147
148/* The state buf must be large enough to hold one state per character in the main buffer.
149 */
150#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
151
152#ifndef YY_TYPEDEF_YY_BUFFER_STATE
153#define YY_TYPEDEF_YY_BUFFER_STATE
154typedef struct yy_buffer_state *YY_BUFFER_STATE;
155#endif
156
157#ifndef YY_TYPEDEF_YY_SIZE_T
158#define YY_TYPEDEF_YY_SIZE_T
159typedef size_t yy_size_t;
160#endif
161
162extern yy_size_t yyleng;
163
164extern FILE *yyin, *yyout;
165
166#define EOB_ACT_CONTINUE_SCAN 0
167#define EOB_ACT_END_OF_FILE 1
168#define EOB_ACT_LAST_MATCH 2
169
170    #define YY_LESS_LINENO(n)
171   
172/* Return all but the first "n" matched characters back to the input stream. */
173#define yyless(n) \
174        do \
175                { \
176                /* Undo effects of setting up yytext. */ \
177        int yyless_macro_arg = (n); \
178        YY_LESS_LINENO(yyless_macro_arg);\
179                *yy_cp = (yy_hold_char); \
180                YY_RESTORE_YY_MORE_OFFSET \
181                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
182                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
183                } \
184        while ( 0 )
185
186#define unput(c) yyunput( c, (yytext_ptr)  )
187
188#ifndef YY_STRUCT_YY_BUFFER_STATE
189#define YY_STRUCT_YY_BUFFER_STATE
190struct yy_buffer_state
191        {
192        FILE *yy_input_file;
193
194        char *yy_ch_buf;                /* input buffer */
195        char *yy_buf_pos;               /* current position in input buffer */
196
197        /* Size of input buffer in bytes, not including room for EOB
198         * characters.
199         */
200        yy_size_t yy_buf_size;
201
202        /* Number of characters read into yy_ch_buf, not including EOB
203         * characters.
204         */
205        yy_size_t yy_n_chars;
206
207        /* Whether we "own" the buffer - i.e., we know we created it,
208         * and can realloc() it to grow it, and should free() it to
209         * delete it.
210         */
211        int yy_is_our_buffer;
212
213        /* Whether this is an "interactive" input source; if so, and
214         * if we're using stdio for input, then we want to use getc()
215         * instead of fread(), to make sure we stop fetching input after
216         * each newline.
217         */
218        int yy_is_interactive;
219
220        /* Whether we're considered to be at the beginning of a line.
221         * If so, '^' rules will be active on the next match, otherwise
222         * not.
223         */
224        int yy_at_bol;
225
226    int yy_bs_lineno; /**< The line count. */
227    int yy_bs_column; /**< The column count. */
228   
229        /* Whether to try to fill the input buffer when we reach the
230         * end of it.
231         */
232        int yy_fill_buffer;
233
234        int yy_buffer_status;
235
236#define YY_BUFFER_NEW 0
237#define YY_BUFFER_NORMAL 1
238        /* When an EOF's been seen but there's still some text to process
239         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
240         * shouldn't try reading from the input source any more.  We might
241         * still have a bunch of tokens to match, though, because of
242         * possible backing-up.
243         *
244         * When we actually see the EOF, we change the status to "new"
245         * (via yyrestart()), so that the user can continue scanning by
246         * just pointing yyin at a new input file.
247         */
248#define YY_BUFFER_EOF_PENDING 2
249
250        };
251#endif /* !YY_STRUCT_YY_BUFFER_STATE */
252
253/* Stack of input buffers. */
254static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
255static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
256static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
257
258/* We provide macros for accessing buffer states in case in the
259 * future we want to put the buffer states in a more general
260 * "scanner state".
261 *
262 * Returns the top of the stack, or NULL.
263 */
264#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
265                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
266                          : NULL)
267
268/* Same as previous macro, but useful when we know that the buffer stack is not
269 * NULL or when we need an lvalue. For internal use only.
270 */
271#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
272
273/* yy_hold_char holds the character lost when yytext is formed. */
274static char yy_hold_char;
275static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
276yy_size_t yyleng;
277
278/* Points to current character in buffer. */
279static char *yy_c_buf_p = (char *) 0;
280static int yy_init = 0;         /* whether we need to initialize */
281static int yy_start = 0;        /* start state number */
282
283/* Flag which is used to allow yywrap()'s to do buffer switches
284 * instead of setting up a fresh yyin.  A bit of a hack ...
285 */
286static int yy_did_buffer_switch_on_eof;
287
288void yyrestart (FILE *input_file  );
289void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
290YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
291void yy_delete_buffer (YY_BUFFER_STATE b  );
292void yy_flush_buffer (YY_BUFFER_STATE b  );
293void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
294void yypop_buffer_state (void );
295
296static void yyensure_buffer_stack (void );
297static void yy_load_buffer_state (void );
298static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
299
300#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
301
302YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
303YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
304YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
305
306void *yyalloc (yy_size_t  );
307void *yyrealloc (void *,yy_size_t  );
308void yyfree (void *  );
309
310#define yy_new_buffer yy_create_buffer
311
312#define yy_set_interactive(is_interactive) \
313        { \
314        if ( ! YY_CURRENT_BUFFER ){ \
315        yyensure_buffer_stack (); \
316                YY_CURRENT_BUFFER_LVALUE =    \
317            yy_create_buffer(yyin,YY_BUF_SIZE ); \
318        } \
319        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
320        }
321
322#define yy_set_bol(at_bol) \
323        { \
324        if ( ! YY_CURRENT_BUFFER ){\
325        yyensure_buffer_stack (); \
326                YY_CURRENT_BUFFER_LVALUE =    \
327            yy_create_buffer(yyin,YY_BUF_SIZE ); \
328        } \
329        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
330        }
331
332#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
333
334/* Begin user sect3 */
335
336typedef unsigned char YY_CHAR;
337
338FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
339
340typedef int yy_state_type;
341
342extern int yylineno;
343
344int yylineno = 1;
345
346extern char *yytext;
347#define yytext_ptr yytext
348
349static yy_state_type yy_get_previous_state (void );
350static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
351static int yy_get_next_buffer (void );
352static void yy_fatal_error (yyconst char msg[]  );
353
354/* Done after the current pattern has been matched and before the
355 * corresponding action - sets up yytext.
356 */
357#define YY_DO_BEFORE_ACTION \
358        (yytext_ptr) = yy_bp; \
359        yyleng = (size_t) (yy_cp - yy_bp); \
360        (yy_hold_char) = *yy_cp; \
361        *yy_cp = '\0'; \
362        (yy_c_buf_p) = yy_cp;
363
364#define YY_NUM_RULES 58
365#define YY_END_OF_BUFFER 59
366/* This struct is not used in this scanner,
367   but its presence is necessary. */
368struct yy_trans_info
369        {
370        flex_int32_t yy_verify;
371        flex_int32_t yy_nxt;
372        };
373static yyconst flex_int16_t yy_accept[199] =
374    {   0,
375        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
376        0,    0,   19,   19,    0,    0,   29,   29,   33,   33,
377        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
378        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
379        0,    0,    5,    5,    7,    7,    0,    0,   57,   57,
380       59,   58,    1,    9,    2,   58,    3,   10,   10,   11,
381       11,   12,   12,   13,   13,   14,   14,   23,    1,    9,
382       21,   23,   19,   22,   20,   18,    3,   25,   24,   30,
383        1,    9,   30,   29,   30,   29,   28,   27,   26,   26,
384        3,   35,   33,   33,   34,   36,   32,   31,   31,   37,
385
386       38,   39,   39,   40,   45,    1,    9,   42,   45,   43,
387       44,   41,    3,   15,   15,   17,   16,   47,   46,   54,
388       54,   53,   52,   49,   48,   50,   50,   51,    5,    1,
389        2,    5,    3,    6,    7,    1,    8,    2,    7,    3,
390       57,   56,   55,    1,    4,   10,    4,   11,    4,   12,
391        4,   13,    4,   14,    4,   19,   18,   24,   29,   29,
392        0,   29,   29,   26,    0,   26,   33,    0,   33,   33,
393       31,    0,   31,   37,   39,    4,   41,   15,    4,   16,
394       46,   54,    4,   52,   48,   50,    4,    5,    1,    4,
395        7,    1,    4,   57,   55,   29,   33,    0
396
397    } ;
398
399static yyconst flex_int32_t yy_ec[256] =
400    {   0,
401        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
402        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
403        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
404        1,    2,    1,    1,    4,    1,    1,    1,    1,    1,
405        1,    1,    5,    1,    6,    7,    8,    9,    9,    9,
406        9,    9,    9,    9,    9,    9,    9,   10,   11,   12,
407       13,   14,    1,    1,   15,   15,   15,   15,   16,   15,
408       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
409       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
410        1,    1,    1,    1,   15,    1,   15,   15,   15,   15,
411
412       16,   15,   15,   15,   15,   15,   15,   15,   15,   15,
413       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
414       15,   15,   17,    1,   18,    1,    1,    1,    1,    1,
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,    1,    1,    1,    1,    1,
421        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
422
423        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
424        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
425        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
426        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
427        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
428        1,    1,    1,    1,    1
429    } ;
430
431static yyconst flex_int32_t yy_meta[19] =
432    {   0,
433        1,    2,    3,    4,    5,    5,    1,    1,    6,    1,
434        7,    1,    1,    1,    8,    8,    7,    9
435    } ;
436
437static yyconst flex_int16_t yy_base[237] =
438    {   0,
439        0,   16,   32,   49,   66,   83,  100,  117,  134,  151,
440      168,  185,  203,    0,  211,  217,  233,    0,  247,    0,
441      255,    0,  270,  287,  305,    0,  322,  339,    0,    0,
442      347,  353,  359,  365,  380,  397,  405,  411,  417,  423,
443      438,  455,  472,  489,  506,  522,    0,    0,    2,    6,
444       88,  842,   80,  842,  842,   73,  842,    0,   72,    0,
445       71,    0,   70,    0,   68,    0,   67,  842,   71,  842,
446      842,   64,   62,  842,  842,    0,  842,  842,    0,  842,
447       63,  842,   55,    5,   55,  533,  842,  842,    0,  545,
448      842,  842,    6,  555,  842,  842,  842,    0,  567,    0,
449
450      842,    0,   54,  842,  842,   59,  842,  842,   51,  842,
451      842,    0,  842,    0,   50,  842,    0,  842,    0,    0,
452       48,  842,    0,  842,    0,    0,   47,  842,    0,   52,
453        0,   40,    0,  842,    0,   45,  842,    0,   38,    0,
454        0,  842,    0,   43,  842,    0,    0,    0,    0,    0,
455        0,    0,    0,    0,    0,   35,    0,    0,    0,    7,
456       33,   16,    0,    0,   32,   30,   21,   20,   22,    0,
457        0,   19,   18,    0,    0,    0,    0,    0,    0,    0,
458        0,    0,    0,    0,    0,    0,    0,    0,   24,    0,
459        0,   11,    0,    0,    0,    3,    2,  842,  583,  592,
460
461      601,  610,  619,  628,  637,  646,  655,  664,  673,  682,
462      691,  700,  708,  716,  724,  732,  735,  738,  741,  744,
463      747,  755,  758,  766,  769,  772,  780,  783,  786,  794,
464      802,  810,  819,  828,  833,  835
465    } ;
466
467static yyconst flex_int16_t yy_def[237] =
468    {   0,
469      199,  199,  200,  200,  201,  201,  202,  202,  203,  203,
470      204,  204,  198,   13,    2,    2,  198,   17,    2,   19,
471        2,   21,  205,  205,  198,   25,  206,  206,    2,    2,
472        2,    2,    2,    2,  207,  207,    2,    2,    2,    2,
473      208,  208,  209,  209,  210,  210,    2,    2,  211,  211,
474      198,  198,  198,  198,  198,  198,  198,  212,  212,  213,
475      213,  214,  214,  215,  215,  216,  216,  198,  198,  198,
476      198,  198,  198,  198,  198,  217,  198,  198,  218,  198,
477      198,  198,  198,  198,  198,  198,  198,  198,  219,  198,
478      198,  198,  198,  198,  198,  198,  198,  220,  198,  221,
479
480      198,  222,  222,  198,  198,  198,  198,  198,  198,  198,
481      198,  223,  198,  224,  224,  198,  225,  198,  226,  227,
482      227,  198,  228,  198,  229,  230,  230,  198,  231,  231,
483      231,  231,  231,  198,  232,  232,  198,  232,  232,  232,
484      233,  198,  234,  198,  198,  212,  212,  213,  213,  214,
485      214,  215,  215,  216,  216,  198,  217,  218,   86,  198,
486      235,  198,   86,  219,  198,  219,  198,  236,  198,   94,
487      220,  198,  220,  221,  222,  222,  223,  224,  224,  225,
488      226,  227,  227,  228,  229,  230,  230,  231,  231,  231,
489      232,  232,  232,  233,  234,  198,  198,    0,  198,  198,
490
491      198,  198,  198,  198,  198,  198,  198,  198,  198,  198,
492      198,  198,  198,  198,  198,  198,  198,  198,  198,  198,
493      198,  198,  198,  198,  198,  198,  198,  198,  198,  198,
494      198,  198,  198,  198,  198,  198
495    } ;
496
497static yyconst flex_int16_t yy_nxt[861] =
498    {   0,
499      198,   53,   54,   55,  142,  143,  198,   56,  142,  143,
500      197,  196,  192,  160,  167,  160,   57,   53,   54,   55,
501      161,  168,  161,   56,  160,  189,  173,  197,  197,  167,
502      167,  161,   57,   53,   54,   55,  168,  168,  166,   59,
503      196,  196,   52,  156,  144,  193,  192,  190,   57,   52,
504       53,   54,   55,  189,  187,  183,   59,  179,  145,   52,
505      144,  176,  145,  159,  144,   57,   52,   53,   54,   55,
506      156,  145,  144,   61,  155,  153,   52,  151,  149,  147,
507      145,  144,   57,   52,   53,   54,   55,  198,  198,  198,
508       61,  198,  198,   52,  198,  198,  198,  198,  198,   57,
509
510       52,   53,   54,   55,  198,  198,  198,   63,  198,  198,
511       52,  198,  198,  198,  198,  198,   57,   52,   53,   54,
512       55,  198,  198,  198,   63,  198,  198,   52,  198,  198,
513      198,  198,  198,   57,   52,   53,   54,   55,  198,  198,
514      198,   65,  198,  198,   52,  198,  198,  198,  198,  198,
515       57,   52,   53,   54,   55,  198,  198,  198,   65,  198,
516      198,   52,  198,  198,  198,  198,  198,   57,   52,   53,
517       54,   55,  198,  198,  198,   67,  198,  198,   52,  198,
518      198,  198,  198,  198,   57,   52,   53,   54,   55,  198,
519      198,  198,   67,  198,  198,   52,  198,  198,  198,  198,
520
521      198,   57,   52,   68,   69,   70,   55,   71,   68,   68,
522       72,   73,   68,   74,   68,   75,   68,   76,   76,   77,
523       68,   78,  198,  198,  198,   79,   79,   78,  198,  198,
524      198,   79,   79,   80,   81,   82,   55,   83,   83,   84,
525       85,   86,   80,   87,   80,   88,   80,   89,   90,   91,
526       80,   92,   92,   93,  198,   94,   95,  198,   96,   97,
527      198,   98,   99,  100,  198,  198,  198,  198,  101,  100,
528      100,   53,   54,   55,  198,  198,  198,  103,  198,  198,
529      104,  198,  198,  198,  198,  198,   57,   52,   53,   54,
530       55,  198,  198,  198,  103,  198,  198,  104,  198,  198,
531
532      198,  198,  198,   57,   52,  105,  106,  107,   55,  108,
533      105,  105,  109,  105,  110,  111,  105,  105,  105,  112,
534      112,  113,  105,   53,   54,   55,  198,  198,  198,  115,
535      198,  198,   52,  198,  198,  198,  198,  198,   57,   52,
536       53,   54,   55,  198,  198,  198,  115,  198,  198,   52,
537      198,  198,  198,  198,  198,   57,   52,  116,  198,  198,
538      198,  117,  117,  116,  198,  198,  198,  117,  117,  118,
539      198,  198,  198,  119,  119,  118,  198,  198,  198,  119,
540      119,   53,   54,   55,  198,  198,  198,  121,  198,  198,
541       52,  198,  198,  198,  198,  198,   57,   52,   53,   54,
542
543       55,  198,  198,  198,  121,  198,  198,   52,  198,  198,
544      198,  198,  198,   57,   52,  122,  198,  198,  198,  123,
545      123,  122,  198,  198,  198,  123,  123,  124,  198,  198,
546      198,  125,  125,  124,  198,  198,  198,  125,  125,   53,
547       54,   55,  198,  198,  198,  127,  198,  198,  128,  198,
548      198,  198,  198,  198,   57,   52,   53,   54,   55,  198,
549      198,  198,  127,  198,  198,  128,  198,  198,  198,  198,
550      198,   57,   52,  130,   54,  131,  198,  198,  198,  132,
551      198,  198,  198,  198,  198,  198,  198,  198,  133,  134,
552      130,   54,  131,  198,  198,  198,  132,  198,  198,  198,
553
554      198,  198,  198,  198,  198,  133,  134,  136,  137,  138,
555      198,  198,  198,  139,  198,  198,  198,  198,  198,  198,
556      198,  198,  140,  136,  137,  138,  198,  198,  198,  139,
557      198,  198,  198,  198,  198,  198,  198,  198,  140,  162,
558      198,  163,  198,  198,  198,  198,  198,  198,  161,  165,
559      165,  198,  198,  166,  198,  198,  198,  198,  198,  164,
560      164,  169,  198,  170,  198,  198,  198,  198,  198,  198,
561      168,  172,  172,  198,  198,  173,  198,  198,  198,  198,
562      198,  171,  171,   52,   52,   52,   52,   52,   52,   52,
563       52,   52,   58,   58,   58,   58,   58,   58,   58,   58,
564
565       58,   60,   60,   60,   60,   60,   60,   60,   60,   60,
566       62,   62,   62,   62,   62,   62,   62,   62,   62,   64,
567       64,   64,   64,   64,   64,   64,   64,   64,   66,   66,
568       66,   66,   66,   66,   66,   66,   66,  102,  102,  102,
569      102,  102,  102,  102,  102,  102,  114,  114,  114,  114,
570      114,  114,  114,  114,  114,  120,  120,  120,  120,  120,
571      120,  120,  120,  120,  126,  126,  126,  126,  126,  126,
572      126,  126,  126,  129,  129,  129,  129,  129,  129,  129,
573      129,  129,  135,  135,  135,  135,  135,  135,  135,  135,
574      135,  141,  141,  141,  141,  141,  141,  141,  141,  141,
575
576      146,  198,  198,  198,  146,  146,  198,  146,  148,  198,
577      198,  198,  148,  148,  198,  148,  150,  198,  198,  198,
578      150,  150,  198,  150,  152,  198,  198,  198,  152,  152,
579      198,  152,  154,  198,  198,  198,  154,  154,  198,  154,
580      157,  198,  157,  158,  198,  158,  164,  198,  164,  171,
581      198,  171,  174,  198,  174,  175,  198,  198,  198,  175,
582      175,  198,  175,  177,  198,  177,  178,  198,  198,  198,
583      178,  178,  198,  178,  180,  198,  180,  181,  198,  181,
584      182,  198,  198,  198,  182,  182,  198,  182,  184,  198,
585      184,  185,  198,  185,  186,  198,  198,  198,  186,  186,
586
587      198,  186,  188,  188,  198,  188,  188,  188,  188,  188,
588      191,  191,  198,  191,  191,  191,  191,  191,  191,  194,
589      194,  198,  198,  194,  194,  194,  194,  194,  195,  198,
590      198,  195,  195,  195,  195,  195,  195,  165,  165,  172,
591      172,   51,  198,  198,  198,  198,  198,  198,  198,  198,
592      198,  198,  198,  198,  198,  198,  198,  198,  198,  198
593    } ;
594
595static yyconst flex_int16_t yy_chk[861] =
596    {   0,
597        0,    1,    1,    1,   49,   49,    0,    1,   50,   50,
598      197,  196,  192,   84,   93,  160,    1,    2,    2,    2,
599       84,   93,  160,    2,  162,  189,  173,  172,  168,  167,
600      169,  162,    2,    3,    3,    3,  167,  169,  166,    3,
601      165,  161,    3,  156,  144,  139,  136,  132,    3,    3,
602        4,    4,    4,  130,  127,  121,    4,  115,  109,    4,
603      106,  103,   85,   83,   81,    4,    4,    5,    5,    5,
604       73,   72,   69,    5,   67,   65,    5,   63,   61,   59,
605       56,   53,    5,    5,    6,    6,    6,   51,    0,    0,
606        6,    0,    0,    6,    0,    0,    0,    0,    0,    6,
607
608        6,    7,    7,    7,    0,    0,    0,    7,    0,    0,
609        7,    0,    0,    0,    0,    0,    7,    7,    8,    8,
610        8,    0,    0,    0,    8,    0,    0,    8,    0,    0,
611        0,    0,    0,    8,    8,    9,    9,    9,    0,    0,
612        0,    9,    0,    0,    9,    0,    0,    0,    0,    0,
613        9,    9,   10,   10,   10,    0,    0,    0,   10,    0,
614        0,   10,    0,    0,    0,    0,    0,   10,   10,   11,
615       11,   11,    0,    0,    0,   11,    0,    0,   11,    0,
616        0,    0,    0,    0,   11,   11,   12,   12,   12,    0,
617        0,    0,   12,    0,    0,   12,    0,    0,    0,    0,
618
619        0,   12,   12,   13,   13,   13,   13,   13,   13,   13,
620       13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
621       13,   15,    0,    0,    0,   15,   15,   16,    0,    0,
622        0,   16,   16,   17,   17,   17,   17,   17,   17,   17,
623       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
624       17,   19,   19,   19,    0,   19,   19,    0,   19,   19,
625        0,   19,   19,   21,    0,    0,    0,    0,   21,   21,
626       21,   23,   23,   23,    0,    0,    0,   23,    0,    0,
627       23,    0,    0,    0,    0,    0,   23,   23,   24,   24,
628       24,    0,    0,    0,   24,    0,    0,   24,    0,    0,
629
630        0,    0,    0,   24,   24,   25,   25,   25,   25,   25,
631       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
632       25,   25,   25,   27,   27,   27,    0,    0,    0,   27,
633        0,    0,   27,    0,    0,    0,    0,    0,   27,   27,
634       28,   28,   28,    0,    0,    0,   28,    0,    0,   28,
635        0,    0,    0,    0,    0,   28,   28,   31,    0,    0,
636        0,   31,   31,   32,    0,    0,    0,   32,   32,   33,
637        0,    0,    0,   33,   33,   34,    0,    0,    0,   34,
638       34,   35,   35,   35,    0,    0,    0,   35,    0,    0,
639       35,    0,    0,    0,    0,    0,   35,   35,   36,   36,
640
641       36,    0,    0,    0,   36,    0,    0,   36,    0,    0,
642        0,    0,    0,   36,   36,   37,    0,    0,    0,   37,
643       37,   38,    0,    0,    0,   38,   38,   39,    0,    0,
644        0,   39,   39,   40,    0,    0,    0,   40,   40,   41,
645       41,   41,    0,    0,    0,   41,    0,    0,   41,    0,
646        0,    0,    0,    0,   41,   41,   42,   42,   42,    0,
647        0,    0,   42,    0,    0,   42,    0,    0,    0,    0,
648        0,   42,   42,   43,   43,   43,    0,    0,    0,   43,
649        0,    0,    0,    0,    0,    0,    0,    0,   43,   43,
650       44,   44,   44,    0,    0,    0,   44,    0,    0,    0,
651
652        0,    0,    0,    0,    0,   44,   44,   45,   45,   45,
653        0,    0,    0,   45,    0,    0,    0,    0,    0,    0,
654        0,    0,   45,   46,   46,   46,    0,    0,    0,   46,
655        0,    0,    0,    0,    0,    0,    0,    0,   46,   86,
656        0,   86,    0,    0,    0,    0,    0,    0,   86,   90,
657       90,    0,    0,   90,    0,    0,    0,    0,    0,   90,
658       90,   94,    0,   94,    0,    0,    0,    0,    0,    0,
659       94,   99,   99,    0,    0,   99,    0,    0,    0,    0,
660        0,   99,   99,  199,  199,  199,  199,  199,  199,  199,
661      199,  199,  200,  200,  200,  200,  200,  200,  200,  200,
662
663      200,  201,  201,  201,  201,  201,  201,  201,  201,  201,
664      202,  202,  202,  202,  202,  202,  202,  202,  202,  203,
665      203,  203,  203,  203,  203,  203,  203,  203,  204,  204,
666      204,  204,  204,  204,  204,  204,  204,  205,  205,  205,
667      205,  205,  205,  205,  205,  205,  206,  206,  206,  206,
668      206,  206,  206,  206,  206,  207,  207,  207,  207,  207,
669      207,  207,  207,  207,  208,  208,  208,  208,  208,  208,
670      208,  208,  208,  209,  209,  209,  209,  209,  209,  209,
671      209,  209,  210,  210,  210,  210,  210,  210,  210,  210,
672      210,  211,  211,  211,  211,  211,  211,  211,  211,  211,
673
674      212,    0,    0,    0,  212,  212,    0,  212,  213,    0,
675        0,    0,  213,  213,    0,  213,  214,    0,    0,    0,
676      214,  214,    0,  214,  215,    0,    0,    0,  215,  215,
677        0,  215,  216,    0,    0,    0,  216,  216,    0,  216,
678      217,    0,  217,  218,    0,  218,  219,    0,  219,  220,
679        0,  220,  221,    0,  221,  222,    0,    0,    0,  222,
680      222,    0,  222,  223,    0,  223,  224,    0,    0,    0,
681      224,  224,    0,  224,  225,    0,  225,  226,    0,  226,
682      227,    0,    0,    0,  227,  227,    0,  227,  228,    0,
683      228,  229,    0,  229,  230,    0,    0,    0,  230,  230,
684
685        0,  230,  231,  231,    0,  231,  231,  231,  231,  231,
686      232,  232,    0,  232,  232,  232,  232,  232,  232,  233,
687      233,    0,    0,  233,  233,  233,  233,  233,  234,    0,
688        0,  234,  234,  234,  234,  234,  234,  235,  235,  236,
689      236,  198,  198,  198,  198,  198,  198,  198,  198,  198,
690      198,  198,  198,  198,  198,  198,  198,  198,  198,  198
691    } ;
692
693static yy_state_type yy_last_accepting_state;
694static char *yy_last_accepting_cpos;
695
696extern int yy_flex_debug;
697int yy_flex_debug = 0;
698
699/* The intent behind this definition is that it'll catch
700 * any uses of REJECT which flex missed.
701 */
702#define REJECT reject_used_but_not_detected
703#define yymore() yymore_used_but_not_detected
704#define YY_MORE_ADJ 0
705#define YY_RESTORE_YY_MORE_OFFSET
706char *yytext;
707#line 1 "scan.l"
708/******************************************************************************
709
710  KPP - The Kinetic PreProcessor
711        Builds simulation code for chemical kinetic systems
712
713  Copyright (C) 1995-1996 Valeriu Damian and Adrian Sandu
714  Copyright (C) 1997-2005 Adrian Sandu
715
716  KPP is free software; you can redistribute it and/or modify it under the
717  terms of the GNU General Public License as published by the Free Software
718  Foundation (http://www.gnu.org/copyleft/gpl.html); either version 2 of the
719  License, or (at your option) any later version.
720
721  KPP is distributed in the hope that it will be useful, but WITHOUT ANY
722  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
723  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
724  details.
725
726  You should have received a copy of the GNU General Public License along
727  with this program; if not, consult http://www.gnu.org/copyleft/gpl.html or
728  write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
729  Boston, MA  02111-1307,  USA.
730
731  Adrian Sandu
732  Computer Science Department
733  Virginia Polytechnic Institute and State University
734  Blacksburg, VA 24060
735  E-mail: sandu@cs.vt.edu
736
737******************************************************************************/
738/******************************************************************************
739  bug fixes for upgrading from yacc to bison implemented by Rolf Sander,
740  following suggestions from Jason Lander <jason@env.leeds.ac.uk>
741******************************************************************************/
742 
743 
744 
745
746
747
748#line 45 "scan.l"
749  #include <string.h> /* strcpy, strlen */
750  #include "gdata.h"
751  #include "scan.h"
752  #include "y.tab.h"
753
754  void Include ( char * filename );
755  int EndInclude();
756
757  int crt_line_no = 1;
758  char *crt_filename;
759
760  #define MAX_INCLUDE 10
761 
762  YY_BUFFER_STATE yy_buffers[ MAX_INCLUDE ];
763  int yy_line_no[ MAX_INCLUDE ];
764  char *yy_filename[ MAX_INCLUDE ];
765  int yy_buf_level = 0;
766 
767  char crtToken[100];
768  char nextToken[100];
769  int crtTokType;
770  int nextTokType;
771  int crtLine;
772  char crtFile[100];
773  char crt_rate[100];
774
775  int oldnErr = 0;
776
777  int idx;
778  int oldstate;
779  extern int yyerrflag;
780
781  typedef struct {
782                   char *name;
783                   int next;
784                   int cmd; 
785                 } KEYWORD;
786
787  KEYWORD keywords[];
788
789  int CheckKeyword( char *cmd );
790
791#define RETURN( x ) \
792        if(1) { \
793          if ( yyerrflag == 0) { \
794            strcpy( crtToken, nextToken ); \
795            crtTokType = nextTokType; \
796            crtLine = crt_line_no; \
797            strcpy( crtFile, crt_filename ); \
798          } \
799          strcpy( nextToken, yytext); \
800          nextTokType = x; \
801          return (x); \
802        }
803#line 804 "lex.yy.c"
804
805#define INITIAL 0
806#define CMD_STATE 1
807#define INC_STATE 2
808#define MOD_STATE 3
809#define INT_STATE 4
810#define PRM_STATE 5
811#define DSP_STATE 6
812#define SSP_STATE 7
813#define INI_STATE 8
814#define EQN_STATE 9
815#define EQNTAG_STATE 10
816#define RATE_STATE 11
817#define LMP_STATE 12
818#define CR_IGNORE 13
819#define SC_IGNORE 14
820#define ATM_STATE 15
821#define LKT_STATE 16
822#define INL_STATE 17
823#define MNI_STATE 18
824#define TPT_STATE 19
825#define USE_STATE 20
826#define COMMENT 21
827#define COMMENT2 22
828#define EQN_ID 23
829#define INL_CODE 24
830
831#ifndef YY_NO_UNISTD_H
832/* Special case for "unistd.h", since it is non-ANSI. We include it way
833 * down here because we want the user's section 1 to have been scanned first.
834 * The user has a chance to override it with an option.
835 */
836#include <unistd.h>
837#endif
838
839#ifndef YY_EXTRA_TYPE
840#define YY_EXTRA_TYPE void *
841#endif
842
843static int yy_init_globals (void );
844
845/* Accessor methods to globals.
846   These are made visible to non-reentrant scanners for convenience. */
847
848int yylex_destroy (void );
849
850int yyget_debug (void );
851
852void yyset_debug (int debug_flag  );
853
854YY_EXTRA_TYPE yyget_extra (void );
855
856void yyset_extra (YY_EXTRA_TYPE user_defined  );
857
858FILE *yyget_in (void );
859
860void yyset_in  (FILE * in_str  );
861
862FILE *yyget_out (void );
863
864void yyset_out  (FILE * out_str  );
865
866yy_size_t yyget_leng (void );
867
868char *yyget_text (void );
869
870int yyget_lineno (void );
871
872void yyset_lineno (int line_number  );
873
874/* Macros after this point can all be overridden by user definitions in
875 * section 1.
876 */
877
878#ifndef YY_SKIP_YYWRAP
879#ifdef __cplusplus
880extern "C" int yywrap (void );
881#else
882extern int yywrap (void );
883#endif
884#endif
885
886    static void yyunput (int c,char *buf_ptr  );
887   
888#ifndef yytext_ptr
889static void yy_flex_strncpy (char *,yyconst char *,int );
890#endif
891
892#ifdef YY_NEED_STRLEN
893static int yy_flex_strlen (yyconst char * );
894#endif
895
896#ifndef YY_NO_INPUT
897
898#ifdef __cplusplus
899static int yyinput (void );
900#else
901static int input (void );
902#endif
903
904#endif
905
906/* Amount of stuff to slurp up with each read. */
907#ifndef YY_READ_BUF_SIZE
908#define YY_READ_BUF_SIZE 8192
909#endif
910
911/* Copy whatever the last rule matched to the standard output. */
912#ifndef ECHO
913/* This used to be an fputs(), but since the string might contain NUL's,
914 * we now use fwrite().
915 */
916#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
917#endif
918
919/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
920 * is returned in "result".
921 */
922#ifndef YY_INPUT
923#define YY_INPUT(buf,result,max_size) \
924        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
925                { \
926                int c = '*'; \
927                size_t n; \
928                for ( n = 0; n < max_size && \
929                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
930                        buf[n] = (char) c; \
931                if ( c == '\n' ) \
932                        buf[n++] = (char) c; \
933                if ( c == EOF && ferror( yyin ) ) \
934                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
935                result = n; \
936                } \
937        else \
938                { \
939                errno=0; \
940                while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
941                        { \
942                        if( errno != EINTR) \
943                                { \
944                                YY_FATAL_ERROR( "input in flex scanner failed" ); \
945                                break; \
946                                } \
947                        errno=0; \
948                        clearerr(yyin); \
949                        } \
950                }\
951\
952
953#endif
954
955/* No semi-colon after return; correct usage is to write "yyterminate();" -
956 * we don't want an extra ';' after the "return" because that will cause
957 * some compilers to complain about unreachable statements.
958 */
959#ifndef yyterminate
960#define yyterminate() return YY_NULL
961#endif
962
963/* Number of entries by which start-condition stack grows. */
964#ifndef YY_START_STACK_INCR
965#define YY_START_STACK_INCR 25
966#endif
967
968/* Report a fatal error. */
969#ifndef YY_FATAL_ERROR
970#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
971#endif
972
973/* end tables serialization structures and prototypes */
974
975/* Default declaration of generated scanner - a define so the user can
976 * easily add parameters.
977 */
978#ifndef YY_DECL
979#define YY_DECL_IS_OURS 1
980
981extern int yylex (void);
982
983#define YY_DECL int yylex (void)
984#endif /* !YY_DECL */
985
986/* Code executed at the beginning of each rule, after yytext and yyleng
987 * have been set up.
988 */
989#ifndef YY_USER_ACTION
990#define YY_USER_ACTION
991#endif
992
993/* Code executed at the end of each rule. */
994#ifndef YY_BREAK
995#define YY_BREAK break;
996#endif
997
998#define YY_RULE_SETUP \
999        YY_USER_ACTION
1000
1001/** The main scanner function which does all the work.
1002 */
1003YY_DECL
1004{
1005        register yy_state_type yy_current_state;
1006        register char *yy_cp, *yy_bp;
1007        register int yy_act;
1008   
1009#line 120 "scan.l"
1010
1011#line 1012 "lex.yy.c"
1012
1013        if ( !(yy_init) )
1014                {
1015                (yy_init) = 1;
1016
1017#ifdef YY_USER_INIT
1018                YY_USER_INIT;
1019#endif
1020
1021                if ( ! (yy_start) )
1022                        (yy_start) = 1; /* first start state */
1023
1024                if ( ! yyin )
1025                        yyin = stdin;
1026
1027                if ( ! yyout )
1028                        yyout = stdout;
1029
1030                if ( ! YY_CURRENT_BUFFER ) {
1031                        yyensure_buffer_stack ();
1032                        YY_CURRENT_BUFFER_LVALUE =
1033                                yy_create_buffer(yyin,YY_BUF_SIZE );
1034                }
1035
1036                yy_load_buffer_state( );
1037                }
1038
1039        while ( 1 )             /* loops until end-of-file is reached */
1040                {
1041                yy_cp = (yy_c_buf_p);
1042
1043                /* Support of yytext. */
1044                *yy_cp = (yy_hold_char);
1045
1046                /* yy_bp points to the position in yy_ch_buf of the start of
1047                 * the current run.
1048                 */
1049                yy_bp = yy_cp;
1050
1051                yy_current_state = (yy_start);
1052yy_match:
1053                do
1054                        {
1055                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1056                        if ( yy_accept[yy_current_state] )
1057                                {
1058                                (yy_last_accepting_state) = yy_current_state;
1059                                (yy_last_accepting_cpos) = yy_cp;
1060                                }
1061                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1062                                {
1063                                yy_current_state = (int) yy_def[yy_current_state];
1064                                if ( yy_current_state >= 199 )
1065                                        yy_c = yy_meta[(unsigned int) yy_c];
1066                                }
1067                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1068                        ++yy_cp;
1069                        }
1070                while ( yy_base[yy_current_state] != 842 );
1071
1072yy_find_action:
1073                yy_act = yy_accept[yy_current_state];
1074                if ( yy_act == 0 )
1075                        { /* have to back up */
1076                        yy_cp = (yy_last_accepting_cpos);
1077                        yy_current_state = (yy_last_accepting_state);
1078                        yy_act = yy_accept[yy_current_state];
1079                        }
1080
1081                YY_DO_BEFORE_ACTION;
1082
1083do_action:      /* This label is used only to access EOF actions. */
1084
1085                switch ( yy_act )
1086        { /* beginning of action switch */
1087                        case 0: /* must back up */
1088                        /* undo the effects of YY_DO_BEFORE_ACTION */
1089                        *yy_cp = (yy_hold_char);
1090                        yy_cp = (yy_last_accepting_cpos);
1091                        yy_current_state = (yy_last_accepting_state);
1092                        goto yy_find_action;
1093
1094case 1:
1095YY_RULE_SETUP
1096#line 121 "scan.l"
1097{
1098                        } 
1099        YY_BREAK
1100case 2:
1101YY_RULE_SETUP
1102#line 123 "scan.l"
1103{ BEGIN CMD_STATE; 
1104                        }
1105        YY_BREAK
1106case 3:
1107YY_RULE_SETUP
1108#line 125 "scan.l"
1109{ oldstate = (yy_start - 1) / 2;
1110                          BEGIN COMMENT;
1111                        }
1112        YY_BREAK
1113case 4:
1114YY_RULE_SETUP
1115#line 128 "scan.l"
1116{ oldstate = (yy_start - 1) / 2;
1117                          BEGIN COMMENT2;
1118                        }
1119        YY_BREAK
1120case 5:
1121YY_RULE_SETUP
1122#line 131 "scan.l"
1123{
1124                        } 
1125        YY_BREAK
1126case 6:
1127YY_RULE_SETUP
1128#line 133 "scan.l"
1129{ BEGIN oldstate;
1130                        }   
1131        YY_BREAK
1132case 7:
1133YY_RULE_SETUP
1134#line 135 "scan.l"
1135{
1136                        } 
1137        YY_BREAK
1138case 8:
1139/* rule 8 can match eol */
1140YY_RULE_SETUP
1141#line 137 "scan.l"
1142{ crt_line_no++; 
1143                          BEGIN oldstate;
1144                        }   
1145        YY_BREAK
1146case 9:
1147/* rule 9 can match eol */
1148YY_RULE_SETUP
1149#line 140 "scan.l"
1150{ crt_line_no++; 
1151                        }
1152        YY_BREAK
1153case 10:
1154YY_RULE_SETUP
1155#line 142 "scan.l"
1156{ idx = CheckKeyword( yytext );
1157                          if ( idx < 0 ) { 
1158                            BEGIN CR_IGNORE;
1159                            break; 
1160                          } 
1161                          BEGIN keywords[idx].next;
1162                          if ( keywords[idx].cmd ) {
1163                            crt_section = keywords[idx].cmd;
1164                            RETURN( keywords[idx].cmd );
1165                          }
1166                        } 
1167        YY_BREAK
1168case 11:
1169YY_RULE_SETUP
1170#line 153 "scan.l"
1171{ Include( IncName(yytext) );
1172                          BEGIN CR_IGNORE;
1173                        } 
1174        YY_BREAK
1175case 12:
1176YY_RULE_SETUP
1177#line 156 "scan.l"
1178{ Include( ModelName(yytext) );
1179                          BEGIN CR_IGNORE;
1180                        } 
1181        YY_BREAK
1182case 13:
1183YY_RULE_SETUP
1184#line 159 "scan.l"
1185{ Include( IntegName(yytext) );
1186                          BEGIN CR_IGNORE;
1187                        } 
1188        YY_BREAK
1189case 14:
1190YY_RULE_SETUP
1191#line 162 "scan.l"
1192{ strcpy( yylval.str, yytext );
1193                          BEGIN CR_IGNORE;                         
1194                          RETURN( PARAMETER ); 
1195                        }
1196        YY_BREAK
1197case 15:
1198YY_RULE_SETUP
1199#line 166 "scan.l"
1200{ ScanError("Extra parameter on command line '%s'", yytext);
1201                        }
1202        YY_BREAK
1203case 16:
1204YY_RULE_SETUP
1205#line 168 "scan.l"
1206{ strcpy( yylval.str, yytext );
1207                          RETURN( ATOMID );
1208                        }
1209        YY_BREAK
1210case 17:
1211YY_RULE_SETUP
1212#line 171 "scan.l"
1213{ RETURN( yytext[0] );
1214                        } 
1215        YY_BREAK
1216case 18:
1217YY_RULE_SETUP
1218#line 173 "scan.l"
1219{ strcpy( yylval.str, yytext );
1220                          RETURN( SPCSPC );
1221                        }
1222        YY_BREAK
1223case 19:
1224YY_RULE_SETUP
1225#line 176 "scan.l"
1226{ strcpy( yylval.str, yytext );
1227                          RETURN( SPCNR );
1228                        }
1229        YY_BREAK
1230case 20:
1231YY_RULE_SETUP
1232#line 179 "scan.l"
1233{ RETURN( SPCEQUAL );
1234                        } 
1235        YY_BREAK
1236case 21:
1237YY_RULE_SETUP
1238#line 181 "scan.l"
1239{ RETURN( SPCPLUS );
1240                        } 
1241        YY_BREAK
1242case 22:
1243YY_RULE_SETUP
1244#line 183 "scan.l"
1245{ RETURN( yytext[0] );
1246                        } 
1247        YY_BREAK
1248case 23:
1249/* rule 23 can match eol */
1250YY_RULE_SETUP
1251#line 185 "scan.l"
1252{ ScanError("Invalid character '%c' in species definition", yytext[0] );
1253                        }
1254        YY_BREAK
1255case 24:
1256YY_RULE_SETUP
1257#line 187 "scan.l"
1258{ strcpy( yylval.str, yytext );
1259                          RETURN( SSPID );
1260                        }
1261        YY_BREAK
1262case 25:
1263YY_RULE_SETUP
1264#line 190 "scan.l"
1265{ RETURN( yytext[0] );
1266                        } 
1267        YY_BREAK
1268case 26:
1269YY_RULE_SETUP
1270#line 192 "scan.l"
1271{ strcpy( yylval.str, yytext );
1272                          RETURN( INISPC ); 
1273                        } 
1274        YY_BREAK
1275case 27:
1276YY_RULE_SETUP
1277#line 195 "scan.l"
1278{ RETURN( INIEQUAL );
1279                        } 
1280        YY_BREAK
1281case 28:
1282YY_RULE_SETUP
1283#line 197 "scan.l"
1284{ RETURN( yytext[0] );
1285                        } 
1286        YY_BREAK
1287case 29:
1288YY_RULE_SETUP
1289#line 199 "scan.l"
1290{ strcpy( yylval.str, yytext );
1291                          RETURN( INIVALUE ); 
1292                        } 
1293        YY_BREAK
1294case 30:
1295/* rule 30 can match eol */
1296YY_RULE_SETUP
1297#line 202 "scan.l"
1298{ ScanError("Invalid character '%c' in initial values", yytext[0] );
1299                        }
1300        YY_BREAK
1301case 31:
1302YY_RULE_SETUP
1303#line 204 "scan.l"
1304{ strcpy( yylval.str, yytext );
1305                          RETURN( EQNSPC );
1306                        } 
1307        YY_BREAK
1308case 32:
1309YY_RULE_SETUP
1310#line 207 "scan.l"
1311{ RETURN( EQNEQUAL );
1312                        } 
1313        YY_BREAK
1314case 33:
1315YY_RULE_SETUP
1316#line 209 "scan.l"
1317{ strcpy( yylval.str, yytext );
1318                          RETURN( EQNCOEF ); 
1319                        } 
1320        YY_BREAK
1321case 34:
1322YY_RULE_SETUP
1323#line 212 "scan.l"
1324{ BEGIN RATE_STATE;
1325                          *crt_rate = 0;
1326                          RETURN( EQNCOLON );
1327                        } 
1328        YY_BREAK
1329case 35:
1330YY_RULE_SETUP
1331#line 216 "scan.l"
1332{ strcpy( yylval.str, yytext );
1333                          RETURN( EQNSIGN );
1334                        } 
1335        YY_BREAK
1336case 36:
1337YY_RULE_SETUP
1338#line 219 "scan.l"
1339{ BEGIN EQNTAG_STATE;
1340                          RETURN( EQNLESS );
1341                        }
1342        YY_BREAK
1343case 37:
1344YY_RULE_SETUP
1345#line 222 "scan.l"
1346{ strcpy( yylval.str, yytext );
1347                          RETURN( EQNTAG );
1348                        } 
1349        YY_BREAK
1350case 38:
1351YY_RULE_SETUP
1352#line 225 "scan.l"
1353{ BEGIN EQN_STATE;
1354                          RETURN( EQNGREATER );
1355                        }   
1356        YY_BREAK
1357case 39:
1358YY_RULE_SETUP
1359#line 228 "scan.l"
1360{ strcpy( yylval.str, yytext );
1361                          RETURN( RATE );
1362                        } 
1363        YY_BREAK
1364case 40:
1365YY_RULE_SETUP
1366#line 231 "scan.l"
1367{ BEGIN EQN_STATE;
1368                          RETURN( yytext[0] );
1369                        } 
1370        YY_BREAK
1371case 41:
1372YY_RULE_SETUP
1373#line 234 "scan.l"
1374{ strcpy( yylval.str, yytext );
1375                          RETURN( LMPSPC );
1376                        }
1377        YY_BREAK
1378case 42:
1379YY_RULE_SETUP
1380#line 237 "scan.l"
1381{ RETURN( LMPPLUS );
1382                        } 
1383        YY_BREAK
1384case 43:
1385YY_RULE_SETUP
1386#line 239 "scan.l"
1387{ RETURN( LMPCOLON );
1388                        } 
1389        YY_BREAK
1390case 44:
1391YY_RULE_SETUP
1392#line 241 "scan.l"
1393{ RETURN( yytext[0] );
1394                        } 
1395        YY_BREAK
1396case 45:
1397/* rule 45 can match eol */
1398YY_RULE_SETUP
1399#line 243 "scan.l"
1400{ ScanError("Invalid character '%c' in species definition", yytext[0] );
1401                        }
1402        YY_BREAK
1403case 46:
1404YY_RULE_SETUP
1405#line 245 "scan.l"
1406{ strcpy( yylval.str, yytext );
1407                          RETURN( LKTID );
1408                        }
1409        YY_BREAK
1410case 47:
1411YY_RULE_SETUP
1412#line 248 "scan.l"
1413{ RETURN( yytext[0] );
1414                        } 
1415        YY_BREAK
1416case 48:
1417YY_RULE_SETUP
1418#line 250 "scan.l"
1419{ strcpy( yylval.str, yytext );
1420                          RETURN( TPTID );
1421                        }
1422        YY_BREAK
1423case 49:
1424YY_RULE_SETUP
1425#line 253 "scan.l"
1426{ RETURN( yytext[0] );
1427                        } 
1428        YY_BREAK
1429case 50:
1430YY_RULE_SETUP
1431#line 255 "scan.l"
1432{ strcpy( yylval.str, yytext );
1433                          RETURN( USEID );
1434                        }
1435        YY_BREAK
1436case 51:
1437YY_RULE_SETUP
1438#line 258 "scan.l"
1439{ RETURN( yytext[0] );
1440                        } 
1441        YY_BREAK
1442case 52:
1443YY_RULE_SETUP
1444#line 260 "scan.l"
1445{ strcpy( yylval.str, yytext );
1446                          RETURN( MNIID );
1447                        }
1448        YY_BREAK
1449case 53:
1450YY_RULE_SETUP
1451#line 263 "scan.l"
1452{ RETURN( yytext[0] );
1453                        } 
1454        YY_BREAK
1455case 54:
1456YY_RULE_SETUP
1457#line 265 "scan.l"
1458{ strcpy( yylval.str, yytext );
1459                          BEGIN INL_CODE;
1460                          RETURN( INLCTX );
1461                        }
1462        YY_BREAK
1463case 55:
1464YY_RULE_SETUP
1465#line 269 "scan.l"
1466{ if ( EqNoCase( yytext+1, "ENDINLINE" ) ){
1467                            BEGIN INITIAL;
1468                            RETURN( ENDINLINE );
1469                          }
1470                          else {
1471                            strcpy( yylval.str, yytext );
1472                            RETURN( INCODE );
1473                          }
1474                        }
1475        YY_BREAK
1476case 56:
1477/* rule 56 can match eol */
1478YY_RULE_SETUP
1479#line 278 "scan.l"
1480{ crt_line_no++;
1481                          strcpy( yylval.str,yytext );
1482                          RETURN( INCODE );
1483                        }
1484        YY_BREAK
1485case 57:
1486YY_RULE_SETUP
1487#line 282 "scan.l"
1488{ strcpy( yylval.str,yytext );
1489                          RETURN( INCODE );
1490                        }
1491        YY_BREAK
1492case YY_STATE_EOF(INITIAL):
1493case YY_STATE_EOF(CMD_STATE):
1494case YY_STATE_EOF(INC_STATE):
1495case YY_STATE_EOF(MOD_STATE):
1496case YY_STATE_EOF(INT_STATE):
1497case YY_STATE_EOF(PRM_STATE):
1498case YY_STATE_EOF(DSP_STATE):
1499case YY_STATE_EOF(SSP_STATE):
1500case YY_STATE_EOF(INI_STATE):
1501case YY_STATE_EOF(EQN_STATE):
1502case YY_STATE_EOF(EQNTAG_STATE):
1503case YY_STATE_EOF(RATE_STATE):
1504case YY_STATE_EOF(LMP_STATE):
1505case YY_STATE_EOF(CR_IGNORE):
1506case YY_STATE_EOF(SC_IGNORE):
1507case YY_STATE_EOF(ATM_STATE):
1508case YY_STATE_EOF(LKT_STATE):
1509case YY_STATE_EOF(INL_STATE):
1510case YY_STATE_EOF(MNI_STATE):
1511case YY_STATE_EOF(TPT_STATE):
1512case YY_STATE_EOF(USE_STATE):
1513case YY_STATE_EOF(COMMENT):
1514case YY_STATE_EOF(COMMENT2):
1515case YY_STATE_EOF(EQN_ID):
1516case YY_STATE_EOF(INL_CODE):
1517#line 285 "scan.l"
1518{ if ( ! EndInclude() ) {
1519                            RETURN( INITIAL );
1520                          }
1521                        } 
1522        YY_BREAK
1523case 58:
1524YY_RULE_SETUP
1525#line 289 "scan.l"
1526ECHO;
1527        YY_BREAK
1528#line 1529 "lex.yy.c"
1529
1530        case YY_END_OF_BUFFER:
1531                {
1532                /* Amount of text matched not including the EOB char. */
1533                int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1534
1535                /* Undo the effects of YY_DO_BEFORE_ACTION. */
1536                *yy_cp = (yy_hold_char);
1537                YY_RESTORE_YY_MORE_OFFSET
1538
1539                if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1540                        {
1541                        /* We're scanning a new file or input source.  It's
1542                         * possible that this happened because the user
1543                         * just pointed yyin at a new source and called
1544                         * yylex().  If so, then we have to assure
1545                         * consistency between YY_CURRENT_BUFFER and our
1546                         * globals.  Here is the right place to do so, because
1547                         * this is the first action (other than possibly a
1548                         * back-up) that will match for the new input source.
1549                         */
1550                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1551                        YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1552                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1553                        }
1554
1555                /* Note that here we test for yy_c_buf_p "<=" to the position
1556                 * of the first EOB in the buffer, since yy_c_buf_p will
1557                 * already have been incremented past the NUL character
1558                 * (since all states make transitions on EOB to the
1559                 * end-of-buffer state).  Contrast this with the test
1560                 * in input().
1561                 */
1562                if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1563                        { /* This was really a NUL. */
1564                        yy_state_type yy_next_state;
1565
1566                        (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1567
1568                        yy_current_state = yy_get_previous_state(  );
1569
1570                        /* Okay, we're now positioned to make the NUL
1571                         * transition.  We couldn't have
1572                         * yy_get_previous_state() go ahead and do it
1573                         * for us because it doesn't know how to deal
1574                         * with the possibility of jamming (and we don't
1575                         * want to build jamming into it because then it
1576                         * will run more slowly).
1577                         */
1578
1579                        yy_next_state = yy_try_NUL_trans( yy_current_state );
1580
1581                        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1582
1583                        if ( yy_next_state )
1584                                {
1585                                /* Consume the NUL. */
1586                                yy_cp = ++(yy_c_buf_p);
1587                                yy_current_state = yy_next_state;
1588                                goto yy_match;
1589                                }
1590
1591                        else
1592                                {
1593                                yy_cp = (yy_c_buf_p);
1594                                goto yy_find_action;
1595                                }
1596                        }
1597
1598                else switch ( yy_get_next_buffer(  ) )
1599                        {
1600                        case EOB_ACT_END_OF_FILE:
1601                                {
1602                                (yy_did_buffer_switch_on_eof) = 0;
1603
1604                                if ( yywrap( ) )
1605                                        {
1606                                        /* Note: because we've taken care in
1607                                         * yy_get_next_buffer() to have set up
1608                                         * yytext, we can now set up
1609                                         * yy_c_buf_p so that if some total
1610                                         * hoser (like flex itself) wants to
1611                                         * call the scanner after we return the
1612                                         * YY_NULL, it'll still work - another
1613                                         * YY_NULL will get returned.
1614                                         */
1615                                        (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1616
1617                                        yy_act = YY_STATE_EOF(YY_START);
1618                                        goto do_action;
1619                                        }
1620
1621                                else
1622                                        {
1623                                        if ( ! (yy_did_buffer_switch_on_eof) )
1624                                                YY_NEW_FILE;
1625                                        }
1626                                break;
1627                                }
1628
1629                        case EOB_ACT_CONTINUE_SCAN:
1630                                (yy_c_buf_p) =
1631                                        (yytext_ptr) + yy_amount_of_matched_text;
1632
1633                                yy_current_state = yy_get_previous_state(  );
1634
1635                                yy_cp = (yy_c_buf_p);
1636                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1637                                goto yy_match;
1638
1639                        case EOB_ACT_LAST_MATCH:
1640                                (yy_c_buf_p) =
1641                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1642
1643                                yy_current_state = yy_get_previous_state(  );
1644
1645                                yy_cp = (yy_c_buf_p);
1646                                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1647                                goto yy_find_action;
1648                        }
1649                break;
1650                }
1651
1652        default:
1653                YY_FATAL_ERROR(
1654                        "fatal flex scanner internal error--no action found" );
1655        } /* end of action switch */
1656                } /* end of scanning one token */
1657} /* end of yylex */
1658
1659/* yy_get_next_buffer - try to read in a new buffer
1660 *
1661 * Returns a code representing an action:
1662 *      EOB_ACT_LAST_MATCH -
1663 *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1664 *      EOB_ACT_END_OF_FILE - end of file
1665 */
1666static int yy_get_next_buffer (void)
1667{
1668        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1669        register char *source = (yytext_ptr);
1670        register int number_to_move, i;
1671        int ret_val;
1672
1673        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1674                YY_FATAL_ERROR(
1675                "fatal flex scanner internal error--end of buffer missed" );
1676
1677        if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1678                { /* Don't try to fill the buffer, so this is an EOF. */
1679                if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1680                        {
1681                        /* We matched a single character, the EOB, so
1682                         * treat this as a final EOF.
1683                         */
1684                        return EOB_ACT_END_OF_FILE;
1685                        }
1686
1687                else
1688                        {
1689                        /* We matched some text prior to the EOB, first
1690                         * process it.
1691                         */
1692                        return EOB_ACT_LAST_MATCH;
1693                        }
1694                }
1695
1696        /* Try to read more data. */
1697
1698        /* First move last chars to start of buffer. */
1699        number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1700
1701        for ( i = 0; i < number_to_move; ++i )
1702                *(dest++) = *(source++);
1703
1704        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1705                /* don't do the read, it's not guaranteed to return an EOF,
1706                 * just force an EOF
1707                 */
1708                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1709
1710        else
1711                {
1712                        yy_size_t num_to_read =
1713                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1714
1715                while ( num_to_read <= 0 )
1716                        { /* Not enough room in the buffer - grow it. */
1717
1718                        /* just a shorter name for the current buffer */
1719                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1720
1721                        int yy_c_buf_p_offset =
1722                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1723
1724                        if ( b->yy_is_our_buffer )
1725                                {
1726                                yy_size_t new_size = b->yy_buf_size * 2;
1727
1728                                if ( new_size <= 0 )
1729                                        b->yy_buf_size += b->yy_buf_size / 8;
1730                                else
1731                                        b->yy_buf_size *= 2;
1732
1733                                b->yy_ch_buf = (char *)
1734                                        /* Include room in for 2 EOB chars. */
1735                                        yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1736                                }
1737                        else
1738                                /* Can't grow it, we don't own it. */
1739                                b->yy_ch_buf = 0;
1740
1741                        if ( ! b->yy_ch_buf )
1742                                YY_FATAL_ERROR(
1743                                "fatal error - scanner input buffer overflow" );
1744
1745                        (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1746
1747                        num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1748                                                number_to_move - 1;
1749
1750                        }
1751
1752                if ( num_to_read > YY_READ_BUF_SIZE )
1753                        num_to_read = YY_READ_BUF_SIZE;
1754
1755                /* Read in more data. */
1756                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1757                        (yy_n_chars), num_to_read );
1758
1759                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1760                }
1761
1762        if ( (yy_n_chars) == 0 )
1763                {
1764                if ( number_to_move == YY_MORE_ADJ )
1765                        {
1766                        ret_val = EOB_ACT_END_OF_FILE;
1767                        yyrestart(yyin  );
1768                        }
1769
1770                else
1771                        {
1772                        ret_val = EOB_ACT_LAST_MATCH;
1773                        YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1774                                YY_BUFFER_EOF_PENDING;
1775                        }
1776                }
1777
1778        else
1779                ret_val = EOB_ACT_CONTINUE_SCAN;
1780
1781        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1782                /* Extend the array by 50%, plus the number we really need. */
1783                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1784                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1785                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1786                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1787        }
1788
1789        (yy_n_chars) += number_to_move;
1790        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1791        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1792
1793        (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1794
1795        return ret_val;
1796}
1797
1798/* yy_get_previous_state - get the state just before the EOB char was reached */
1799
1800    static yy_state_type yy_get_previous_state (void)
1801{
1802        register yy_state_type yy_current_state;
1803        register char *yy_cp;
1804   
1805        yy_current_state = (yy_start);
1806
1807        for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1808                {
1809                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1810                if ( yy_accept[yy_current_state] )
1811                        {
1812                        (yy_last_accepting_state) = yy_current_state;
1813                        (yy_last_accepting_cpos) = yy_cp;
1814                        }
1815                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1816                        {
1817                        yy_current_state = (int) yy_def[yy_current_state];
1818                        if ( yy_current_state >= 199 )
1819                                yy_c = yy_meta[(unsigned int) yy_c];
1820                        }
1821                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1822                }
1823
1824        return yy_current_state;
1825}
1826
1827/* yy_try_NUL_trans - try to make a transition on the NUL character
1828 *
1829 * synopsis
1830 *      next_state = yy_try_NUL_trans( current_state );
1831 */
1832    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1833{
1834        register int yy_is_jam;
1835        register char *yy_cp = (yy_c_buf_p);
1836
1837        register YY_CHAR yy_c = 1;
1838        if ( yy_accept[yy_current_state] )
1839                {
1840                (yy_last_accepting_state) = yy_current_state;
1841                (yy_last_accepting_cpos) = yy_cp;
1842                }
1843        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1844                {
1845                yy_current_state = (int) yy_def[yy_current_state];
1846                if ( yy_current_state >= 199 )
1847                        yy_c = yy_meta[(unsigned int) yy_c];
1848                }
1849        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1850        yy_is_jam = (yy_current_state == 198);
1851
1852                return yy_is_jam ? 0 : yy_current_state;
1853}
1854
1855    static void yyunput (int c, register char * yy_bp )
1856{
1857        register char *yy_cp;
1858   
1859    yy_cp = (yy_c_buf_p);
1860
1861        /* undo effects of setting up yytext */
1862        *yy_cp = (yy_hold_char);
1863
1864        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1865                { /* need to shift things up to make room */
1866                /* +2 for EOB chars. */
1867                register yy_size_t number_to_move = (yy_n_chars) + 2;
1868                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1869                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1870                register char *source =
1871                                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1872
1873                while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1874                        *--dest = *--source;
1875
1876                yy_cp += (int) (dest - source);
1877                yy_bp += (int) (dest - source);
1878                YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1879                        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1880
1881                if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1882                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
1883                }
1884
1885        *--yy_cp = (char) c;
1886
1887        (yytext_ptr) = yy_bp;
1888        (yy_hold_char) = *yy_cp;
1889        (yy_c_buf_p) = yy_cp;
1890}
1891
1892#ifndef YY_NO_INPUT
1893#ifdef __cplusplus
1894    static int yyinput (void)
1895#else
1896    static int input  (void)
1897#endif
1898
1899{
1900        int c;
1901   
1902        *(yy_c_buf_p) = (yy_hold_char);
1903
1904        if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1905                {
1906                /* yy_c_buf_p now points to the character we want to return.
1907                 * If this occurs *before* the EOB characters, then it's a
1908                 * valid NUL; if not, then we've hit the end of the buffer.
1909                 */
1910                if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1911                        /* This was really a NUL. */
1912                        *(yy_c_buf_p) = '\0';
1913
1914                else
1915                        { /* need more input */
1916                        yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1917                        ++(yy_c_buf_p);
1918
1919                        switch ( yy_get_next_buffer(  ) )
1920                                {
1921                                case EOB_ACT_LAST_MATCH:
1922                                        /* This happens because yy_g_n_b()
1923                                         * sees that we've accumulated a
1924                                         * token and flags that we need to
1925                                         * try matching the token before
1926                                         * proceeding.  But for input(),
1927                                         * there's no matching to consider.
1928                                         * So convert the EOB_ACT_LAST_MATCH
1929                                         * to EOB_ACT_END_OF_FILE.
1930                                         */
1931
1932                                        /* Reset buffer status. */
1933                                        yyrestart(yyin );
1934
1935                                        /*FALLTHROUGH*/
1936
1937                                case EOB_ACT_END_OF_FILE:
1938                                        {
1939                                        if ( yywrap( ) )
1940                                                return EOF;
1941
1942                                        if ( ! (yy_did_buffer_switch_on_eof) )
1943                                                YY_NEW_FILE;
1944#ifdef __cplusplus
1945                                        return yyinput();
1946#else
1947                                        return input();
1948#endif
1949                                        }
1950
1951                                case EOB_ACT_CONTINUE_SCAN:
1952                                        (yy_c_buf_p) = (yytext_ptr) + offset;
1953                                        break;
1954                                }
1955                        }
1956                }
1957
1958        c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1959        *(yy_c_buf_p) = '\0';   /* preserve yytext */
1960        (yy_hold_char) = *++(yy_c_buf_p);
1961
1962        return c;
1963}
1964#endif  /* ifndef YY_NO_INPUT */
1965
1966/** Immediately switch to a different input stream.
1967 * @param input_file A readable stream.
1968 *
1969 * @note This function does not reset the start condition to @c INITIAL .
1970 */
1971    void yyrestart  (FILE * input_file )
1972{
1973   
1974        if ( ! YY_CURRENT_BUFFER ){
1975        yyensure_buffer_stack ();
1976                YY_CURRENT_BUFFER_LVALUE =
1977            yy_create_buffer(yyin,YY_BUF_SIZE );
1978        }
1979
1980        yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1981        yy_load_buffer_state( );
1982}
1983
1984/** Switch to a different input buffer.
1985 * @param new_buffer The new input buffer.
1986 *
1987 */
1988    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1989{
1990   
1991        /* TODO. We should be able to replace this entire function body
1992         * with
1993         *              yypop_buffer_state();
1994         *              yypush_buffer_state(new_buffer);
1995     */
1996        yyensure_buffer_stack ();
1997        if ( YY_CURRENT_BUFFER == new_buffer )
1998                return;
1999
2000        if ( YY_CURRENT_BUFFER )
2001                {
2002                /* Flush out information for old buffer. */
2003                *(yy_c_buf_p) = (yy_hold_char);
2004                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2005                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2006                }
2007
2008        YY_CURRENT_BUFFER_LVALUE = new_buffer;
2009        yy_load_buffer_state( );
2010
2011        /* We don't actually know whether we did this switch during
2012         * EOF (yywrap()) processing, but the only time this flag
2013         * is looked at is after yywrap() is called, so it's safe
2014         * to go ahead and always set it.
2015         */
2016        (yy_did_buffer_switch_on_eof) = 1;
2017}
2018
2019static void yy_load_buffer_state  (void)
2020{
2021        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2022        (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2023        yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2024        (yy_hold_char) = *(yy_c_buf_p);
2025}
2026
2027/** Allocate and initialize an input buffer state.
2028 * @param file A readable stream.
2029 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2030 *
2031 * @return the allocated buffer state.
2032 */
2033    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2034{
2035        YY_BUFFER_STATE b;
2036   
2037        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2038        if ( ! b )
2039                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2040
2041        b->yy_buf_size = size;
2042
2043        /* yy_ch_buf has to be 2 characters longer than the size given because
2044         * we need to put in 2 end-of-buffer characters.
2045         */
2046        b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2047        if ( ! b->yy_ch_buf )
2048                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2049
2050        b->yy_is_our_buffer = 1;
2051
2052        yy_init_buffer(b,file );
2053
2054        return b;
2055}
2056
2057/** Destroy the buffer.
2058 * @param b a buffer created with yy_create_buffer()
2059 *
2060 */
2061    void yy_delete_buffer (YY_BUFFER_STATE  b )
2062{
2063   
2064        if ( ! b )
2065                return;
2066
2067        if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2068                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2069
2070        if ( b->yy_is_our_buffer )
2071                yyfree((void *) b->yy_ch_buf  );
2072
2073        yyfree((void *) b  );
2074}
2075
2076/* Initializes or reinitializes a buffer.
2077 * This function is sometimes called more than once on the same buffer,
2078 * such as during a yyrestart() or at EOF.
2079 */
2080    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2081
2082{
2083        int oerrno = errno;
2084   
2085        yy_flush_buffer(b );
2086
2087        b->yy_input_file = file;
2088        b->yy_fill_buffer = 1;
2089
2090    /* If b is the current buffer, then yy_init_buffer was _probably_
2091     * called from yyrestart() or through yy_get_next_buffer.
2092     * In that case, we don't want to reset the lineno or column.
2093     */
2094    if (b != YY_CURRENT_BUFFER){
2095        b->yy_bs_lineno = 1;
2096        b->yy_bs_column = 0;
2097    }
2098
2099        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2100   
2101        errno = oerrno;
2102}
2103
2104/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2105 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2106 *
2107 */
2108    void yy_flush_buffer (YY_BUFFER_STATE  b )
2109{
2110        if ( ! b )
2111                return;
2112
2113        b->yy_n_chars = 0;
2114
2115        /* We always need two end-of-buffer characters.  The first causes
2116         * a transition to the end-of-buffer state.  The second causes
2117         * a jam in that state.
2118         */
2119        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2120        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2121
2122        b->yy_buf_pos = &b->yy_ch_buf[0];
2123
2124        b->yy_at_bol = 1;
2125        b->yy_buffer_status = YY_BUFFER_NEW;
2126
2127        if ( b == YY_CURRENT_BUFFER )
2128                yy_load_buffer_state( );
2129}
2130
2131/** Pushes the new state onto the stack. The new state becomes
2132 *  the current state. This function will allocate the stack
2133 *  if necessary.
2134 *  @param new_buffer The new state.
2135 * 
2136 */
2137void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2138{
2139        if (new_buffer == NULL)
2140                return;
2141
2142        yyensure_buffer_stack();
2143
2144        /* This block is copied from yy_switch_to_buffer. */
2145        if ( YY_CURRENT_BUFFER )
2146                {
2147                /* Flush out information for old buffer. */
2148                *(yy_c_buf_p) = (yy_hold_char);
2149                YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2150                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2151                }
2152
2153        /* Only push if top exists. Otherwise, replace top. */
2154        if (YY_CURRENT_BUFFER)
2155                (yy_buffer_stack_top)++;
2156        YY_CURRENT_BUFFER_LVALUE = new_buffer;
2157
2158        /* copied from yy_switch_to_buffer. */
2159        yy_load_buffer_state( );
2160        (yy_did_buffer_switch_on_eof) = 1;
2161}
2162
2163/** Removes and deletes the top of the stack, if present.
2164 *  The next element becomes the new top.
2165 * 
2166 */
2167void yypop_buffer_state (void)
2168{
2169        if (!YY_CURRENT_BUFFER)
2170                return;
2171
2172        yy_delete_buffer(YY_CURRENT_BUFFER );
2173        YY_CURRENT_BUFFER_LVALUE = NULL;
2174        if ((yy_buffer_stack_top) > 0)
2175                --(yy_buffer_stack_top);
2176
2177        if (YY_CURRENT_BUFFER) {
2178                yy_load_buffer_state( );
2179                (yy_did_buffer_switch_on_eof) = 1;
2180        }
2181}
2182
2183/* Allocates the stack if it does not exist.
2184 *  Guarantees space for at least one push.
2185 */
2186static void yyensure_buffer_stack (void)
2187{
2188        yy_size_t num_to_alloc;
2189   
2190        if (!(yy_buffer_stack)) {
2191
2192                /* First allocation is just for 2 elements, since we don't know if this
2193                 * scanner will even need a stack. We use 2 instead of 1 to avoid an
2194                 * immediate realloc on the next call.
2195         */
2196                num_to_alloc = 1;
2197                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2198                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
2199                                                                );
2200                if ( ! (yy_buffer_stack) )
2201                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2202                                                                 
2203                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2204                               
2205                (yy_buffer_stack_max) = num_to_alloc;
2206                (yy_buffer_stack_top) = 0;
2207                return;
2208        }
2209
2210        if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2211
2212                /* Increase the buffer to prepare for a possible push. */
2213                int grow_size = 8 /* arbitrary grow size */;
2214
2215                num_to_alloc = (yy_buffer_stack_max) + grow_size;
2216                (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2217                                                                ((yy_buffer_stack),
2218                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
2219                                                                );
2220                if ( ! (yy_buffer_stack) )
2221                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2222
2223                /* zero only the new slots.*/
2224                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2225                (yy_buffer_stack_max) = num_to_alloc;
2226        }
2227}
2228
2229/** Setup the input buffer state to scan directly from a user-specified character buffer.
2230 * @param base the character buffer
2231 * @param size the size in bytes of the character buffer
2232 *
2233 * @return the newly allocated buffer state object.
2234 */
2235YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
2236{
2237        YY_BUFFER_STATE b;
2238   
2239        if ( size < 2 ||
2240             base[size-2] != YY_END_OF_BUFFER_CHAR ||
2241             base[size-1] != YY_END_OF_BUFFER_CHAR )
2242                /* They forgot to leave room for the EOB's. */
2243                return 0;
2244
2245        b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2246        if ( ! b )
2247                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2248
2249        b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2250        b->yy_buf_pos = b->yy_ch_buf = base;
2251        b->yy_is_our_buffer = 0;
2252        b->yy_input_file = 0;
2253        b->yy_n_chars = b->yy_buf_size;
2254        b->yy_is_interactive = 0;
2255        b->yy_at_bol = 1;
2256        b->yy_fill_buffer = 0;
2257        b->yy_buffer_status = YY_BUFFER_NEW;
2258
2259        yy_switch_to_buffer();
2260
2261        return b;
2262}
2263
2264/** Setup the input buffer state to scan a string. The next call to yylex() will
2265 * scan from a @e copy of @a str.
2266 * @param yystr a NUL-terminated string to scan
2267 *
2268 * @return the newly allocated buffer state object.
2269 * @note If you want to scan bytes that may contain NUL values, then use
2270 *       yy_scan_bytes() instead.
2271 */
2272YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
2273{
2274   
2275        return yy_scan_bytes(yystr,strlen(yystr) );
2276}
2277
2278/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
2279 * scan from a @e copy of @a bytes.
2280 * @param yybytes the byte buffer to scan
2281 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2282 *
2283 * @return the newly allocated buffer state object.
2284 */
2285YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
2286{
2287        YY_BUFFER_STATE b;
2288        char *buf;
2289        yy_size_t n;
2290        int i;
2291   
2292        /* Get memory for full buffer, including space for trailing EOB's. */
2293        n = _yybytes_len + 2;
2294        buf = (char *) yyalloc();
2295        if ( ! buf )
2296                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2297
2298        for ( i = 0; i < _yybytes_len; ++i )
2299                buf[i] = yybytes[i];
2300
2301        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2302
2303        b = yy_scan_buffer(buf,n );
2304        if ( ! b )
2305                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2306
2307        /* It's okay to grow etc. this buffer, and we should throw it
2308         * away when we're done.
2309         */
2310        b->yy_is_our_buffer = 1;
2311
2312        return b;
2313}
2314
2315#ifndef YY_EXIT_FAILURE
2316#define YY_EXIT_FAILURE 2
2317#endif
2318
2319static void yy_fatal_error (yyconst char* msg )
2320{
2321        (void) fprintf( stderr, "%s\n", msg );
2322        exit( YY_EXIT_FAILURE );
2323}
2324
2325/* Redefine yyless() so it works in section 3 code. */
2326
2327#undef yyless
2328#define yyless(n) \
2329        do \
2330                { \
2331                /* Undo effects of setting up yytext. */ \
2332        int yyless_macro_arg = (n); \
2333        YY_LESS_LINENO(yyless_macro_arg);\
2334                yytext[yyleng] = (yy_hold_char); \
2335                (yy_c_buf_p) = yytext + yyless_macro_arg; \
2336                (yy_hold_char) = *(yy_c_buf_p); \
2337                *(yy_c_buf_p) = '\0'; \
2338                yyleng = yyless_macro_arg; \
2339                } \
2340        while ( 0 )
2341
2342/* Accessor  methods (get/set functions) to struct members. */
2343
2344/** Get the current line number.
2345 *
2346 */
2347int yyget_lineno  (void)
2348{
2349       
2350    return yylineno;
2351}
2352
2353/** Get the input stream.
2354 *
2355 */
2356FILE *yyget_in  (void)
2357{
2358        return yyin;
2359}
2360
2361/** Get the output stream.
2362 *
2363 */
2364FILE *yyget_out  (void)
2365{
2366        return yyout;
2367}
2368
2369/** Get the length of the current token.
2370 *
2371 */
2372yy_size_t yyget_leng  (void)
2373{
2374        return yyleng;
2375}
2376
2377/** Get the current token.
2378 *
2379 */
2380
2381char *yyget_text  (void)
2382{
2383        return yytext;
2384}
2385
2386/** Set the current line number.
2387 * @param line_number
2388 *
2389 */
2390void yyset_lineno (int  line_number )
2391{
2392   
2393    yylineno = line_number;
2394}
2395
2396/** Set the input stream. This does not discard the current
2397 * input buffer.
2398 * @param in_str A readable stream.
2399 *
2400 * @see yy_switch_to_buffer
2401 */
2402void yyset_in (FILE *  in_str )
2403{
2404        yyin = in_str ;
2405}
2406
2407void yyset_out (FILE *  out_str )
2408{
2409        yyout = out_str ;
2410}
2411
2412int yyget_debug  (void)
2413{
2414        return yy_flex_debug;
2415}
2416
2417void yyset_debug (int  bdebug )
2418{
2419        yy_flex_debug = bdebug ;
2420}
2421
2422static int yy_init_globals (void)
2423{
2424        /* Initialization is the same as for the non-reentrant scanner.
2425     * This function is called from yylex_destroy(), so don't allocate here.
2426     */
2427
2428    (yy_buffer_stack) = 0;
2429    (yy_buffer_stack_top) = 0;
2430    (yy_buffer_stack_max) = 0;
2431    (yy_c_buf_p) = (char *) 0;
2432    (yy_init) = 0;
2433    (yy_start) = 0;
2434
2435/* Defined in main.c */
2436#ifdef YY_STDINIT
2437    yyin = stdin;
2438    yyout = stdout;
2439#else
2440    yyin = (FILE *) 0;
2441    yyout = (FILE *) 0;
2442#endif
2443
2444    /* For future reference: Set errno on error, since we are called by
2445     * yylex_init()
2446     */
2447    return 0;
2448}
2449
2450/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2451int yylex_destroy  (void)
2452{
2453   
2454    /* Pop the buffer stack, destroying each element. */
2455        while(YY_CURRENT_BUFFER){
2456                yy_delete_buffer(YY_CURRENT_BUFFER  );
2457                YY_CURRENT_BUFFER_LVALUE = NULL;
2458                yypop_buffer_state();
2459        }
2460
2461        /* Destroy the stack itself. */
2462        yyfree((yy_buffer_stack) );
2463        (yy_buffer_stack) = NULL;
2464
2465    /* Reset the globals. This is important in a non-reentrant scanner so the next time
2466     * yylex() is called, initialization will occur. */
2467    yy_init_globals( );
2468
2469    return 0;
2470}
2471
2472/*
2473 * Internal utility routines.
2474 */
2475
2476#ifndef yytext_ptr
2477static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2478{
2479        register int i;
2480        for ( i = 0; i < n; ++i )
2481                s1[i] = s2[i];
2482}
2483#endif
2484
2485#ifdef YY_NEED_STRLEN
2486static int yy_flex_strlen (yyconst char * s )
2487{
2488        register int n;
2489        for ( n = 0; s[n]; ++n )
2490                ;
2491
2492        return n;
2493}
2494#endif
2495
2496void *yyalloc (yy_size_t  size )
2497{
2498        return (void *) malloc( size );
2499}
2500
2501void *yyrealloc  (void * ptr, yy_size_t  size )
2502{
2503        /* The cast to (char *) in the following accommodates both
2504         * implementations that use char* generic pointers, and those
2505         * that use void* generic pointers.  It works with the latter
2506         * because both ANSI C and C++ allow castless assignment from
2507         * any pointer type to void*, and deal with argument conversions
2508         * as though doing an assignment.
2509         */
2510        return (void *) realloc( (char *) ptr, size );
2511}
2512
2513void yyfree (void * ptr )
2514{
2515        free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
2516}
2517
2518#define YYTABLES_NAME "yytables"
2519
2520#line 289 "scan.l"
2521
2522
2523
2524  KEYWORD keywords[] = { { "INCLUDE",    INC_STATE, 0 },
2525                         { "MODEL",      MOD_STATE, 0 },
2526                         { "INTEGRATOR", INT_STATE, 0 },
2527                         { "JACOBIAN",   PRM_STATE, JACOBIAN }, 
2528                         { "HESSIAN",    PRM_STATE, HESSIAN }, 
2529                         { "DECLARE",    PRM_STATE, DECLARE }, 
2530                         { "STOICMAT",   PRM_STATE, STOICMAT }, 
2531                         { "STOCHASTIC", PRM_STATE, STOCHASTIC }, 
2532                         { "DOUBLE",     PRM_STATE, DOUBLE }, 
2533                         { "REORDER",    PRM_STATE, REORDER }, 
2534                         { "MEX",        PRM_STATE, MEX }, 
2535                         { "DUMMYINDEX", PRM_STATE, DUMMYINDEX}, 
2536                         { "EQNTAGS",    PRM_STATE, EQNTAGS}, 
2537                         { "FUNCTION",   PRM_STATE, FUNCTION }, 
2538                         { "ATOMS",      ATM_STATE, ATOMDECL },   
2539                         { "CHECK",      ATM_STATE, CHECK },
2540                         { "CHECKALL",   INITIAL,   CHECKALL },
2541                         { "DEFVAR",     DSP_STATE, DEFVAR }, 
2542                         { "DEFRAD",     DSP_STATE, DEFVAR }, 
2543                         { "DEFFIX",     DSP_STATE, DEFFIX }, 
2544                         { "SETVAR",     SSP_STATE, SETVAR }, 
2545                         { "SETRAD",     SSP_STATE, SETVAR }, 
2546                         { "SETFIX",     SSP_STATE, SETFIX }, 
2547                         { "INITVALUES", INI_STATE, INITVALUES }, 
2548                         { "EQUATIONS",  EQN_STATE, EQUATIONS }, 
2549                         { "LUMP",       LMP_STATE, LUMP }, 
2550                         { "LOOKAT",     LKT_STATE, LOOKAT },
2551                         { "LOOKATALL",  INITIAL,   LOOKATALL },
2552                         { "TRANSPORT",  TPT_STATE, TRANSPORT },
2553                         { "TRANSPORTALL", INITIAL,   TRANSPORTALL },
2554                         { "INITIALIZE", PRM_STATE, INITIALIZE },
2555                         { "XGRID",      PRM_STATE, XGRID },
2556                         { "YGRID",      PRM_STATE, YGRID },
2557                         { "ZGRID",      PRM_STATE, ZGRID },
2558                         { "MONITOR",    MNI_STATE, MONITOR },
2559                         { "WRITE_ATM",  INITIAL,   WRITE_ATM },
2560                         { "WRITE_SPC",  INITIAL,   WRITE_SPC },
2561                         { "WRITE_MAT",  INITIAL,   WRITE_MAT },
2562                         { "WRITE_OPT",  INITIAL,   WRITE_OPT },
2563                         { "USE",        PRM_STATE, USE },
2564                         { "LANGUAGE",   PRM_STATE, LANGUAGE },
2565                         { "INLINE",     INL_STATE, INLINE },
2566                         { "ENDINLINE",  INITIAL,   ENDINLINE },
2567                         { "INTFILE",    PRM_STATE, INTFILE },
2568                         { "DRIVER",     PRM_STATE, DRIVER },
2569                         { "RUN",        PRM_STATE, RUN },
2570                         { "USES",       USE_STATE, USES },
2571                         { "SPARSEDATA", PRM_STATE, SPARSEDATA },
2572                         { 0, 0, 0 } 
2573                       };
2574
2575void Include ( char * name )
2576{
2577FILE *f;
2578YY_BUFFER_STATE newb;
2579
2580  if ( yy_buf_level == MAX_INCLUDE ) {
2581    printf("\nInclude nested too deep. Include %s ignored", name);
2582    return;
2583  }
2584
2585  yy_buffers[ yy_buf_level ]  = YY_CURRENT_BUFFER;
2586  yy_line_no[ yy_buf_level ]  = crt_line_no;
2587  yy_filename[ yy_buf_level ] = crt_filename;
2588  yy_buf_level++;
2589 
2590  crt_line_no = 1; 
2591
2592  crt_filename = malloc( 1 + strlen( name ) );
2593  strcpy( crt_filename, name ); 
2594
2595 
2596  f = fopen( name, "r" );
2597  if( f == 0 )
2598    FatalError(3,"%s: Can't read file", name );
2599
2600  newb = yy_create_buffer(f,YY_BUF_SIZE);
2601  yy_switch_to_buffer(newb );
2602}
2603
2604int EndInclude()
2605{
2606YY_BUFFER_STATE oldb;
2607char * oldn;
2608
2609  if ( yy_buf_level > 0 ) {
2610    oldb = YY_CURRENT_BUFFER;
2611    oldn = crt_filename; 
2612    yy_buf_level--;
2613    yy_switch_to_buffer(yy_buffers[yy_buf_level] );
2614    crt_line_no = yy_line_no[ yy_buf_level ];
2615    crt_filename = yy_filename[ yy_buf_level ]; 
2616    yy_delete_buffer(oldb ); 
2617    free( oldn );
2618    return 1;
2619  } 
2620  return 0;
2621}
2622
2623int EqNoCase( char *s1, char *s2 )
2624{
2625  while( *s1 ) {
2626    if ( toupper(*s1++) != toupper(*s2++) ) return 0;
2627  }
2628  return *s1 == *s2;
2629}
2630
2631int CheckKeyword( char *cmd )
2632{
2633int i;
2634
2635  i = 0;
2636  while( 1 ) {
2637    if( keywords[i].name == 0 ) {
2638      ScanError( "'%s': Unknown command (ignored)", cmd);
2639      return -1;
2640    }
2641    if( EqNoCase( cmd, keywords[i].name ) ) {
2642      return i;
2643    }
2644    i++;
2645  }
2646}
2647
2648
Note: See TracBrowser for help on using the repository browser.