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