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