Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
freaking paranoid flags!
[simgrid.git] / src / simdag / dax_dtd.c
1
2 #define  YY_INT_ALIGNED short int
3
4 /* A lexical scanner generated by flex */
5
6 #define yy_create_buffer dax__create_buffer
7 #define yy_delete_buffer dax__delete_buffer
8 #define yy_flex_debug dax__flex_debug
9 #define yy_init_buffer dax__init_buffer
10 #define yy_flush_buffer dax__flush_buffer
11 #define yy_load_buffer_state dax__load_buffer_state
12 #define yy_switch_to_buffer dax__switch_to_buffer
13 #define yyin dax_in
14 #define yyleng dax_leng
15 #define yylex dax_lex
16 #define yylineno dax_lineno
17 #define yyout dax_out
18 #define yyrestart dax_restart
19 #define yytext dax_text
20 #define yywrap dax_wrap
21 #define yyalloc dax_alloc
22 #define yyrealloc dax_realloc
23 #define yyfree dax_free
24
25 #define FLEX_SCANNER
26 #define YY_FLEX_MAJOR_VERSION 2
27 #define YY_FLEX_MINOR_VERSION 6
28 #define YY_FLEX_SUBMINOR_VERSION 0
29 #if YY_FLEX_SUBMINOR_VERSION > 0
30 #define FLEX_BETA
31 #endif
32
33 /* First, we deal with  platform-specific or compiler-specific issues. */
34
35 /* begin standard C headers. */
36 #include <stdio.h>
37 #include <string.h>
38 #include <errno.h>
39 #include <stdlib.h>
40
41 /* end standard C headers. */
42
43 /* flex integer type definitions */
44
45 #ifndef FLEXINT_H
46 #define FLEXINT_H
47
48 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
49
50 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
51
52 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
53  * if you want the limit (max/min) macros for int types. 
54  */
55 #ifndef __STDC_LIMIT_MACROS
56 #define __STDC_LIMIT_MACROS 1
57 #endif
58
59 #include <inttypes.h>
60 typedef int8_t flex_int8_t;
61 typedef uint8_t flex_uint8_t;
62 typedef int16_t flex_int16_t;
63 typedef uint16_t flex_uint16_t;
64 typedef int32_t flex_int32_t;
65 typedef uint32_t flex_uint32_t;
66 #else
67 typedef signed char flex_int8_t;
68 typedef short int flex_int16_t;
69 typedef int flex_int32_t;
70 typedef unsigned char flex_uint8_t; 
71 typedef unsigned short int flex_uint16_t;
72 typedef unsigned int flex_uint32_t;
73
74 /* Limits of integral types. */
75 #ifndef INT8_MIN
76 #define INT8_MIN               (-128)
77 #endif
78 #ifndef INT16_MIN
79 #define INT16_MIN              (-32767-1)
80 #endif
81 #ifndef INT32_MIN
82 #define INT32_MIN              (-2147483647-1)
83 #endif
84 #ifndef INT8_MAX
85 #define INT8_MAX               (127)
86 #endif
87 #ifndef INT16_MAX
88 #define INT16_MAX              (32767)
89 #endif
90 #ifndef INT32_MAX
91 #define INT32_MAX              (2147483647)
92 #endif
93 #ifndef UINT8_MAX
94 #define UINT8_MAX              (255U)
95 #endif
96 #ifndef UINT16_MAX
97 #define UINT16_MAX             (65535U)
98 #endif
99 #ifndef UINT32_MAX
100 #define UINT32_MAX             (4294967295U)
101 #endif
102
103 #endif /* ! C99 */
104
105 #endif /* ! FLEXINT_H */
106
107 #ifdef __cplusplus
108
109 /* The "const" storage-class-modifier is valid. */
110 #define YY_USE_CONST
111
112 #else   /* ! __cplusplus */
113
114 /* C99 requires __STDC__ to be defined as 1. */
115 #if defined (__STDC__)
116
117 #define YY_USE_CONST
118
119 #endif  /* defined (__STDC__) */
120 #endif  /* ! __cplusplus */
121
122 #ifdef YY_USE_CONST
123 #define yyconst const
124 #else
125 #define yyconst
126 #endif
127
128 /* Returned upon end-of-file. */
129 #define YY_NULL 0
130
131 /* Promotes a possibly negative, possibly signed char to an unsigned
132  * integer for use as an array index.  If the signed char is negative,
133  * we want to instead treat it as an 8-bit unsigned char, hence the
134  * double cast.
135  */
136 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
137
138 /* Enter a start condition.  This macro really ought to take a parameter,
139  * but we do it the disgusting crufty way forced on us by the ()-less
140  * definition of BEGIN.
141  */
142 #define BEGIN (yy_start) = 1 + 2 *
143
144 /* Translate the current start state into a value that can be later handed
145  * to BEGIN to return to the state.  The YYSTATE alias is for lex
146  * compatibility.
147  */
148 #define YY_START (((yy_start) - 1) / 2)
149 #define YYSTATE YY_START
150
151 /* Action number for EOF rule of a given start state. */
152 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
153
154 /* Special action meaning "start processing a new file". */
155 #define YY_NEW_FILE dax_restart(dax_in  )
156
157 #define YY_END_OF_BUFFER_CHAR 0
158
159 /* Size of default input buffer. */
160 #ifndef YY_BUF_SIZE
161 #ifdef __ia64__
162 /* On IA-64, the buffer size is 16k, not 8k.
163  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
164  * Ditto for the __ia64__ case accordingly.
165  */
166 #define YY_BUF_SIZE 32768
167 #else
168 #define YY_BUF_SIZE 16384
169 #endif /* __ia64__ */
170 #endif
171
172 /* The state buf must be large enough to hold one state per character in the main buffer.
173  */
174 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
175
176 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
177 #define YY_TYPEDEF_YY_BUFFER_STATE
178 typedef struct yy_buffer_state *YY_BUFFER_STATE;
179 #endif
180
181 #ifndef YY_TYPEDEF_YY_SIZE_T
182 #define YY_TYPEDEF_YY_SIZE_T
183 typedef size_t yy_size_t;
184 #endif
185
186 extern yy_size_t dax_leng;
187
188 extern FILE *dax_in, *dax_out;
189
190 #define EOB_ACT_CONTINUE_SCAN 0
191 #define EOB_ACT_END_OF_FILE 1
192 #define EOB_ACT_LAST_MATCH 2
193
194     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
195      *       access to the local variable yy_act. Since yyless() is a macro, it would break
196      *       existing scanners that call yyless() from OUTSIDE dax_lex. 
197      *       One obvious solution it to make yy_act a global. I tried that, and saw
198      *       a 5% performance hit in a non-dax_lineno scanner, because yy_act is
199      *       normally declared as a register variable-- so it is not worth it.
200      */
201     #define  YY_LESS_LINENO(n) \
202             do { \
203                 unsigned int yyl;\
204                 for ( yyl = n; yyl < dax_leng; ++yyl )\
205                     if ( dax_text[yyl] == '\n' )\
206                         --dax_lineno;\
207             }while(0)
208     #define YY_LINENO_REWIND_TO(dst) \
209             do {\
210                 const char *p;\
211                 for ( p = yy_cp-1; p >= (dst); --p)\
212                     if ( *p == '\n' )\
213                         --dax_lineno;\
214             }while(0)
215     
216 /* Return all but the first "n" matched characters back to the input stream. */
217 #define yyless(n) \
218         do \
219                 { \
220                 /* Undo effects of setting up dax_text. */ \
221         int yyless_macro_arg = (n); \
222         YY_LESS_LINENO(yyless_macro_arg);\
223                 *yy_cp = (yy_hold_char); \
224                 YY_RESTORE_YY_MORE_OFFSET \
225                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
226                 YY_DO_BEFORE_ACTION; /* set up dax_text again */ \
227                 } \
228         while ( 0 )
229
230 #define unput(c) yyunput( c, (yytext_ptr)  )
231
232 #ifndef YY_STRUCT_YY_BUFFER_STATE
233 #define YY_STRUCT_YY_BUFFER_STATE
234 struct yy_buffer_state
235         {
236         FILE *yy_input_file;
237
238         char *yy_ch_buf;                /* input buffer */
239         char *yy_buf_pos;               /* current position in input buffer */
240
241         /* Size of input buffer in bytes, not including room for EOB
242          * characters.
243          */
244         yy_size_t yy_buf_size;
245
246         /* Number of characters read into yy_ch_buf, not including EOB
247          * characters.
248          */
249         int yy_n_chars;
250
251         /* Whether we "own" the buffer - i.e., we know we created it,
252          * and can realloc() it to grow it, and should free() it to
253          * delete it.
254          */
255         int yy_is_our_buffer;
256
257         /* Whether this is an "interactive" input source; if so, and
258          * if we're using stdio for input, then we want to use getc()
259          * instead of fread(), to make sure we stop fetching input after
260          * each newline.
261          */
262         int yy_is_interactive;
263
264         /* Whether we're considered to be at the beginning of a line.
265          * If so, '^' rules will be active on the next match, otherwise
266          * not.
267          */
268         int yy_at_bol;
269
270     int yy_bs_lineno; /**< The line count. */
271     int yy_bs_column; /**< The column count. */
272     
273         /* Whether to try to fill the input buffer when we reach the
274          * end of it.
275          */
276         int yy_fill_buffer;
277
278         int yy_buffer_status;
279
280 #define YY_BUFFER_NEW 0
281 #define YY_BUFFER_NORMAL 1
282         /* When an EOF's been seen but there's still some text to process
283          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
284          * shouldn't try reading from the input source any more.  We might
285          * still have a bunch of tokens to match, though, because of
286          * possible backing-up.
287          *
288          * When we actually see the EOF, we change the status to "new"
289          * (via dax_restart()), so that the user can continue scanning by
290          * just pointing dax_in at a new input file.
291          */
292 #define YY_BUFFER_EOF_PENDING 2
293
294         };
295 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
296
297 /* Stack of input buffers. */
298 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
299 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
300 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
301
302 /* We provide macros for accessing buffer states in case in the
303  * future we want to put the buffer states in a more general
304  * "scanner state".
305  *
306  * Returns the top of the stack, or NULL.
307  */
308 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
309                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
310                           : NULL)
311
312 /* Same as previous macro, but useful when we know that the buffer stack is not
313  * NULL or when we need an lvalue. For internal use only.
314  */
315 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
316
317 /* yy_hold_char holds the character lost when dax_text is formed. */
318 static char yy_hold_char;
319 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
320 yy_size_t dax_leng;
321
322 /* Points to current character in buffer. */
323 static char *yy_c_buf_p = (char *) 0;
324 static int yy_init = 0;         /* whether we need to initialize */
325 static int yy_start = 0;        /* start state number */
326
327 /* Flag which is used to allow dax_wrap()'s to do buffer switches
328  * instead of setting up a fresh dax_in.  A bit of a hack ...
329  */
330 static int yy_did_buffer_switch_on_eof;
331
332 void dax_restart (FILE *input_file  );
333 void dax__switch_to_buffer (YY_BUFFER_STATE new_buffer  );
334 YY_BUFFER_STATE dax__create_buffer (FILE *file,int size  );
335 void dax__delete_buffer (YY_BUFFER_STATE b  );
336 void dax__flush_buffer (YY_BUFFER_STATE b  );
337 void dax_push_buffer_state (YY_BUFFER_STATE new_buffer  );
338 void dax_pop_buffer_state (void );
339
340 static void dax_ensure_buffer_stack (void );
341 static void dax__load_buffer_state (void );
342 static void dax__init_buffer (YY_BUFFER_STATE b,FILE *file  );
343
344 #define YY_FLUSH_BUFFER dax__flush_buffer(YY_CURRENT_BUFFER )
345
346 YY_BUFFER_STATE dax__scan_buffer (char *base,yy_size_t size  );
347 YY_BUFFER_STATE dax__scan_string (yyconst char *yy_str  );
348 YY_BUFFER_STATE dax__scan_bytes (yyconst char *bytes,yy_size_t len  );
349
350 void *dax_alloc (yy_size_t  );
351 void *dax_realloc (void *,yy_size_t  );
352 void dax_free (void *  );
353
354 #define yy_new_buffer dax__create_buffer
355
356 #define yy_set_interactive(is_interactive) \
357         { \
358         if ( ! YY_CURRENT_BUFFER ){ \
359         dax_ensure_buffer_stack (); \
360                 YY_CURRENT_BUFFER_LVALUE =    \
361             dax__create_buffer(dax_in,YY_BUF_SIZE ); \
362         } \
363         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
364         }
365
366 #define yy_set_bol(at_bol) \
367         { \
368         if ( ! YY_CURRENT_BUFFER ){\
369         dax_ensure_buffer_stack (); \
370                 YY_CURRENT_BUFFER_LVALUE =    \
371             dax__create_buffer(dax_in,YY_BUF_SIZE ); \
372         } \
373         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
374         }
375
376 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
377
378 /* Begin user sect3 */
379
380 #define dax_wrap() (/*CONSTCOND*/1)
381 #define YY_SKIP_YYWRAP
382
383 typedef unsigned char YY_CHAR;
384
385 FILE *dax_in = (FILE *) 0, *dax_out = (FILE *) 0;
386
387 typedef int yy_state_type;
388
389 extern int dax_lineno;
390
391 int dax_lineno = 1;
392
393 extern char *dax_text;
394 #ifdef yytext_ptr
395 #undef yytext_ptr
396 #endif
397 #define yytext_ptr dax_text
398
399 static yy_state_type yy_get_previous_state (void );
400 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
401 static int yy_get_next_buffer (void );
402 #if defined(__GNUC__) && __GNUC__ >= 3
403 __attribute__((__noreturn__))
404 #endif
405 static void yy_fatal_error (yyconst char msg[]  );
406
407 /* Done after the current pattern has been matched and before the
408  * corresponding action - sets up dax_text.
409  */
410 #define YY_DO_BEFORE_ACTION \
411         (yytext_ptr) = yy_bp; \
412         dax_leng = (size_t) (yy_cp - yy_bp); \
413         (yy_hold_char) = *yy_cp; \
414         *yy_cp = '\0'; \
415         (yy_c_buf_p) = yy_cp;
416
417 #define YY_NUM_RULES 140
418 #define YY_END_OF_BUFFER 141
419 /* This struct is not used in this scanner,
420    but its presence is necessary. */
421 struct yy_trans_info
422         {
423         flex_int32_t yy_verify;
424         flex_int32_t yy_nxt;
425         };
426 static yyconst flex_int16_t yy_accept[775] =
427     {   0,
428         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
429         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
430         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
431         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
432         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
433         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
434         0,    0,    0,    0,    0,    0,  141,  139,   15,   10,
435        10,   15,   15,  119,   10,  119,    5,    6,    5,    8,
436         9,    8,  135,  127,  128,  136,  133,  136,  134,  138,
437       127,  128,  138,  139,   40,   10,   40,   40,   40,   38,
438
439        40,   40,   40,   40,   40,   40,   40,   44,   10,   44,
440        44,  139,  139,   44,   51,   10,   51,   51,   51,   49,
441        51,   55,   10,   55,  139,   55,   72,   10,   72,   72,
442        72,   70,   72,   72,   72,   72,   72,   76,   10,   76,
443       139,   76,   83,   10,   83,   83,   83,   81,   83,   87,
444        10,   87,  114,   10,  114,  114,  114,  112,  114,  114,
445       114,  114,  114,  114,  118,   10,  118,  136,  135,   10,
446         0,    2,    2,    0,    4,    7,  130,  129,    0,    0,
447         0,    0,    0,    0,    0,   39,   41,   41,   41,   41,
448        41,   41,   41,   41,   41,   41,    0,    0,    0,    0,
449
450         0,    0,    0,    0,   50,   52,   52,    0,    0,   71,
451        73,   73,   73,   73,   73,   73,    0,    0,   82,   84,
452        84,    0,  113,  115,  115,  115,  115,  115,  115,  115,
453       115,    0,    0,    0,    0,    0,    0,    0,    3,    0,
454         0,    0,    0,    0,    0,    0,  137,    0,   41,   41,
455        41,   41,   41,   41,   41,   41,   41,    0,    0,    0,
456         0,    0,    0,    0,    0,    0,   52,    0,    0,    0,
457         0,    0,   73,   73,   73,   73,    0,    0,    0,   84,
458         0,    0,  115,  115,  115,  115,  115,  115,  115,    0,
459         0,    0,  132,    0,   14,    1,    0,    0,  125,    0,
460
461         0,    0,  122,  121,    0,    0,   41,   41,   41,   41,
462        41,   41,   41,   41,   41,    0,    0,   43,    0,    0,
463         0,   57,    0,    0,   56,    0,    0,    0,    0,    0,
464        54,    0,    0,    0,   59,   58,   73,   73,   73,   73,
465         0,    0,   75,    0,    0,    0,    0,    0,    0,   86,
466         0,  115,  115,  115,  115,  115,  115,  115,    0,    0,
467       117,    0,    0,    0,    0,  126,  120,    0,    0,   17,
468        41,   41,   41,   41,   41,    0,    0,   41,   41,   41,
469         0,   16,    0,   57,    0,   88,   56,    0,    0,   48,
470        47,    0,    0,   73,    0,    0,   73,   73,   73,    0,
471
472        89,    0,   80,   79,    0,    0,    0,    0,    0,  115,
473       115,    0,    0,  115,    0,    0,    0,    0,    0,    0,
474         0,   12,    0,  123,  124,   17,   41,    0,    0,   41,
475         0,    0,   41,    0,   29,   28,   41,    0,   41,    0,
476        41,    0,   16,   46,    0,   88,   45,    0,    0,    0,
477         0,    0,   63,   62,   73,   73,   73,    0,   74,   89,
478         0,    0,   91,   90,    0,    0,    0,  115,  115,    0,
479       105,  104,  115,    0,  111,  110,    0,    0,    0,    0,
480         0,   11,   41,    0,   21,   20,   41,    0,   25,   24,
481        41,   41,   41,    0,   33,   32,   41,    0,   42,   46,
482
483        77,   45,    0,   78,    0,   61,   60,   73,   73,   73,
484         0,    0,    0,    0,    0,  115,  115,  115,    0,  116,
485         0,    0,    0,    0,   41,   41,   41,    0,    0,   41,
486        41,   77,    0,   53,   78,   73,    0,    0,    0,    0,
487         0,    0,    0,    0,    0,  115,  115,  115,    0,    0,
488         0,    0,   41,   41,    0,    0,    0,   31,   30,   41,
489        41,   73,    0,   67,   66,    0,   69,   68,    0,   85,
490         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
491       131,    0,    0,    0,   41,    0,    0,    0,   27,   26,
492         0,    0,   41,    0,    0,    0,    0,    0,    0,    0,
493
494         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
495         0,    0,    0,    0,   23,   22,    0,   35,   34,   41,
496         0,   65,   64,    0,    0,    0,    0,    0,    0,    0,
497         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
498         0,    0,    0,   19,   18,   41,   93,    0,   92,    0,
499         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
500         0,    0,    0,    0,    0,   41,   95,   94,    0,    0,
501         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
502         0,    0,    0,    0,   41,    0,    0,    0,    0,    0,
503         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
504
505         0,    0,    0,   41,    0,   99,    0,   98,    0,  103,
506         0,  102,    0,  109,    0,  108,    0,    0,    0,    0,
507         0,    0,   41,   97,   96,  101,  100,  107,  106,    0,
508         0,    0,   12,    0,   12,    0,   41,    0,    0,    0,
509         0,    0,   41,    0,    0,    0,    0,    0,   11,    0,
510        37,   36,    0,    0,    0,    0,    0,    0,    0,    0,
511         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
512         0,    0,   13,    0
513     } ;
514
515 static yyconst YY_CHAR yy_ec[256] =
516     {   0,
517         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
518         1,    2,    4,    1,    1,    1,    1,    1,    1,    1,
519         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
520         1,    2,    5,    6,    7,    1,    1,    8,    9,    1,
521         1,    1,    1,    1,   10,   11,   12,   13,   13,   13,
522        13,   13,   13,   13,   13,   13,   13,   14,   15,   16,
523        17,   18,   19,    1,   20,   21,   22,   23,   24,   21,
524        25,   25,   25,   25,   25,   26,   27,   25,   28,   29,
525        25,   25,   30,   31,   25,   25,   25,   25,   32,   25,
526        33,    1,   34,    1,   25,    1,   35,   36,   37,   38,
527
528        39,   40,   41,   42,   43,   44,   45,   46,   47,   48,
529        49,   50,   51,   52,   53,   54,   55,   56,   25,   57,
530        58,   59,    1,    1,    1,    1,    1,    1,    1,    1,
531         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
532         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
533         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
534         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
535         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
536         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
537         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
538
539         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
540         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
541         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
542         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
543         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
544         1,    1,    1,    1,    1
545     } ;
546
547 static yyconst YY_CHAR yy_meta[60] =
548     {   0,
549         1,    2,    2,    2,    1,    1,    1,    1,    1,    3,
550         3,    1,    4,    5,    1,    1,    1,    6,    1,    7,
551         7,    7,    7,    7,    5,    5,    5,    5,    5,    5,
552         5,    5,    1,    1,    7,    7,    7,    7,    7,    7,
553         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
554         5,    5,    5,    5,    5,    5,    5,    5,    5
555     } ;
556
557 static yyconst flex_uint16_t yy_base[814] =
558     {   0,
559         0,    0,    0,    3,    6,    9,   24,   27,   11,   14,
560        15,   17,   29,   38,   45,   52,   59,   61,   67,   70,
561        95,    0,   73,   76,  153,  156,  159,  162,  177,  180,
562       183,  186,  201,  204,  207,  210,  226,  278,  245,  248,
563       251,  254,  297,  300,  303,  306,  330,    0,  388,  391,
564       394,  397,  412,  415,  418,  421,  437,  489,  456,  459,
565       541,    0,  462,  465,  598,  600, 2053, 2135, 2135,  269,
566       272,   47,   62, 2135,  321,  172, 2135, 2135, 2033, 2135,
567      2135, 2022, 2135, 2033, 2031,  475, 2135, 2135, 2135, 2135,
568      2027, 2025, 1987,  468, 2135,  324, 1998,    0,  196, 2135,
569
570         8, 1968, 1958, 1952, 1863, 1858,   35, 2135,  481,  600,
571       608,  604,  612,  641, 2135,  509, 1878,    0,  258, 2135,
572      1855, 2135,  515,  660,  663,  682, 2135,  525, 1875,    0,
573       310, 2135, 1854, 1852, 1855, 1834, 1849, 2135,  528,  704,
574       701,  723, 2135,  531, 1869,    0,  407, 2135, 1847, 2135,
575       534,  606, 2135,  626, 1857,    0,  469, 2135, 1831, 1829,
576      1821, 1830, 1814,   32, 2135,  667,  621, 1851, 1820,  671,
577       628, 1784, 2135, 1827, 1818, 2135, 2135, 2135,    2,   44,
578      1781, 1780, 1778, 1814, 1793, 2135,    0, 1787, 1774, 1777,
579      1784, 1784, 1772, 1747, 1752, 1753, 1752, 1748, 1742, 1722,
580
581      1735, 1712, 1715, 1720, 2135,    0, 1713, 1695, 1693, 2135,
582         0,  686, 1670, 1671, 1668, 1660, 1666, 1656, 2135,    0,
583      1661, 1650, 2135,    0, 1652, 1644, 1635, 1646, 1627, 1648,
584      1632, 1626, 1634, 1648, 1646, 1649,  458, 1611, 2135,   72,
585         0, 1606, 1602, 1635, 1633, 1594, 2135, 1607, 1590, 1586,
586      1594, 1592, 1601, 1583, 1567, 1567, 1600,  759,  762, 1577,
587      1564, 1570, 1547, 1559, 1560, 1544,  727,  766,  772, 1534,
588       779,  783, 1545, 1536, 1520, 1519,  791,  795, 1528,  799,
589       802,  808, 1527, 1517, 1517, 1513, 1506, 1496, 1503,  815,
590       819, 1519, 2135, 1521, 2135, 2135,   17, 1488, 2135, 1514,
591
592      1513, 1473, 2135, 2135, 1464, 1475, 1477, 1459, 1490, 1453,
593      1450,  825, 1455, 1443, 1438,  828,  832, 2135,  836, 1449,
594      1442,  845, 1447, 1432,  849, 1437,  853,  856,  864,  871,
595      2135,  874, 1433,  877, 2135, 2135, 1425,  891, 1426, 1421,
596       894,  897, 2135,  900, 1410,  903,  907,  919,  922, 2135,
597       925,  928,  931, 1411, 1406,  947, 1404,  950,  953,  956,
598      2135,  966, 1422,  646,  976, 2135, 2135, 1429, 1427,  959,
599      1419,  979, 1386,  983, 1379,  986,  995, 1374, 1004, 1381,
600      1007,  989, 1379, 1010, 1367, 1013, 1020, 1369, 1024, 2135,
601      2135, 1032, 1357, 1035, 1038, 1054, 1352, 1353, 1347, 1041,
602
603      1062, 1065, 2135, 2135, 1073, 1077, 1080, 1093, 1096, 1333,
604      1325, 1104, 1111, 1334, 1120, 1123, 1131, 1352,  507, 1353,
605      1136, 2135, 1347, 2135, 2135, 1139, 1315, 1142, 1149, 1291,
606      1159, 1162, 1297, 1176, 2135, 2135, 1295, 1170, 1285, 1187,
607      1298, 1195, 1198, 1201, 1275, 1204, 1207, 1212, 1274, 1215,
608      1218, 1231, 2135, 2135, 1282, 1273, 1263, 1239, 2135, 1242,
609      1245, 1249, 2135, 2135, 1258,  124,  125, 1274, 1262, 1266,
610      2135, 2135, 1259, 1274, 2135, 2135, 1282, 1261,  491,  152,
611         5, 2135, 1235, 1285, 2135, 2135, 1234, 1293, 2135, 2135,
612      1227, 1301, 1226, 1304, 2135, 2135, 1235, 1312, 2135, 1317,
613
614      1320, 1323, 1329, 1332, 1335, 2135, 2135, 1236, 1346, 1349,
615      1352, 1223, 1211, 1217, 1204, 1210, 1202, 1187, 1355, 2135,
616      1218,  174,  158,  384, 1188, 1177, 1358, 1365, 1374, 1186,
617      1181, 1382, 1385, 2135, 1388, 1187, 1391, 1395, 1407, 1410,
618      1418, 1175, 1169, 1162, 1141, 1423, 1426, 1429, 1161, 1435,
619       176,  461, 1134, 1445, 1448, 1452, 1464, 2135, 2135, 1472,
620      1151, 1475, 1478, 2135, 2135, 1491, 2135, 2135, 1499, 2135,
621      1128, 1131, 1122, 1120, 1502, 1505, 1518, 1521, 1529, 1534,
622      2135, 1545,  228,  179, 1548, 1551, 1555, 1567, 2135, 2135,
623      1575, 1579, 1143, 1587, 1591, 1113, 1105, 1103, 1101, 1599,
624
625       567,  570, 1607,  582,  626, 1615,  668,  671,  280,  222,
626       643, 1623, 1626, 1635, 2135, 2135, 1643, 2135, 2135, 1101,
627      1651, 2135, 2135, 1142, 1093, 1127, 1077, 1095, 1076, 1084,
628      1066, 1081, 1059, 1074, 1052, 1068, 1049, 1058, 1040,  715,
629       244,  385, 1659, 2135, 2135, 1053, 2135, 1082, 2135, 1078,
630      1026, 1015, 1016, 1006, 1008,  992, 1000,  974,  973,  921,
631       929,  918,  388,  391, 1667,  937, 2135, 2135,  912,  907,
632       889,  902,  861,  851,  835,  848,  832,  830,  792,  776,
633      1670, 1673, 1676, 1693,  753,  714,  746,  695,  712,  666,
634       678,  644,  648,  603,  609,  501,  471, 1701, 1704, 1711,
635
636      1721, 1739, 1773,  408,  429, 2135,  421, 2135,  421, 2135,
637       402, 2135,  402, 2135,  396, 2135,  725, 1791,  675,  506,
638      1809, 1843,  272, 2135, 2135, 2135, 2135, 2135, 2135,  684,
639       706,  200,  311,  731,  260, 1731,  220,  668,  218,  202,
640       207, 1765, 1836,  296,  153, 1861, 1757,  728, 2135, 1799,
641      2135, 2135, 1734, 1864,  439,  709,  753,  773,  806,  807,
642       761,  873,  823,  901,  948, 1031, 1013, 1035, 1014,  929,
643      1877, 1881, 2135, 2135, 1899, 1906, 1913, 1920, 1927, 1934,
644      1941, 1948, 1955, 1962, 1969, 1976, 1983, 1990, 1995, 2000,
645      2005, 2010, 2015, 2022, 2025, 2028, 2031, 2034, 2037, 2044,
646
647      2048, 2054, 2060, 2066, 2072, 2078, 2085, 2092, 2099, 2106,
648      2113, 2120, 2127
649     } ;
650
651 static yyconst flex_int16_t yy_def[814] =
652     {   0,
653       775,  775,  776,  776,  776,  776,  777,  777,  778,  778,
654       779,  779,  780,  780,  780,  780,  781,  781,  775,  775,
655       774,   21,  782,  782,  782,  782,  775,  775,  782,  782,
656       775,  775,  782,  782,  782,  782,  783,  783,  784,  784,
657       775,  775,  784,  784,  784,  784,  774,   47,  785,  785,
658       775,  775,  785,  785,  785,  785,  786,  786,  787,  787,
659       774,   61,  788,  788,  780,  780,  774,  774,  774,  774,
660       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
661       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
662       774,  774,  774,  774,  774,  774,  774,  789,  774,  774,
663
664       789,  789,  789,  789,  789,  789,  789,  774,  774,  774,
665       774,  774,  774,  774,  774,  774,  774,  790,  774,  774,
666       790,  774,  774,  774,  774,  774,  774,  774,  774,  791,
667       774,  774,  791,  791,  791,  791,  791,  774,  774,  774,
668       774,  774,  774,  774,  774,  792,  774,  774,  792,  774,
669       774,  774,  774,  774,  774,  793,  774,  774,  793,  793,
670       793,  793,  793,  793,  774,  774,  774,  774,  774,  774,
671       794,  774,  774,  774,  774,  774,  774,  774,  774,  774,
672       774,  774,  774,  774,  774,  774,  789,  789,  789,  789,
673       789,  789,  789,  789,  789,  789,  795,  774,  774,  774,
674
675       774,  774,  774,  774,  774,  790,  790,  796,  774,  774,
676       791,  791,  791,  791,  791,  791,  797,  774,  774,  792,
677       792,  798,  774,  793,  793,  793,  793,  793,  793,  793,
678       793,  799,  774,  774,  800,  774,  800,  774,  774,  774,
679       801,  774,  774,  774,  774,  774,  774,  774,  789,  789,
680       789,  789,  789,  789,  789,  789,  789,  802,  802,  774,
681       774,  774,  774,  774,  774,  774,  790,  803,  803,  774,
682       774,  774,  791,  791,  791,  791,  804,  804,  774,  792,
683       805,  805,  793,  793,  793,  793,  793,  793,  793,  806,
684       806,  774,  774,  800,  774,  774,  800,  774,  774,  801,
685
686       774,  774,  774,  774,  774,  774,  789,  789,  789,  789,
687       789,  789,  789,  789,  789,  774,  802,  774,  802,  774,
688       774,  774,  774,  774,  774,  774,  774,  774,  774,  803,
689       774,  803,  774,  774,  774,  774,  791,  791,  791,  791,
690       774,  804,  774,  804,  774,  774,  774,  774,  805,  774,
691       805,  793,  793,  793,  793,  793,  793,  793,  774,  806,
692       774,  806,  774,  800,  807,  774,  774,  774,  774,  774,
693       789,  789,  789,  789,  789,  774,  774,  789,  789,  789,
694       802,  774,  774,  774,  774,  774,  774,  774,  774,  774,
695       774,  803,  774,  791,  774,  774,  791,  791,  791,  804,
696
697       774,  774,  774,  774,  805,  774,  774,  774,  774,  793,
698       793,  774,  774,  793,  774,  774,  806,  774,  800,  807,
699       807,  774,  807,  774,  774,  774,  789,  774,  774,  789,
700       774,  774,  789,  774,  774,  774,  789,  774,  789,  774,
701       789,  802,  774,  774,  774,  774,  774,  803,  774,  774,
702       774,  774,  774,  774,  791,  791,  791,  774,  774,  774,
703       805,  774,  774,  774,  774,  774,  774,  793,  793,  774,
704       774,  774,  793,  774,  774,  774,  806,  774,  800,  807,
705       807,  774,  789,  774,  774,  774,  789,  774,  774,  774,
706       789,  789,  789,  774,  774,  774,  789,  774,  774,  774,
707
708       774,  774,  803,  774,  774,  774,  774,  791,  791,  791,
709       805,  774,  774,  774,  774,  793,  793,  793,  774,  774,
710       774,  800,  807,  807,  789,  789,  789,  774,  774,  789,
711       789,  774,  774,  774,  774,  791,  774,  774,  774,  774,
712       805,  774,  774,  774,  774,  793,  793,  793,  774,  800,
713       807,  807,  789,  789,  774,  774,  774,  774,  774,  789,
714       789,  791,  774,  774,  774,  774,  774,  774,  774,  774,
715       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
716       774,  800,  807,  807,  789,  774,  774,  774,  774,  774,
717       774,  774,  789,  774,  774,  774,  774,  774,  774,  774,
718
719       774,  774,  774,  774,  774,  774,  774,  774,  800,  807,
720       807,  774,  774,  774,  774,  774,  774,  774,  774,  789,
721       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
722       774,  774,  774,  774,  774,  774,  774,  774,  774,  800,
723       807,  807,  774,  774,  774,  789,  774,  774,  774,  774,
724       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
725       774,  774,  800,  807,  807,  789,  774,  774,  774,  774,
726       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
727       800,  807,  807,  807,  789,  774,  774,  774,  774,  774,
728       774,  774,  774,  774,  774,  774,  774,  800,  807,  807,
729
730       807,  808,  809,  789,  774,  774,  774,  774,  774,  774,
731       774,  774,  774,  774,  774,  774,  800,  807,  810,  811,
732       808,  809,  789,  774,  774,  774,  774,  774,  774,  800,
733       810,  807,  812,  811,  813,  807,  789,  800,  812,  774,
734       813,  807,  789,  800,  774,  774,  774,  800,  774,  774,
735       774,  774,  800,  800,  800,  800,  800,  800,  800,  800,
736       800,  800,  800,  800,  800,  800,  800,  800,  800,  800,
737       800,  800,  774,    0,  774,  774,  774,  774,  774,  774,
738       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
739       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
740
741       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
742       774,  774,  774
743     } ;
744
745 static yyconst flex_uint16_t yy_nxt[2195] =
746     {   0,
747       774,   70,   71,   70,   70,   71,   70,   70,   71,   70,
748        70,   71,   70,   78,  240,   72,   78,   81,   72,   81,
749        79,   73,  422,   79,   73,   75,   71,   75,   75,   71,
750        75,   84,   85,   82,  295,   82,   86,   87,  364,   76,
751        84,   85,   76,  524,   88,   86,   87,   84,   85,  188,
752        89,  171,   86,   88,   84,   85,  189,   89,  241,   86,
753        88,   91,   92,   91,   92,  172,  171,   88,   71,   71,
754        71,   71,   71,   71,  109,   71,  109,  109,   71,  109,
755       173,  195,   94,  230,  240,   94,  299,  196,  110,  231,
756       242,  110,   93,  243,   93,   95,   96,   71,   96,   95,
757
758        95,   95,   95,   95,   95,   95,   97,   95,   98,   95,
759        99,   95,  100,   95,   98,   98,   98,   98,   98,   98,
760        98,   98,   98,   98,   98,   98,   98,   95,   95,   98,
761        98,  101,   98,   98,  102,   98,   98,  103,  104,   98,
762        98,   98,  105,   98,   98,   98,   98,   98,   98,   98,
763       106,  107,   98,   98,  109,   71,  109,  109,   71,  109,
764        71,   71,   71,   71,   71,   71,  512,  514,  111,  422,
765       749,  111,  513,  515,  112,  422,  174,  112,  109,   71,
766       109,  109,   71,  109,   71,   71,   71,   71,   71,   71,
767       173,  295,  110,  422,  551,  110,  422,  550,  113,  523,
768
769       174,  113,  109,   71,  109,  109,   71,  109,  109,   71,
770       109,  109,   71,  109,  173,  740,  111,  422,  423,  111,
771       745,  611,  114,  740,  583,  114,  115,  116,   71,  116,
772       115,  115,  115,  115,  115,  115,  115,  117,  115,  422,
773       115,  119,  115,  120,  115,  422,  123,   71,  123,  123,
774        71,  123,   71,   71,   71,   71,   71,   71,  115,  115,
775       124,  422,  174,  124,  641,  610,  125,  743,  740,  125,
776       170,  170,  170,  170,  170,  170,  173,  121,  115,  116,
777        71,  116,  115,  115,  115,  115,  115,  115,  115,  117,
778       115,  664,  115,  119,  115,  120,  115,  295,  123,   71,
779
780       123,  123,   71,  123,  123,   71,  123,  123,   71,  123,
781       115,  115,  124,  295,  174,  124,  740,  640,  126,  748,
782       737,  126,  170,  170,  170,  170,  170,  170,  173,  121,
783       127,  128,   71,  128,  127,  127,  127,  127,  127,  127,
784       127,  129,  127,  130,  127,  131,  127,  132,  127,  130,
785       130,  130,  130,  130,  130,  130,  130,  130,  130,  130,
786       130,  130,  127,  127,  130,  130,  130,  130,  130,  130,
787       130,  130,  133,  130,  130,  134,  130,  135,  130,  130,
788       130,  136,  130,  130,  130,  137,  130,  130,  130,  139,
789        71,  139,  139,   71,  139,   71,   71,   71,   71,   71,
790
791        71,  422,  422,  140,  729,  295,  140,  728,  422,  141,
792       727,  174,  141,  139,   71,  139,  139,   71,  139,  139,
793        71,  139,  139,   71,  139,  173,  726,  140,  681,  725,
794       140,  682,  665,  142,  724,  552,  142,  143,  144,   71,
795       144,  143,  143,  143,  143,  143,  143,  143,  145,  143,
796       723,  143,  147,  143,  148,  143,  295,  151,   71,  151,
797       151,   71,  151,  166,   71,  166,  166,   71,  166,  143,
798       143,  152,  174,  174,  152,  295,  757,  167,  422,  716,
799       167,  179,  170,  170,  170,  297,  173,  173,  149,  143,
800       144,   71,  144,  143,  143,  143,  143,  143,  143,  143,
801
802       145,  143,  185,  143,  147,  143,  148,  143,  295,  180,
803       170,  170,  170,  584,  732,  181,  170,  170,  170,  522,
804       182,  143,  143,  735,  295,  183,  170,  170,  170,  170,
805       170,  170,  170,  170,  170,  170,  170,  170,  479,  715,
806       149,  153,  154,   71,  154,  153,  153,  153,  153,  153,
807       153,  153,  155,  153,  156,  153,  157,  153,  158,  153,
808       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
809       156,  156,  156,  153,  153,  156,  156,  156,  156,  156,
810       159,  156,  156,  156,  156,  156,  160,  156,  156,  161,
811       156,  156,  162,  163,  164,  156,  156,  156,  156,  156,
812
813        84,   85,   84,   85,  174,   86,  628,   86,  174,  630,
814       174,  197,  174,  168,  714,  168,  174,  222,  173,  197,
815       629,  632,  173,  631,  173,  174,  173,  170,  170,  170,
816       173,  169,  232,  169,  198,  633,  199,  236,  198,  173,
817       204,  713,  198,  200,  199,  174,  198,  200,  199,  201,
818       237,  203,  197,  201,  202,  203,  712,  201,  202,  173,
819       422,  201,  202,  295,  174,  634,  202,  174,  170,  170,
820       170,  208,  170,  170,  170,  198,  419,  204,  173,  635,
821       732,  173,  711,  710,  203,  295,  174,  271,  271,  271,
822       201,  642,  733,  208,  198,  202,  204,  198,  744,  204,
823
824       173,  295,  272,  203,  709,  174,  203,  636,  174,  209,
825       638,  732,  209,  738,  202,  217,  198,  202,  204,  173,
826       708,  637,  173,  733,  639,  203,  295,  174,  327,  327,
827       327,  201,  295,  707,  217,  198,  202,  204,  198,  732,
828       204,  173,  295,  328,  203,  295,  758,  203,  735,  663,
829       201,  706,  705,  201,  753,  218,  730,  198,  218,  204,
830       316,  316,  316,  316,  316,  316,  203,  329,  329,  329,
831       295,  763,  201,  329,  329,  329,  318,  202,  295,  318,
832       271,  271,  271,  331,  334,  334,  334,  759,  335,  331,
833       295,  336,  341,  341,  341,  272,  341,  341,  341,  319,
834
835       346,  346,  346,  348,  348,  348,  704,  760,  343,  348,
836       348,  348,  343,  332,  697,  347,  359,  359,  359,  350,
837       359,  359,  359,  295,  295,  350,  376,  376,  376,  316,
838       316,  316,  361,  316,  316,  316,  361,  316,  316,  316,
839       295,  377,  351,  344,  696,  318,  384,  384,  384,  318,
840       387,  387,  387,  318,  327,  327,  327,  389,  389,  389,
841       765,  390,  761,  762,  391,  329,  329,  329,  695,  328,
842       381,  362,  329,  329,  329,  329,  329,  329,  334,  334,
843       334,  331,  335,  764,  694,  336,  693,  692,  331,  691,
844       295,  331,  395,  395,  395,  341,  341,  341,  341,  341,
845
846       341,  341,  341,  341,  346,  346,  346,  396,  402,  402,
847       402,  343,  403,  690,  343,  404,  392,  343,  295,  347,
848       348,  348,  348,  348,  348,  348,  348,  348,  348,  406,
849       406,  406,  408,  408,  408,  400,  350,  771,  766,  350,
850       689,  688,  350,  397,  407,  687,  295,  409,  412,  412,
851       412,  415,  415,  415,  359,  359,  359,  359,  359,  359,
852       426,  426,  426,  413,  686,  295,  416,  359,  359,  359,
853       361,  685,  680,  361,  679,  678,  405,  421,  421,  421,
854       428,  428,  428,  361,  431,  431,  431,  376,  376,  376,
855       443,  443,  443,  422,  423,  429,  434,  434,  434,  432,
856
857       435,  767,  377,  436,  417,  438,  438,  438,  316,  316,
858       316,  384,  384,  384,  446,  446,  446,  439,  677,  771,
859       440,  387,  387,  387,  318,  389,  389,  389,  676,  390,
860       295,  295,  391,  329,  329,  329,  450,  450,  450,  395,
861       395,  395,  458,  458,  458,  675,  674,  442,  295,  331,
862       769,  451,  295,  673,  396,  452,  452,  452,  459,  453,
863       672,  671,  454,  460,  460,  460,  402,  402,  402,  670,
864       403,  669,  770,  404,  348,  348,  348,  448,  406,  406,
865       406,  462,  462,  462,  768,  463,  668,  667,  464,  666,
866       350,  662,  661,  407,  408,  408,  408,  465,  465,  465,
867
868       660,  466,  659,  658,  467,  412,  412,  412,  657,  409,
869       656,  461,  470,  470,  470,  655,  471,  654,  653,  472,
870       413,  415,  415,  415,  474,  474,  474,  652,  475,  651,
871       650,  476,  359,  359,  359,  649,  416,  421,  421,  421,
872       426,  426,  426,  428,  428,  428,  648,  647,  361,  646,
873       484,  484,  484,  422,  485,  627,  626,  486,  429,  625,
874       431,  431,  431,  488,  488,  488,  624,  489,  620,  599,
875       490,  438,  438,  438,  480,  432,  598,  434,  434,  434,
876       597,  435,  596,  477,  436,  593,  440,  585,  494,  494,
877       494,  481,  495,  581,  574,  496,  498,  498,  498,  443,
878
879       443,  443,  500,  500,  500,  446,  446,  446,  502,  502,
880       502,  573,  499,  329,  329,  329,  450,  450,  450,  505,
881       505,  505,  572,  506,  571,  562,  507,  561,  560,  331,
882       554,  451,  452,  452,  452,  553,  453,  549,  548,  454,
883       458,  458,  458,  460,  460,  460,  348,  348,  348,  503,
884       462,  462,  462,  547,  463,  546,  459,  464,  545,  465,
885       465,  465,  350,  466,  544,  543,  467,  470,  470,  470,
886       542,  471,  536,  531,  472,  474,  474,  474,  530,  475,
887       527,  526,  476,  519,  519,  519,  484,  484,  484,  525,
888       485,  521,  511,  486,  488,  488,  488,  518,  489,  520,
889
890       517,  490,  528,  528,  528,  494,  494,  494,  516,  495,
891       510,  509,  496,  498,  498,  498,  508,  529,  500,  500,
892       500,  532,  532,  532,  502,  502,  502,  504,  501,  499,
893       533,  533,  533,  535,  535,  535,  505,  505,  505,  497,
894       506,  493,  492,  507,  491,  487,  534,  537,  537,  537,
895       539,  539,  539,  348,  348,  348,  519,  519,  519,  555,
896       555,  555,  538,  483,  482,  540,  528,  528,  528,  350,
897       422,  478,  520,  473,  556,  557,  557,  557,  469,  558,
898       468,  529,  559,  532,  532,  532,  533,  533,  533,  535,
899       535,  535,  537,  537,  537,  457,  563,  563,  563,  456,
900
901       564,  455,  534,  565,  449,  541,  447,  538,  539,  539,
902       539,  566,  566,  566,  445,  567,  444,  441,  568,  569,
903       569,  569,  437,  540,  575,  575,  575,  577,  577,  577,
904       579,  579,  579,  433,  430,  570,  582,  582,  582,  576,
905       427,  425,  578,  424,  418,  580,  586,  586,  586,  555,
906       555,  555,  295,  588,  588,  588,  414,  589,  411,  410,
907       590,  587,  401,  399,  556,  557,  557,  557,  398,  558,
908       394,  393,  559,  591,  591,  591,  594,  594,  594,  563,
909       563,  563,  388,  564,  386,  385,  565,  383,  592,  382,
910       380,  595,  566,  566,  566,  379,  567,  378,  375,  568,
911
912       569,  569,  569,  575,  575,  575,  600,  600,  600,  374,
913       601,  373,  372,  602,  371,  370,  570,  369,  576,  577,
914       577,  577,  603,  603,  603,  368,  604,  367,  366,  605,
915       579,  579,  579,  365,  578,  606,  606,  606,  295,  607,
916       363,  358,  608,  357,  356,  580,  582,  582,  582,  612,
917       612,  612,  586,  586,  586,  355,  614,  614,  614,  354,
918       615,  353,  295,  616,  613,  352,  345,  587,  588,  588,
919       588,  340,  589,  339,  338,  590,  591,  591,  591,  609,
920       617,  617,  617,  337,  618,  333,  326,  619,  594,  594,
921       594,  592,  621,  621,  621,  325,  622,  324,  323,  623,
922
923       600,  600,  600,  595,  601,  322,  321,  602,  603,  603,
924       603,  320,  604,  315,  314,  605,  606,  606,  606,  313,
925       607,  312,  311,  608,  612,  612,  612,  643,  643,  643,
926       310,  644,  309,  308,  645,  307,  614,  614,  614,  613,
927       615,  306,  305,  616,  617,  617,  617,  304,  618,  303,
928       302,  619,  621,  621,  621,  301,  622,  298,  296,  623,
929       643,  643,  643,  295,  644,  293,  292,  645,  683,  683,
930       683,  698,  698,  698,  699,  699,  699,  683,  683,  683,
931       291,  289,  288,  684,  422,  287,  286,  295,  285,  700,
932       422,  284,  684,  422,  701,  701,  701,  283,  702,  282,
933
934       280,  703,  698,  698,  698,  699,  699,  699,  279,  278,
935       422,  276,  718,  718,  718,  275,  719,  274,  295,  720,
936       700,  422,  701,  701,  701,  273,  702,  270,  422,  703,
937       717,  269,  742,  742,  742,  754,  754,  754,  422,  420,
938       420,  420,  420,  420,  420,  420,  420,  420,  422,  423,
939       420,  295,  267,  420,  420,  420,  422,  420,  750,  750,
940       750,  266,  751,  265,  264,  752,  742,  742,  742,  263,
941       262,  420,  420,  420,  420,  420,  420,  420,  420,  420,
942       420,  420,  422,  261,  420,  260,  259,  420,  420,  420,
943       422,  420,  718,  718,  718,  257,  719,  256,  255,  720,
944
945       750,  750,  750,  480,  751,  420,  420,  752,  422,  420,
946       420,  420,  420,  420,  736,  420,  420,  420,  254,  253,
947       420,  252,  251,  420,  420,  420,  422,  420,  250,  249,
948       248,  247,  246,  245,  244,  239,  236,  746,  746,  746,
949       238,  420,  420,  420,  420,  420,  420,  420,  420,  420,
950       420,  736,  747,  234,  420,  233,  229,  420,  420,  420,
951       422,  420,  746,  746,  746,  754,  754,  754,  228,  755,
952       227,  226,  756,  225,  223,  420,  420,  747,  772,  772,
953       772,  295,  772,  772,  772,  221,  219,  216,  215,  214,
954       213,  212,  210,  207,  773,  205,  194,  193,  773,   68,
955
956        68,   68,   68,   68,   68,   68,   69,   69,   69,   69,
957        69,   69,   69,   74,   74,   74,   74,   74,   74,   74,
958        77,   77,   77,   77,   77,   77,   77,   80,   80,   80,
959        80,   80,   80,   80,   83,   83,   83,   83,   83,   83,
960        83,   90,   90,   90,   90,   90,   90,   90,  108,  108,
961       108,  108,  108,  108,  108,  118,  118,  118,  118,  118,
962       118,  118,  122,  122,  122,  122,  122,  122,  122,  138,
963       138,  138,  138,  138,  138,  138,  146,  146,  146,  146,
964       146,  146,  146,  150,  150,  150,  150,  150,  150,  150,
965       165,  165,  165,  165,  165,  165,  165,  187,  187,  187,
966
967       192,  187,  206,  206,  206,  191,  206,  211,  211,  211,
968       190,  211,  220,  220,  220,  186,  220,  224,  224,  224,
969       184,  224,  235,  235,  235,  235,  235,  178,  235,  258,
970       177,  258,  268,  178,  268,  277,  177,  277,  281,  176,
971       281,  290,  175,  290,  294,  294,  294,  294,  294,  294,
972       294,  300,  774,  774,  300,  317,  317,  317,  317,  317,
973       317,  330,  330,  330,  330,  330,  330,  342,  342,  342,
974       342,  342,  342,  349,  349,  349,  349,  349,  349,  360,
975       360,  360,  360,  360,  360,  420,  420,  420,  420,  420,
976       420,  420,  721,  721,  721,  721,  721,  721,  721,  722,
977
978       722,  722,  722,  722,  722,  722,  731,  731,  731,  731,
979       731,  731,  731,  734,  734,  734,  734,  734,  734,  734,
980       739,  739,  739,  739,  739,  739,  739,  741,  741,  741,
981       741,  741,  741,  741,   67,  774,  774,  774,  774,  774,
982       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
983       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
984       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
985       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
986       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
987       774,  774,  774,  774
988
989     } ;
990
991 static yyconst flex_int16_t yy_chk[2195] =
992     {   0,
993         0,    3,    3,    3,    4,    4,    4,    5,    5,    5,
994         6,    6,    6,    9,  179,    3,   10,   11,    4,   12,
995         9,    5,  481,   10,    6,    7,    7,    7,    8,    8,
996         8,   13,   13,   11,  297,   12,   13,   13,  297,    7,
997        14,   14,    8,  481,   13,   14,   14,   15,   15,  101,
998        15,   72,   15,   14,   16,   16,  101,   16,  179,   16,
999        15,   17,   17,   18,   18,   72,   73,   16,   19,   19,
1000        19,   20,   20,   20,   23,   23,   23,   24,   24,   24,
1001        73,  107,   19,  164,  240,   20,  240,  107,   23,  164,
1002       180,   24,   17,  180,   18,   21,   21,   21,   21,   21,
1003
1004        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1005        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1006        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1007        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1008        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
1009        21,   21,   21,   21,   25,   25,   25,   26,   26,   26,
1010        27,   27,   27,   28,   28,   28,  466,  467,   25,  480,
1011       745,   26,  466,  467,   27,  523,   76,   28,   29,   29,
1012        29,   30,   30,   30,   31,   31,   31,   32,   32,   32,
1013        76,  522,   29,  551,  523,   30,  584,  522,   31,  480,
1014
1015        99,   32,   33,   33,   33,   34,   34,   34,   35,   35,
1016        35,   36,   36,   36,   99,  741,   33,  732,  732,   34,
1017       740,  584,   35,  739,  551,   36,   37,   37,   37,   37,
1018        37,   37,   37,   37,   37,   37,   37,   37,   37,  610,
1019        37,   37,   37,   37,   37,  583,   39,   39,   39,   40,
1020        40,   40,   41,   41,   41,   42,   42,   42,   37,   37,
1021        39,  641,  119,   40,  610,  583,   41,  737,  735,   42,
1022        70,   70,   70,   71,   71,   71,  119,   37,   38,   38,
1023        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
1024        38,  641,   38,   38,   38,   38,   38,  609,   43,   43,
1025
1026        43,   44,   44,   44,   45,   45,   45,   46,   46,   46,
1027        38,   38,   43,  744,  131,   44,  733,  609,   45,  744,
1028       723,   46,   75,   75,   75,   96,   96,   96,  131,   38,
1029        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1030        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1031        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1032        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1033        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
1034        47,   47,   47,   47,   47,   47,   47,   47,   47,   49,
1035        49,   49,   50,   50,   50,   51,   51,   51,   52,   52,
1036
1037        52,  524,  642,   49,  715,  663,   50,  713,  664,   51,
1038       711,  147,   52,   53,   53,   53,   54,   54,   54,   55,
1039        55,   55,   56,   56,   56,  147,  709,   53,  663,  707,
1040        54,  664,  642,   55,  705,  524,   56,   57,   57,   57,
1041        57,   57,   57,   57,   57,   57,   57,   57,   57,   57,
1042       704,   57,   57,   57,   57,   57,  755,   59,   59,   59,
1043        60,   60,   60,   63,   63,   63,   64,   64,   64,   57,
1044        57,   59,   94,  157,   60,  237,  755,   63,  552,  697,
1045        64,   86,  109,  109,  109,  237,   94,  157,   57,   58,
1046        58,   58,   58,   58,   58,   58,   58,   58,   58,   58,
1047
1048        58,   58,   94,   58,   58,   58,   58,   58,  479,   86,
1049       116,  116,  116,  552,  720,   86,  123,  123,  123,  479,
1050        86,   58,   58,  720,  419,   86,  128,  128,  128,  139,
1051       139,  139,  144,  144,  144,  151,  151,  151,  419,  696,
1052        58,   61,   61,   61,   61,   61,   61,   61,   61,   61,
1053        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
1054        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
1055        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
1056        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
1057        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
1058
1059        65,   65,   66,   66,  110,   65,  601,   66,  112,  602,
1060       152,  110,  111,   65,  695,   66,  113,  152,  110,  111,
1061       601,  604,  112,  602,  152,  167,  111,  154,  154,  154,
1062       113,   65,  167,   66,  110,  604,  110,  171,  112,  167,
1063       112,  694,  111,  110,  111,  114,  113,  112,  113,  110,
1064       171,  111,  114,  112,  110,  113,  693,  111,  112,  114,
1065       611,  113,  111,  364,  124,  605,  113,  125,  166,  166,
1066       166,  124,  170,  170,  170,  114,  364,  114,  124,  605,
1067       719,  125,  692,  691,  114,  738,  126,  212,  212,  212,
1068       114,  611,  719,  126,  124,  114,  124,  125,  738,  125,
1069
1070       126,  730,  212,  124,  690,  141,  125,  607,  140,  124,
1071       608,  731,  125,  730,  124,  140,  126,  125,  126,  141,
1072       689,  607,  140,  731,  608,  126,  756,  142,  267,  267,
1073       267,  126,  640,  688,  142,  141,  126,  141,  140,  734,
1074       140,  142,  717,  267,  141,  748,  756,  140,  734,  640,
1075       141,  687,  686,  140,  748,  141,  717,  142,  140,  142,
1076       258,  258,  258,  259,  259,  259,  142,  268,  268,  268,
1077       757,  761,  142,  269,  269,  269,  258,  142,  761,  259,
1078       271,  271,  271,  268,  272,  272,  272,  757,  272,  269,
1079       758,  272,  277,  277,  277,  271,  278,  278,  278,  259,
1080
1081       280,  280,  280,  281,  281,  281,  685,  758,  277,  282,
1082       282,  282,  278,  269,  680,  280,  290,  290,  290,  281,
1083       291,  291,  291,  759,  760,  282,  312,  312,  312,  316,
1084       316,  316,  290,  317,  317,  317,  291,  319,  319,  319,
1085       763,  312,  282,  278,  679,  316,  322,  322,  322,  317,
1086       325,  325,  325,  319,  327,  327,  327,  328,  328,  328,
1087       763,  328,  759,  760,  328,  329,  329,  329,  678,  327,
1088       319,  291,  330,  330,  330,  332,  332,  332,  334,  334,
1089       334,  329,  334,  762,  677,  334,  676,  675,  330,  674,
1090       762,  332,  338,  338,  338,  341,  341,  341,  342,  342,
1091
1092       342,  344,  344,  344,  346,  346,  346,  338,  347,  347,
1093       347,  341,  347,  673,  342,  347,  332,  344,  764,  346,
1094       348,  348,  348,  349,  349,  349,  351,  351,  351,  352,
1095       352,  352,  353,  353,  353,  344,  348,  770,  764,  349,
1096       672,  671,  351,  338,  352,  670,  770,  353,  356,  356,
1097       356,  358,  358,  358,  359,  359,  359,  360,  360,  360,
1098       370,  370,  370,  356,  669,  765,  358,  362,  362,  362,
1099       359,  666,  662,  360,  661,  660,  351,  365,  365,  365,
1100       372,  372,  372,  362,  374,  374,  374,  376,  376,  376,
1101       382,  382,  382,  365,  365,  372,  377,  377,  377,  374,
1102
1103       377,  765,  376,  377,  362,  379,  379,  379,  381,  381,
1104       381,  384,  384,  384,  386,  386,  386,  379,  659,  769,
1105       379,  387,  387,  387,  381,  389,  389,  389,  658,  389,
1106       767,  769,  389,  392,  392,  392,  394,  394,  394,  395,
1107       395,  395,  400,  400,  400,  657,  656,  381,  766,  392,
1108       767,  394,  768,  655,  395,  396,  396,  396,  400,  396,
1109       654,  653,  396,  401,  401,  401,  402,  402,  402,  652,
1110       402,  651,  768,  402,  405,  405,  405,  392,  406,  406,
1111       406,  407,  407,  407,  766,  407,  650,  648,  407,  646,
1112       405,  639,  638,  406,  408,  408,  408,  409,  409,  409,
1113
1114       637,  409,  636,  635,  409,  412,  412,  412,  634,  408,
1115       633,  405,  413,  413,  413,  632,  413,  631,  630,  413,
1116       412,  415,  415,  415,  416,  416,  416,  629,  416,  628,
1117       627,  416,  417,  417,  417,  626,  415,  421,  421,  421,
1118       426,  426,  426,  428,  428,  428,  625,  624,  417,  620,
1119       429,  429,  429,  421,  429,  599,  598,  429,  428,  597,
1120       431,  431,  431,  432,  432,  432,  596,  432,  593,  574,
1121       432,  438,  438,  438,  421,  431,  573,  434,  434,  434,
1122       572,  434,  571,  417,  434,  561,  438,  553,  440,  440,
1123       440,  421,  440,  549,  545,  440,  442,  442,  442,  443,
1124
1125       443,  443,  444,  444,  444,  446,  446,  446,  447,  447,
1126       447,  544,  442,  448,  448,  448,  450,  450,  450,  451,
1127       451,  451,  543,  451,  542,  536,  451,  531,  530,  448,
1128       526,  450,  452,  452,  452,  525,  452,  521,  518,  452,
1129       458,  458,  458,  460,  460,  460,  461,  461,  461,  448,
1130       462,  462,  462,  517,  462,  516,  458,  462,  515,  465,
1131       465,  465,  461,  465,  514,  513,  465,  470,  470,  470,
1132       512,  470,  508,  497,  470,  474,  474,  474,  493,  474,
1133       491,  487,  474,  477,  477,  477,  484,  484,  484,  483,
1134       484,  478,  461,  484,  488,  488,  488,  473,  488,  477,
1135
1136       469,  488,  492,  492,  492,  494,  494,  494,  468,  494,
1137       457,  456,  494,  498,  498,  498,  455,  492,  500,  500,
1138       500,  501,  501,  501,  502,  502,  502,  449,  445,  498,
1139       503,  503,  503,  504,  504,  504,  505,  505,  505,  441,
1140       505,  439,  437,  505,  433,  430,  503,  509,  509,  509,
1141       510,  510,  510,  511,  511,  511,  519,  519,  519,  527,
1142       527,  527,  509,  427,  423,  510,  528,  528,  528,  511,
1143       420,  418,  519,  414,  527,  529,  529,  529,  411,  529,
1144       410,  528,  529,  532,  532,  532,  533,  533,  533,  535,
1145       535,  535,  537,  537,  537,  399,  538,  538,  538,  398,
1146
1147       538,  397,  533,  538,  393,  511,  388,  537,  539,  539,
1148       539,  540,  540,  540,  385,  540,  383,  380,  540,  541,
1149       541,  541,  378,  539,  546,  546,  546,  547,  547,  547,
1150       548,  548,  548,  375,  373,  541,  550,  550,  550,  546,
1151       371,  369,  547,  368,  363,  548,  554,  554,  554,  555,
1152       555,  555,  550,  556,  556,  556,  357,  556,  355,  354,
1153       556,  554,  345,  340,  555,  557,  557,  557,  339,  557,
1154       337,  333,  557,  560,  560,  560,  562,  562,  562,  563,
1155       563,  563,  326,  563,  324,  323,  563,  321,  560,  320,
1156       315,  562,  566,  566,  566,  314,  566,  313,  311,  566,
1157
1158       569,  569,  569,  575,  575,  575,  576,  576,  576,  310,
1159       576,  309,  308,  576,  307,  306,  569,  305,  575,  577,
1160       577,  577,  578,  578,  578,  302,  578,  301,  300,  578,
1161       579,  579,  579,  298,  577,  580,  580,  580,  294,  580,
1162       292,  289,  580,  288,  287,  579,  582,  582,  582,  585,
1163       585,  585,  586,  586,  586,  286,  587,  587,  587,  285,
1164       587,  284,  582,  587,  585,  283,  279,  586,  588,  588,
1165       588,  276,  588,  275,  274,  588,  591,  591,  591,  582,
1166       592,  592,  592,  273,  592,  270,  266,  592,  594,  594,
1167       594,  591,  595,  595,  595,  265,  595,  264,  263,  595,
1168
1169       600,  600,  600,  594,  600,  262,  261,  600,  603,  603,
1170       603,  260,  603,  257,  256,  603,  606,  606,  606,  255,
1171       606,  254,  253,  606,  612,  612,  612,  613,  613,  613,
1172       252,  613,  251,  250,  613,  249,  614,  614,  614,  612,
1173       614,  248,  246,  614,  617,  617,  617,  245,  617,  244,
1174       243,  617,  621,  621,  621,  242,  621,  238,  236,  621,
1175       643,  643,  643,  235,  643,  234,  233,  643,  665,  665,
1176       665,  681,  681,  681,  682,  682,  682,  683,  683,  683,
1177       232,  231,  230,  665,  665,  229,  228,  681,  227,  682,
1178       682,  226,  683,  683,  684,  684,  684,  225,  684,  222,
1179
1180       221,  684,  698,  698,  698,  699,  699,  699,  218,  217,
1181       684,  216,  700,  700,  700,  215,  700,  214,  698,  700,
1182       699,  699,  701,  701,  701,  213,  701,  209,  700,  701,
1183       698,  208,  736,  736,  736,  753,  753,  753,  701,  702,
1184       702,  702,  702,  702,  702,  702,  702,  702,  736,  736,
1185       702,  753,  207,  702,  702,  702,  702,  702,  747,  747,
1186       747,  204,  747,  203,  202,  747,  742,  742,  742,  201,
1187       200,  702,  702,  703,  703,  703,  703,  703,  703,  703,
1188       703,  703,  742,  199,  703,  198,  197,  703,  703,  703,
1189       703,  703,  718,  718,  718,  196,  718,  195,  194,  718,
1190
1191       750,  750,  750,  742,  750,  703,  703,  750,  718,  721,
1192       721,  721,  721,  721,  721,  721,  721,  721,  193,  192,
1193       721,  191,  190,  721,  721,  721,  721,  721,  189,  188,
1194       185,  184,  183,  182,  181,  175,  174,  743,  743,  743,
1195       172,  721,  721,  722,  722,  722,  722,  722,  722,  722,
1196       722,  722,  743,  169,  722,  168,  163,  722,  722,  722,
1197       722,  722,  746,  746,  746,  754,  754,  754,  162,  754,
1198       161,  160,  754,  159,  155,  722,  722,  746,  771,  771,
1199       771,  754,  772,  772,  772,  149,  145,  137,  136,  135,
1200       134,  133,  129,  121,  771,  117,  106,  105,  772,  775,
1201
1202       775,  775,  775,  775,  775,  775,  776,  776,  776,  776,
1203       776,  776,  776,  777,  777,  777,  777,  777,  777,  777,
1204       778,  778,  778,  778,  778,  778,  778,  779,  779,  779,
1205       779,  779,  779,  779,  780,  780,  780,  780,  780,  780,
1206       780,  781,  781,  781,  781,  781,  781,  781,  782,  782,
1207       782,  782,  782,  782,  782,  783,  783,  783,  783,  783,
1208       783,  783,  784,  784,  784,  784,  784,  784,  784,  785,
1209       785,  785,  785,  785,  785,  785,  786,  786,  786,  786,
1210       786,  786,  786,  787,  787,  787,  787,  787,  787,  787,
1211       788,  788,  788,  788,  788,  788,  788,  789,  789,  789,
1212
1213       104,  789,  790,  790,  790,  103,  790,  791,  791,  791,
1214       102,  791,  792,  792,  792,   97,  792,  793,  793,  793,
1215        93,  793,  794,  794,  794,  794,  794,   92,  794,  795,
1216        91,  795,  796,   85,  796,  797,   84,  797,  798,   82,
1217       798,  799,   79,  799,  800,  800,  800,  800,  800,  800,
1218       800,  801,   67,    0,  801,  802,  802,  802,  802,  802,
1219       802,  803,  803,  803,  803,  803,  803,  804,  804,  804,
1220       804,  804,  804,  805,  805,  805,  805,  805,  805,  806,
1221       806,  806,  806,  806,  806,  807,  807,  807,  807,  807,
1222       807,  807,  808,  808,  808,  808,  808,  808,  808,  809,
1223
1224       809,  809,  809,  809,  809,  809,  810,  810,  810,  810,
1225       810,  810,  810,  811,  811,  811,  811,  811,  811,  811,
1226       812,  812,  812,  812,  812,  812,  812,  813,  813,  813,
1227       813,  813,  813,  813,  774,  774,  774,  774,  774,  774,
1228       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
1229       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
1230       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
1231       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
1232       774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
1233       774,  774,  774,  774
1234
1235     } ;
1236
1237 /* Table of booleans, true if rule could match eol. */
1238 static yyconst flex_int32_t yy_rule_can_match_eol[141] =
1239     {   0,
1240 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 
1241     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 
1242     0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 
1243     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 
1244     1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
1245     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 
1246     0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 
1247     0,     };
1248
1249 static yy_state_type yy_last_accepting_state;
1250 static char *yy_last_accepting_cpos;
1251
1252 extern int dax__flex_debug;
1253 int dax__flex_debug = 0;
1254
1255 /* The intent behind this definition is that it'll catch
1256  * any uses of REJECT which flex missed.
1257  */
1258 #define REJECT reject_used_but_not_detected
1259 #define yymore() yymore_used_but_not_detected
1260 #define YY_MORE_ADJ 0
1261 #define YY_RESTORE_YY_MORE_OFFSET
1262 char *dax_text;
1263 /* Validating XML processor for src/simdag/dax.dtd.
1264  *
1265  * This program was generated with the FleXML XML processor generator.
1266  * FleXML is Copyright (C) 1999-2005 Kristoffer Rose.  All rights reserved.
1267  * FleXML is Copyright (C) 2003-2013 Martin Quinson.  All rights reserved.
1268  * (1.9.6).
1269  * 
1270  * There are two, intertwined parts to this program, part A and part B.
1271  *
1272  * Part A
1273  * ------
1274  * 
1275  * Some parts, here collectively called "Part A", are found in the 
1276  * FleXML package.  They are Copyright (C) 1999-2005 Kristoffer Rose
1277  * and Copyright (C) 2003-2013 Martin Quinson. All rights reserved.
1278  *
1279  * You can redistribute, use, perform, display and/or modify "Part A"
1280  * provided the following two conditions hold:
1281  *
1282  * 1. The program is distributed WITHOUT ANY WARRANTY from the author of
1283  *    FleXML; without even the implied warranty of MERCHANTABILITY or
1284  *    FITNESS FOR A PARTICULAR PURPOSE.
1285  *
1286  * 2. The program distribution conditions do not in any way affect the
1287  *    distribution conditions of the FleXML system used to generate this
1288  *    file or any version of FleXML derived from that system.
1289  *
1290  * Notice that these are explicit rights granted to you for files
1291  * generated by the FleXML system.  For your rights in connection with
1292  * the FleXML system itself please consult the GNU General Public License.
1293  * 
1294  * Part B
1295  * ------
1296  * 
1297  * The other parts, here collectively called "Part B", and which came 
1298  * from the DTD used by FleXML to generate this program, can be 
1299  * distributed (or not, as the case may be) under the terms of whoever
1300  * wrote them, provided these terms respect and obey the two conditions 
1301  * above under the heading "Part A".
1302  *
1303  * The author of and contributors to FleXML specifically disclaim
1304  * any copyright interest in "Part B", unless "Part B" was written 
1305  * by the author of or contributors to FleXML.
1306  * 
1307  */
1308
1309 /* Version strings. */
1310 const char dax__flexml_version[] = "1.9.6";
1311
1312 /* ANSI headers. */
1313 #include <stdlib.h> /* for realloc() -- needed here when using flex 2.5.4 */
1314 #include <stdio.h>
1315 #include <string.h>
1316 #include <assert.h>
1317 #include <stdarg.h>
1318 #include <ctype.h>
1319      
1320 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__)
1321 # ifndef __STRICT_ANSI__
1322 #  include <io.h>
1323 #  include <process.h>
1324 # endif
1325 #else
1326 # include <unistd.h>
1327 #endif
1328      
1329 #ifndef FLEXML_INDEXSTACKSIZE
1330 #define FLEXML_INDEXSTACKSIZE 1000
1331 #endif
1332
1333 /* Generated definitions. */
1334 #define FLEXML_yylineno
1335 #ifndef FLEXML_BUFFERSTACKSIZE
1336 #define FLEXML_BUFFERSTACKSIZE 1000000
1337 #endif
1338 #define FLEXML_NEED_BUFFERLIT
1339
1340 /* XML processor api. */
1341 /* FleXML-provided data. */
1342 int dax__pcdata_ix;
1343 extern char *dax__bufferstack;
1344 #define dax__pcdata (dax__bufferstack + dax__pcdata_ix)
1345 AT_dax__adag_childCount AX_dax__adag_childCount;
1346 #define A_dax__adag_childCount (dax__bufferstack + AX_dax__adag_childCount)
1347 short int dax__adag_childCount_isset;
1348 AT_dax__adag_count AX_dax__adag_count;
1349 #define A_dax__adag_count (dax__bufferstack + AX_dax__adag_count)
1350 short int dax__adag_count_isset;
1351 AT_dax__adag_fileCount AX_dax__adag_fileCount;
1352 #define A_dax__adag_fileCount (dax__bufferstack + AX_dax__adag_fileCount)
1353 short int dax__adag_fileCount_isset;
1354 AT_dax__adag_index AX_dax__adag_index;
1355 #define A_dax__adag_index (dax__bufferstack + AX_dax__adag_index)
1356 short int dax__adag_index_isset;
1357 AT_dax__adag_jobCount AX_dax__adag_jobCount;
1358 #define A_dax__adag_jobCount (dax__bufferstack + AX_dax__adag_jobCount)
1359 short int dax__adag_jobCount_isset;
1360 AT_dax__adag_name AX_dax__adag_name;
1361 #define A_dax__adag_name (dax__bufferstack + AX_dax__adag_name)
1362 short int dax__adag_name_isset;
1363 AT_dax__adag_version AX_dax__adag_version;
1364 #define A_dax__adag_version (dax__bufferstack + AX_dax__adag_version)
1365 short int dax__adag_version_isset;
1366 AT_dax__adag_xmlns AX_dax__adag_xmlns;
1367 #define A_dax__adag_xmlns (dax__bufferstack + AX_dax__adag_xmlns)
1368 short int dax__adag_xmlns_isset;
1369 AT_dax__adag_xmlns_c_xsi AX_dax__adag_xmlns_c_xsi;
1370 #define A_dax__adag_xmlns_c_xsi (dax__bufferstack + AX_dax__adag_xmlns_c_xsi)
1371 short int dax__adag_xmlns_c_xsi_isset;
1372 AT_dax__adag_xsi_c_schemaLocation AX_dax__adag_xsi_c_schemaLocation;
1373 #define A_dax__adag_xsi_c_schemaLocation (dax__bufferstack + AX_dax__adag_xsi_c_schemaLocation)
1374 short int dax__adag_xsi_c_schemaLocation_isset;
1375 AT_dax__child_ref AX_dax__child_ref;
1376 #define A_dax__child_ref (dax__bufferstack + AX_dax__child_ref)
1377 short int dax__child_ref_isset;
1378 AT_dax__job_id AX_dax__job_id;
1379 #define A_dax__job_id (dax__bufferstack + AX_dax__job_id)
1380 short int dax__job_id_isset;
1381 AT_dax__job_level AX_dax__job_level;
1382 #define A_dax__job_level (dax__bufferstack + AX_dax__job_level)
1383 short int dax__job_level_isset;
1384 AT_dax__job_name AX_dax__job_name;
1385 #define A_dax__job_name (dax__bufferstack + AX_dax__job_name)
1386 short int dax__job_name_isset;
1387 AT_dax__job_namespace AX_dax__job_namespace;
1388 #define A_dax__job_namespace (dax__bufferstack + AX_dax__job_namespace)
1389 short int dax__job_namespace_isset;
1390 AT_dax__job_runtime AX_dax__job_runtime;
1391 #define A_dax__job_runtime (dax__bufferstack + AX_dax__job_runtime)
1392 short int dax__job_runtime_isset;
1393 AT_dax__job_version AX_dax__job_version;
1394 #define A_dax__job_version (dax__bufferstack + AX_dax__job_version)
1395 short int dax__job_version_isset;
1396 AT_dax__parent_ref AX_dax__parent_ref;
1397 #define A_dax__parent_ref (dax__bufferstack + AX_dax__parent_ref)
1398 short int dax__parent_ref_isset;
1399 AT_dax__uses_file AX_dax__uses_file;
1400 #define A_dax__uses_file (dax__bufferstack + AX_dax__uses_file)
1401 short int dax__uses_file_isset;
1402 AT_dax__uses_link AX_dax__uses_link;
1403 #define A_dax__uses_link AX_dax__uses_link
1404 short int dax__uses_link_isset;
1405 AT_dax__uses_optional AX_dax__uses_optional;
1406 #define A_dax__uses_optional AX_dax__uses_optional
1407 short int dax__uses_optional_isset;
1408 AT_dax__uses_register AX_dax__uses_register;
1409 #define A_dax__uses_register AX_dax__uses_register
1410 short int dax__uses_register_isset;
1411 AT_dax__uses_size AX_dax__uses_size;
1412 #define A_dax__uses_size (dax__bufferstack + AX_dax__uses_size)
1413 short int dax__uses_size_isset;
1414 AT_dax__uses_transfer AX_dax__uses_transfer;
1415 #define A_dax__uses_transfer AX_dax__uses_transfer
1416 short int dax__uses_transfer_isset;
1417 AT_dax__uses_type AX_dax__uses_type;
1418 #define A_dax__uses_type (dax__bufferstack + AX_dax__uses_type)
1419 short int dax__uses_type_isset;
1420
1421 /* XML state. */
1422 #ifdef FLEX_DEBUG
1423 # define ENTER(state)   debug_enter(state,#state)
1424 # define LEAVE          debug_leave()
1425 # define SET(state)     debug_set(state,#state)
1426   static void debug_enter(int, const char*);
1427   static void debug_leave(void);
1428   static void debug_set(int, const char*);
1429 #else
1430 # define ENTER(state)   (yy_push_state(state))
1431 # define LEAVE          (yy_pop_state())
1432 # define SET(state)     BEGIN(state)
1433 #endif
1434
1435 /* Generic actions. */
1436 #define SKIP    /*skip*/
1437 #define SUCCEED        CLEANUP; return 0
1438
1439 #define FAIL    return fail
1440 static int fail(const char*, ...);
1441
1442 enum {flexml_max_err_msg_size = 512};
1443 static char flexml_err_msg[flexml_max_err_msg_size];
1444 const char * dax__parse_err_msg()
1445 {
1446     return flexml_err_msg;
1447 }
1448 static void reset_dax__parse_err_msg()
1449 {
1450     flexml_err_msg[0] = '\0';
1451 }
1452
1453 /* Cleanup */
1454 static void cleanup(void);
1455 #define CLEANUP  cleanup()
1456
1457 /* Text buffer stack handling. */
1458 char *dax__bufferstack = NULL;
1459 static int blimit = FLEXML_BUFFERSTACKSIZE;
1460 static int bnext = 1;
1461
1462 static int *indexstack = NULL;
1463 static int ilimit = FLEXML_INDEXSTACKSIZE;
1464 static int inext = 1;
1465
1466 #define BUFFERSET(P)  (P = bnext)
1467 #define BUFFERPUTC(C) (ck_blimit(), dax__bufferstack[bnext++] = (C))
1468 #define BUFFERDONE    (BUFFERPUTC('\0'))
1469
1470 #define BUFFERLITERAL(C, P) dax__bufferliteral(C, &(P), dax_text)
1471
1472 /* after this is called, there are at least 2 slots left in the stack */
1473 static int ck_blimit()
1474 {
1475      if (bnext >= blimit) {
1476          blimit += FLEXML_BUFFERSTACKSIZE + 2;
1477          {
1478              char *temp = (char *) realloc(dax__bufferstack, blimit);
1479              assert(temp);
1480              dax__bufferstack = temp;
1481          }
1482      }
1483      return 0;
1484 }
1485
1486 /* after this is called, there are at least 2 slots left in the stack */
1487 static int ck_ilimit()
1488 {
1489      if (inext >= ilimit) {
1490          ilimit += FLEXML_INDEXSTACKSIZE + 2;
1491          {
1492              int *temp = (int *) realloc(indexstack, ilimit);
1493              assert(temp);
1494              indexstack = temp;
1495          }
1496      }
1497      return 0;
1498 }
1499
1500 #ifdef FLEXML_NEED_BUFFERLIT
1501 static void dax__bufferliteral(char c, int* pp, const char* text)
1502 {
1503    BUFFERSET(*pp);
1504    if (c) {
1505       const char *s = strchr(text, c), *e = strrchr(text, c);
1506       assert(s && e && s <= e);
1507       ++s;
1508       while (s < e) {
1509          if (isspace(*s)) {
1510             BUFFERPUTC(' ');
1511             do ++s; while (s < e && isspace(*s));
1512          } else
1513            BUFFERPUTC(*s++);
1514       }
1515    } else {
1516       const char *s = text;
1517       while (*s)
1518         BUFFERPUTC(*s++);
1519    }
1520    BUFFERDONE;
1521 }
1522 #endif
1523
1524 static void pushbuffer(int p)
1525 {
1526     ck_ilimit();
1527     indexstack[inext++] = p;
1528     indexstack[inext++] = bnext;    
1529 }
1530
1531 static int popbuffer(void)
1532 {
1533     assert(inext >= 2);
1534     bnext = indexstack[--inext];
1535     return indexstack[--inext];
1536 }
1537
1538 /* General internal entities are `unput' back onto the input stream... */
1539 #define ENTITYTEXT(T) \
1540   { char *s = (T), *e = s+strlen(s);\
1541     while (--e >= s) { unput(*e); }}
1542
1543 /* Flex standard options. */
1544 #define YY_NO_INPUT 1
1545 /* Flex user-requested options. */
1546 /* XML character classes (currently restricted to ASCII). */
1547 /* "Common syntactic structures." */
1548 /* "Names and Tokens." */
1549 /* Miscellaneous. */
1550 /* Parser states (flex `exclusive start conditions'):
1551  *
1552  * PROLOG       the XML prolog of the document before <?xml...>
1553  * DOCTYPE      the XML prolog of the document after <?xml...>
1554  * EPILOG       after the root element
1555  * INCOMMENT    inside an XML comment <!--....-->
1556  * INPI         inside an XML PI <?...?>
1557  * VALUE1       inside a '...'-delimited literal
1558  * VALUE2       inside a "..."-delimited literal
1559  * CDATA        inside a <![CDATA[...] ]> section.
1560  * ROOT_<tag>   expect root element <tag>
1561  * AL_<tag>     inside the attribute list for <tag>
1562  * IN_<tag>     inside a <tag> with element contents (ready for end tag)
1563  * IMPOSSIBLE   dummy to permit disabling rules; must be last
1564  */
1565
1566 /* State names. */
1567 const char* *dax__statenames=NULL;
1568
1569 #define INITIAL 0
1570 #define PROLOG 1
1571 #define DOCTYPE 2
1572 #define EPILOG 3
1573 #define INCOMMENT 4
1574 #define INPI 5
1575 #define VALUE1 6
1576 #define VALUE2 7
1577 #define CDATA 8
1578 #define ROOT_dax__adag 9
1579 #define AL_dax__adag 10
1580 #define S_dax__adag 11
1581 #define S_dax__adag_1 12
1582 #define S_dax__adag_2 13
1583 #define S_dax__adag_3 14
1584 #define S_dax__adag_4 15
1585 #define S_dax__adag_5 16
1586 #define E_dax__adag 17
1587 #define AL_dax__child 18
1588 #define S_dax__child 19
1589 #define S_dax__child_1 20
1590 #define S_dax__child_2 21
1591 #define E_dax__child 22
1592 #define AL_dax__job 23
1593 #define S_dax__job 24
1594 #define S_dax__job_1 25
1595 #define S_dax__job_2 26
1596 #define E_dax__job 27
1597 #define AL_dax__parent 28
1598 #define E_dax__parent 29
1599 #define AL_dax__uses 30
1600 #define E_dax__uses 31
1601 #define IMPOSSIBLE 32
1602
1603 #ifndef YY_NO_UNISTD_H
1604 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1605  * down here because we want the user's section 1 to have been scanned first.
1606  * The user has a chance to override it with an option.
1607  */
1608 #if defined(_WIN32)
1609 #  ifndef __STRICT_ANSI__
1610 #    include <io.h>
1611 #    include <process.h>
1612 #  endif
1613 #else
1614 #  include <unistd.h>
1615 #endif
1616 #endif
1617
1618 #ifndef YY_EXTRA_TYPE
1619 #define YY_EXTRA_TYPE void *
1620 #endif
1621
1622 static int yy_init_globals (void );
1623
1624 /* Accessor methods to globals.
1625    These are made visible to non-reentrant scanners for convenience. */
1626
1627 int dax_lex_destroy (void );
1628
1629 int dax_get_debug (void );
1630
1631 void dax_set_debug (int debug_flag  );
1632
1633 YY_EXTRA_TYPE dax_get_extra (void );
1634
1635 void dax_set_extra (YY_EXTRA_TYPE user_defined  );
1636
1637 FILE *dax_get_in (void );
1638
1639 void dax_set_in  (FILE * _in_str  );
1640
1641 FILE *dax_get_out (void );
1642
1643 void dax_set_out  (FILE * _out_str  );
1644
1645 yy_size_t dax_get_leng (void );
1646
1647 char *dax_get_text (void );
1648
1649 int dax_get_lineno (void );
1650
1651 void dax_set_lineno (int _line_number  );
1652
1653 /* Macros after this point can all be overridden by user definitions in
1654  * section 1.
1655  */
1656
1657 #ifndef YY_SKIP_YYWRAP
1658 #ifdef __cplusplus
1659 extern "C" int dax_wrap (void );
1660 #else
1661 extern int dax_wrap (void );
1662 #endif
1663 #endif
1664
1665 #ifndef YY_NO_UNPUT
1666     
1667 #endif
1668
1669 #ifndef yytext_ptr
1670 static void yy_flex_strncpy (char *,yyconst char *,int );
1671 #endif
1672
1673 #ifdef YY_NEED_STRLEN
1674 static int yy_flex_strlen (yyconst char * );
1675 #endif
1676
1677 #ifndef YY_NO_INPUT
1678
1679 #ifdef __cplusplus
1680 static int yyinput (void );
1681 #else
1682 static int input (void );
1683 #endif
1684
1685 #endif
1686
1687         static int yy_start_stack_ptr = 0;
1688         static int yy_start_stack_depth = 0;
1689         static int *yy_start_stack = NULL;
1690     
1691     static void yy_push_state (int _new_state );
1692     
1693     static void yy_pop_state (void );
1694     
1695 /* Amount of stuff to slurp up with each read. */
1696 #ifndef YY_READ_BUF_SIZE
1697 #ifdef __ia64__
1698 /* On IA-64, the buffer size is 16k, not 8k */
1699 #define YY_READ_BUF_SIZE 16384
1700 #else
1701 #define YY_READ_BUF_SIZE 8192
1702 #endif /* __ia64__ */
1703 #endif
1704
1705 /* Copy whatever the last rule matched to the standard output. */
1706 #ifndef ECHO
1707 /* This used to be an fputs(), but since the string might contain NUL's,
1708  * we now use fwrite().
1709  */
1710 #define ECHO do { if (fwrite( dax_text, dax_leng, 1, dax_out )) {} } while (0)
1711 #endif
1712
1713 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1714  * is returned in "result".
1715  */
1716 #ifndef YY_INPUT
1717 #define YY_INPUT(buf,result,max_size) \
1718         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1719                 { \
1720                 int c = '*'; \
1721                 size_t n; \
1722                 for ( n = 0; n < max_size && \
1723                              (c = getc( dax_in )) != EOF && c != '\n'; ++n ) \
1724                         buf[n] = (char) c; \
1725                 if ( c == '\n' ) \
1726                         buf[n++] = (char) c; \
1727                 if ( c == EOF && ferror( dax_in ) ) \
1728                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1729                 result = n; \
1730                 } \
1731         else \
1732                 { \
1733                 errno=0; \
1734                 while ( (result = fread(buf, 1, max_size, dax_in))==0 && ferror(dax_in)) \
1735                         { \
1736                         if( errno != EINTR) \
1737                                 { \
1738                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1739                                 break; \
1740                                 } \
1741                         errno=0; \
1742                         clearerr(dax_in); \
1743                         } \
1744                 }\
1745 \
1746
1747 #endif
1748
1749 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1750  * we don't want an extra ';' after the "return" because that will cause
1751  * some compilers to complain about unreachable statements.
1752  */
1753 #ifndef yyterminate
1754 #define yyterminate() return YY_NULL
1755 #endif
1756
1757 /* Number of entries by which start-condition stack grows. */
1758 #ifndef YY_START_STACK_INCR
1759 #define YY_START_STACK_INCR 25
1760 #endif
1761
1762 /* Report a fatal error. */
1763 #ifndef YY_FATAL_ERROR
1764 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1765 #endif
1766
1767 /* end tables serialization structures and prototypes */
1768
1769 /* Default declaration of generated scanner - a define so the user can
1770  * easily add parameters.
1771  */
1772 #ifndef YY_DECL
1773 #define YY_DECL_IS_OURS 1
1774
1775 extern int dax_lex (void);
1776
1777 #define YY_DECL int dax_lex (void)
1778 #endif /* !YY_DECL */
1779
1780 /* Code executed at the beginning of each rule, after dax_text and dax_leng
1781  * have been set up.
1782  */
1783 #ifndef YY_USER_ACTION
1784 #define YY_USER_ACTION
1785 #endif
1786
1787 /* Code executed at the end of each rule. */
1788 #ifndef YY_BREAK
1789 #define YY_BREAK /*LINTED*/break;
1790 #endif
1791
1792 #define YY_RULE_SETUP \
1793         YY_USER_ACTION
1794
1795 /** The main scanner function which does all the work.
1796  */
1797 YY_DECL
1798 {
1799         yy_state_type yy_current_state;
1800         char *yy_cp, *yy_bp;
1801         int yy_act;
1802     
1803         if ( !(yy_init) )
1804                 {
1805                 (yy_init) = 1;
1806
1807 #ifdef YY_USER_INIT
1808                 YY_USER_INIT;
1809 #endif
1810
1811                 if ( ! (yy_start) )
1812                         (yy_start) = 1; /* first start state */
1813
1814                 if ( ! dax_in )
1815                         dax_in = stdin;
1816
1817                 if ( ! dax_out )
1818                         dax_out = stdout;
1819
1820                 if ( ! YY_CURRENT_BUFFER ) {
1821                         dax_ensure_buffer_stack ();
1822                         YY_CURRENT_BUFFER_LVALUE =
1823                                 dax__create_buffer(dax_in,YY_BUF_SIZE );
1824                 }
1825
1826                 dax__load_buffer_state( );
1827                 }
1828
1829         {
1830
1831  /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
1832  SET(PROLOG);
1833  reset_dax__parse_err_msg();
1834  dax__bufferstack = (char *) malloc(FLEXML_BUFFERSTACKSIZE);
1835  assert(dax__bufferstack);
1836  #ifdef FLEX_DEBUG
1837  {
1838      int i;
1839      for (i = 0; i < blimit; i++) {
1840          dax__bufferstack[i] = '\377';
1841      }
1842  }
1843  #endif
1844  dax__bufferstack[0] = '\0';
1845  indexstack = (int *) malloc(FLEXML_INDEXSTACKSIZE * sizeof(int));
1846  assert(indexstack);
1847  indexstack[0] = 0;
1848
1849   /* FleXML_init */
1850   bnext = inext = 1;
1851   dax__bufferliteral('\0', &bnext, "http://pegasus.isi.edu/schema/DAX");
1852   dax__bufferliteral('\0', &bnext, "http://www.w3.org/2001/XMLSchema-instance");
1853   dax__bufferliteral('\0', &bnext, "http://pegasus.isi.edu/schema/DAX http://pegasus.isi.edu/schema/dax-2.1.xsd");
1854   dax__bufferliteral('\0', &bnext, "1.0");
1855   dax__bufferliteral('\0', &bnext, "0.0");
1856   dax__bufferliteral('\0', &bnext, "data");
1857   if(!dax__statenames) {dax__statenames= (const char **)calloc(IMPOSSIBLE,sizeof(char*));
1858   dax__statenames[PROLOG] = NULL;
1859   dax__statenames[DOCTYPE] = NULL;
1860   dax__statenames[EPILOG] = NULL;
1861   dax__statenames[INCOMMENT] = NULL;
1862   dax__statenames[INPI] = NULL;
1863   dax__statenames[VALUE1] = NULL;
1864   dax__statenames[VALUE2] = NULL;
1865   dax__statenames[CDATA] = NULL;
1866   dax__statenames[ROOT_dax__adag] = NULL;
1867   dax__statenames[AL_dax__adag] = NULL;
1868   dax__statenames[S_dax__adag] = "adag";
1869   dax__statenames[S_dax__adag_1] = "adag";
1870   dax__statenames[S_dax__adag_2] = "adag";
1871   dax__statenames[S_dax__adag_3] = "adag";
1872   dax__statenames[S_dax__adag_4] = "adag";
1873   dax__statenames[S_dax__adag_5] = "adag";
1874   dax__statenames[E_dax__adag] = "adag";
1875   dax__statenames[AL_dax__child] = NULL;
1876   dax__statenames[S_dax__child] = "child";
1877   dax__statenames[S_dax__child_1] = "child";
1878   dax__statenames[S_dax__child_2] = "child";
1879   dax__statenames[E_dax__child] = "child";
1880   dax__statenames[AL_dax__job] = NULL;
1881   dax__statenames[S_dax__job] = "job";
1882   dax__statenames[S_dax__job_1] = "job";
1883   dax__statenames[S_dax__job_2] = "job";
1884   dax__statenames[E_dax__job] = "job";
1885   dax__statenames[AL_dax__parent] = NULL;
1886   dax__statenames[E_dax__parent] = "parent";
1887   dax__statenames[AL_dax__uses] = NULL;
1888   dax__statenames[E_dax__uses] = "uses";
1889   }
1890
1891  /* COMMENTS and PIs: handled uniformly for efficiency. */
1892
1893         while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
1894                 {
1895                 yy_cp = (yy_c_buf_p);
1896
1897                 /* Support of dax_text. */
1898                 *yy_cp = (yy_hold_char);
1899
1900                 /* yy_bp points to the position in yy_ch_buf of the start of
1901                  * the current run.
1902                  */
1903                 yy_bp = yy_cp;
1904
1905                 yy_current_state = (yy_start);
1906 yy_match:
1907                 do
1908                         {
1909                         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1910                         if ( yy_accept[yy_current_state] )
1911                                 {
1912                                 (yy_last_accepting_state) = yy_current_state;
1913                                 (yy_last_accepting_cpos) = yy_cp;
1914                                 }
1915                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1916                                 {
1917                                 yy_current_state = (int) yy_def[yy_current_state];
1918                                 if ( yy_current_state >= 775 )
1919                                         yy_c = yy_meta[(unsigned int) yy_c];
1920                                 }
1921                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1922                         ++yy_cp;
1923                         }
1924                 while ( yy_base[yy_current_state] != 2135 );
1925
1926 yy_find_action:
1927                 yy_act = yy_accept[yy_current_state];
1928                 if ( yy_act == 0 )
1929                         { /* have to back up */
1930                         yy_cp = (yy_last_accepting_cpos);
1931                         yy_current_state = (yy_last_accepting_state);
1932                         yy_act = yy_accept[yy_current_state];
1933                         }
1934
1935                 YY_DO_BEFORE_ACTION;
1936
1937                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1938                         {
1939                         yy_size_t yyl;
1940                         for ( yyl = 0; yyl < dax_leng; ++yyl )
1941                                 if ( dax_text[yyl] == '\n' )
1942                                            
1943     dax_lineno++;
1944 ;
1945                         }
1946
1947 do_action:      /* This label is used only to access EOF actions. */
1948
1949                 switch ( yy_act )
1950         { /* beginning of action switch */
1951                         case 0: /* must back up */
1952                         /* undo the effects of YY_DO_BEFORE_ACTION */
1953                         *yy_cp = (yy_hold_char);
1954                         yy_cp = (yy_last_accepting_cpos);
1955                         yy_current_state = (yy_last_accepting_state);
1956                         goto yy_find_action;
1957
1958 case 1:
1959 YY_RULE_SETUP
1960 ENTER(INCOMMENT);
1961         YY_BREAK
1962 case 2:
1963 YY_RULE_SETUP
1964 ENTER(INPI);
1965         YY_BREAK
1966
1967 case 3:
1968 YY_RULE_SETUP
1969 LEAVE;
1970         YY_BREAK
1971 case 4:
1972 case 5:
1973 case 6:
1974 /* rule 6 can match eol */
1975 YY_RULE_SETUP
1976 SKIP;
1977         YY_BREAK
1978 case YY_STATE_EOF(INCOMMENT):
1979 FAIL("EOF in comment.");
1980         YY_BREAK
1981
1982 case 7:
1983 YY_RULE_SETUP
1984 LEAVE;
1985         YY_BREAK
1986 case 8:
1987 case 9:
1988 /* rule 9 can match eol */
1989 YY_RULE_SETUP
1990 SKIP;
1991         YY_BREAK
1992 case YY_STATE_EOF(INPI):
1993 FAIL("EOF in PI (processing instruction).");
1994         YY_BREAK
1995
1996 /* SPACES: skipped uniformly */
1997 case 10:
1998 /* rule 10 can match eol */
1999 YY_RULE_SETUP
2000 SKIP;
2001         YY_BREAK
2002 /* PROLOG: determine root element and process it. */
2003
2004 case 11:
2005 /* rule 11 can match eol */
2006 YY_RULE_SETUP
2007 SET(ROOT_dax__adag); 
2008         YY_BREAK
2009 case 12:
2010 /* rule 12 can match eol */
2011 YY_RULE_SETUP
2012 FAIL("Bad declaration %s.",dax_text);
2013         YY_BREAK
2014
2015 case 13:
2016 /* rule 13 can match eol */
2017 YY_RULE_SETUP
2018 SET(ROOT_dax__adag);
2019         YY_BREAK
2020 case 14:
2021 /* rule 14 can match eol */
2022 YY_RULE_SETUP
2023 FAIL("Bad declaration %s.",dax_text);
2024         YY_BREAK
2025 case 15:
2026 YY_RULE_SETUP
2027 FAIL("Unexpected character `%c' in prolog.", dax_text[0]);
2028         YY_BREAK
2029 case YY_STATE_EOF(PROLOG):
2030 case YY_STATE_EOF(DOCTYPE):
2031 FAIL("EOF in prolog.");
2032         YY_BREAK
2033
2034 /* RULES DERIVED FROM DTD. */
2035 /* <!-- Small DTD for DAX files. -->  */
2036 case 16:
2037 /* rule 16 can match eol */
2038 YY_RULE_SETUP
2039 FAIL("Starting tag <adag> is not allowed here.");
2040         YY_BREAK
2041 case 17:
2042 /* rule 17 can match eol */
2043 YY_RULE_SETUP
2044 {
2045   AX_dax__adag_childCount = 0;
2046   dax__adag_childCount_isset = 0;
2047   AX_dax__adag_count = 0;
2048   dax__adag_count_isset = 0;
2049   AX_dax__adag_fileCount = 0;
2050   dax__adag_fileCount_isset = 0;
2051   AX_dax__adag_index = 0;
2052   dax__adag_index_isset = 0;
2053   AX_dax__adag_jobCount = 0;
2054   dax__adag_jobCount_isset = 0;
2055   AX_dax__adag_name = 0;
2056   dax__adag_name_isset = 0;
2057   AX_dax__adag_version = 153;
2058   dax__adag_version_isset = 0;
2059   AX_dax__adag_xmlns = 1;
2060   dax__adag_xmlns_isset = 0;
2061   AX_dax__adag_xmlns_c_xsi = 35;
2062   dax__adag_xmlns_c_xsi_isset = 0;
2063   AX_dax__adag_xsi_c_schemaLocation = 77;
2064   dax__adag_xsi_c_schemaLocation_isset = 0;
2065   ENTER(AL_dax__adag); pushbuffer(0);
2066   }
2067         YY_BREAK
2068
2069 case 18:
2070 /* rule 18 can match eol */
2071 YY_RULE_SETUP
2072 if (dax__adag_childCount_isset != 0) {FAIL("Multiple definition of attribute childCount in <dax__adag>");} dax__adag_childCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_childCount);
2073         YY_BREAK
2074 case 19:
2075 /* rule 19 can match eol */
2076 YY_RULE_SETUP
2077 if (dax__adag_childCount_isset != 0) {FAIL("Multiple definition of attribute childCount in <dax__adag>");}  dax__adag_childCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_childCount);
2078         YY_BREAK
2079 case 20:
2080 /* rule 20 can match eol */
2081 YY_RULE_SETUP
2082 if (dax__adag_count_isset != 0) {FAIL("Multiple definition of attribute count in <dax__adag>");} dax__adag_count_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_count);
2083         YY_BREAK
2084 case 21:
2085 /* rule 21 can match eol */
2086 YY_RULE_SETUP
2087 if (dax__adag_count_isset != 0) {FAIL("Multiple definition of attribute count in <dax__adag>");}  dax__adag_count_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_count);
2088         YY_BREAK
2089 case 22:
2090 /* rule 22 can match eol */
2091 YY_RULE_SETUP
2092 if (dax__adag_fileCount_isset != 0) {FAIL("Multiple definition of attribute fileCount in <dax__adag>");} dax__adag_fileCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_fileCount);
2093         YY_BREAK
2094 case 23:
2095 /* rule 23 can match eol */
2096 YY_RULE_SETUP
2097 if (dax__adag_fileCount_isset != 0) {FAIL("Multiple definition of attribute fileCount in <dax__adag>");}  dax__adag_fileCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_fileCount);
2098         YY_BREAK
2099 case 24:
2100 /* rule 24 can match eol */
2101 YY_RULE_SETUP
2102 if (dax__adag_index_isset != 0) {FAIL("Multiple definition of attribute index in <dax__adag>");} dax__adag_index_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_index);
2103         YY_BREAK
2104 case 25:
2105 /* rule 25 can match eol */
2106 YY_RULE_SETUP
2107 if (dax__adag_index_isset != 0) {FAIL("Multiple definition of attribute index in <dax__adag>");}  dax__adag_index_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_index);
2108         YY_BREAK
2109 case 26:
2110 /* rule 26 can match eol */
2111 YY_RULE_SETUP
2112 if (dax__adag_jobCount_isset != 0) {FAIL("Multiple definition of attribute jobCount in <dax__adag>");} dax__adag_jobCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_jobCount);
2113         YY_BREAK
2114 case 27:
2115 /* rule 27 can match eol */
2116 YY_RULE_SETUP
2117 if (dax__adag_jobCount_isset != 0) {FAIL("Multiple definition of attribute jobCount in <dax__adag>");}  dax__adag_jobCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_jobCount);
2118         YY_BREAK
2119 case 28:
2120 /* rule 28 can match eol */
2121 YY_RULE_SETUP
2122 if (dax__adag_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__adag>");} dax__adag_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_name);
2123         YY_BREAK
2124 case 29:
2125 /* rule 29 can match eol */
2126 YY_RULE_SETUP
2127 if (dax__adag_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__adag>");}  dax__adag_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_name);
2128         YY_BREAK
2129 case 30:
2130 /* rule 30 can match eol */
2131 YY_RULE_SETUP
2132 if (dax__adag_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__adag>");} dax__adag_version_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_version);
2133         YY_BREAK
2134 case 31:
2135 /* rule 31 can match eol */
2136 YY_RULE_SETUP
2137 if (dax__adag_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__adag>");}  dax__adag_version_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_version);
2138         YY_BREAK
2139 case 32:
2140 /* rule 32 can match eol */
2141 YY_RULE_SETUP
2142 if (dax__adag_xmlns_isset != 0) {FAIL("Multiple definition of attribute xmlns in <dax__adag>");} dax__adag_xmlns_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns);
2143         YY_BREAK
2144 case 33:
2145 /* rule 33 can match eol */
2146 YY_RULE_SETUP
2147 if (dax__adag_xmlns_isset != 0) {FAIL("Multiple definition of attribute xmlns in <dax__adag>");}  dax__adag_xmlns_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns);
2148         YY_BREAK
2149 case 34:
2150 /* rule 34 can match eol */
2151 YY_RULE_SETUP
2152 if (dax__adag_xmlns_c_xsi_isset != 0) {FAIL("Multiple definition of attribute xmlns:xsi in <dax__adag>");} dax__adag_xmlns_c_xsi_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns_c_xsi);
2153         YY_BREAK
2154 case 35:
2155 /* rule 35 can match eol */
2156 YY_RULE_SETUP
2157 if (dax__adag_xmlns_c_xsi_isset != 0) {FAIL("Multiple definition of attribute xmlns:xsi in <dax__adag>");}  dax__adag_xmlns_c_xsi_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns_c_xsi);
2158         YY_BREAK
2159 case 36:
2160 /* rule 36 can match eol */
2161 YY_RULE_SETUP
2162 if (dax__adag_xsi_c_schemaLocation_isset != 0) {FAIL("Multiple definition of attribute xsi:schemaLocation in <dax__adag>");} dax__adag_xsi_c_schemaLocation_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation);
2163         YY_BREAK
2164 case 37:
2165 /* rule 37 can match eol */
2166 YY_RULE_SETUP
2167 if (dax__adag_xsi_c_schemaLocation_isset != 0) {FAIL("Multiple definition of attribute xsi:schemaLocation in <dax__adag>");}  dax__adag_xsi_c_schemaLocation_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation);
2168         YY_BREAK
2169 case 38:
2170 YY_RULE_SETUP
2171 {
2172   LEAVE; STag_dax__adag();dax__pcdata_ix = 0; ENTER(S_dax__adag);
2173  }
2174         YY_BREAK
2175 case 39:
2176 YY_RULE_SETUP
2177 {
2178   LEAVE; STag_dax__adag(); dax__pcdata_ix = 0; ETag_dax__adag(); popbuffer(); /* attribute */
2179   switch (YY_START) {
2180    case ROOT_dax__adag: SET(EPILOG); break;
2181   }
2182  }
2183         YY_BREAK
2184 case 40:
2185 YY_RULE_SETUP
2186 FAIL("Unexpected character `%c' in attribute list of adag element.", dax_text[0]);
2187         YY_BREAK
2188 case 41:
2189 YY_RULE_SETUP
2190 FAIL("Bad attribute `%s' in `adag' element start tag.",dax_text);
2191         YY_BREAK
2192 case YY_STATE_EOF(AL_dax__adag):
2193 FAIL("EOF in attribute list of `adag' element.");
2194         YY_BREAK
2195
2196 case 42:
2197 /* rule 42 can match eol */
2198 YY_RULE_SETUP
2199 {
2200   LEAVE;
2201   ETag_dax__adag();
2202   popbuffer(); /* attribute */
2203   switch (YY_START) {
2204    case ROOT_dax__adag: SET(EPILOG); break;
2205   }
2206  }
2207         YY_BREAK
2208 case 43:
2209 /* rule 43 can match eol */
2210 YY_RULE_SETUP
2211 FAIL("Unexpected end-tag `%s': `</adag>' expected.",dax_text);
2212         YY_BREAK
2213 case 44:
2214 YY_RULE_SETUP
2215 FAIL("Unexpected character `%c': `</adag>' expected.",dax_text[0]);
2216         YY_BREAK
2217 case YY_STATE_EOF(E_dax__adag):
2218 case YY_STATE_EOF(S_dax__adag):
2219 case YY_STATE_EOF(S_dax__adag_1):
2220 case YY_STATE_EOF(S_dax__adag_3):
2221 case YY_STATE_EOF(S_dax__adag_5):
2222 FAIL("Premature EOF: `</adag>' expected.");
2223         YY_BREAK
2224
2225 case 45:
2226 /* rule 45 can match eol */
2227 YY_RULE_SETUP
2228 FAIL("Starting tag <child> is not allowed here.");
2229         YY_BREAK
2230 case 46:
2231 /* rule 46 can match eol */
2232 YY_RULE_SETUP
2233 {
2234   AX_dax__child_ref = 0;
2235   dax__child_ref_isset = 0;
2236   ENTER(AL_dax__child); pushbuffer(0);
2237   }
2238         YY_BREAK
2239
2240 case 47:
2241 /* rule 47 can match eol */
2242 YY_RULE_SETUP
2243 if (dax__child_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__child>");} dax__child_ref_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__child_ref);
2244         YY_BREAK
2245 case 48:
2246 /* rule 48 can match eol */
2247 YY_RULE_SETUP
2248 if (dax__child_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__child>");}  dax__child_ref_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__child_ref);
2249         YY_BREAK
2250 case 49:
2251 YY_RULE_SETUP
2252 {
2253   if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element.");
2254   LEAVE; STag_dax__child();dax__pcdata_ix = 0; ENTER(S_dax__child);
2255  }
2256         YY_BREAK
2257 case 50:
2258 YY_RULE_SETUP
2259 {
2260   if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element.");
2261   LEAVE; STag_dax__child(); dax__pcdata_ix = 0; ETag_dax__child(); popbuffer(); /* attribute */
2262   switch (YY_START) {
2263    case S_dax__adag: case S_dax__adag_1: case S_dax__adag_3: case S_dax__adag_4: case S_dax__adag_5: SET(S_dax__adag_5); break;
2264   }
2265  }
2266         YY_BREAK
2267 case 51:
2268 YY_RULE_SETUP
2269 FAIL("Unexpected character `%c' in attribute list of child element.", dax_text[0]);
2270         YY_BREAK
2271 case 52:
2272 YY_RULE_SETUP
2273 FAIL("Bad attribute `%s' in `child' element start tag.",dax_text);
2274         YY_BREAK
2275 case YY_STATE_EOF(AL_dax__child):
2276 FAIL("EOF in attribute list of `child' element.");
2277         YY_BREAK
2278
2279 case 53:
2280 /* rule 53 can match eol */
2281 YY_RULE_SETUP
2282 {
2283   LEAVE;
2284   ETag_dax__child();
2285   popbuffer(); /* attribute */
2286   switch (YY_START) {
2287    case S_dax__adag: case S_dax__adag_1: case S_dax__adag_3: case S_dax__adag_4: case S_dax__adag_5: SET(S_dax__adag_5); break;
2288   }
2289  }
2290         YY_BREAK
2291 case 54:
2292 /* rule 54 can match eol */
2293 YY_RULE_SETUP
2294 FAIL("Unexpected end-tag `%s': `</child>' expected.",dax_text);
2295         YY_BREAK
2296 case 55:
2297 YY_RULE_SETUP
2298 FAIL("Unexpected character `%c': `</child>' expected.",dax_text[0]);
2299         YY_BREAK
2300 case YY_STATE_EOF(E_dax__child):
2301 case YY_STATE_EOF(S_dax__child):
2302 case YY_STATE_EOF(S_dax__child_2):
2303 FAIL("Premature EOF: `</child>' expected.");
2304         YY_BREAK
2305
2306 case 56:
2307 /* rule 56 can match eol */
2308 YY_RULE_SETUP
2309 FAIL("Starting tag <job> is not allowed here.");
2310         YY_BREAK
2311 case 57:
2312 /* rule 57 can match eol */
2313 YY_RULE_SETUP
2314 {
2315   AX_dax__job_id = 0;
2316   dax__job_id_isset = 0;
2317   AX_dax__job_level = 0;
2318   dax__job_level_isset = 0;
2319   AX_dax__job_name = 0;
2320   dax__job_name_isset = 0;
2321   AX_dax__job_namespace = 0;
2322   dax__job_namespace_isset = 0;
2323   AX_dax__job_runtime = 0;
2324   dax__job_runtime_isset = 0;
2325   AX_dax__job_version = 157;
2326   dax__job_version_isset = 0;
2327   ENTER(AL_dax__job); pushbuffer(0);
2328   }
2329         YY_BREAK
2330
2331 case 58:
2332 /* rule 58 can match eol */
2333 YY_RULE_SETUP
2334 if (dax__job_id_isset != 0) {FAIL("Multiple definition of attribute id in <dax__job>");} dax__job_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_id);
2335         YY_BREAK
2336 case 59:
2337 /* rule 59 can match eol */
2338 YY_RULE_SETUP
2339 if (dax__job_id_isset != 0) {FAIL("Multiple definition of attribute id in <dax__job>");}  dax__job_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_id);
2340         YY_BREAK
2341 case 60:
2342 /* rule 60 can match eol */
2343 YY_RULE_SETUP
2344 if (dax__job_level_isset != 0) {FAIL("Multiple definition of attribute level in <dax__job>");} dax__job_level_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_level);
2345         YY_BREAK
2346 case 61:
2347 /* rule 61 can match eol */
2348 YY_RULE_SETUP
2349 if (dax__job_level_isset != 0) {FAIL("Multiple definition of attribute level in <dax__job>");}  dax__job_level_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_level);
2350         YY_BREAK
2351 case 62:
2352 /* rule 62 can match eol */
2353 YY_RULE_SETUP
2354 if (dax__job_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__job>");} dax__job_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_name);
2355         YY_BREAK
2356 case 63:
2357 /* rule 63 can match eol */
2358 YY_RULE_SETUP
2359 if (dax__job_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__job>");}  dax__job_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_name);
2360         YY_BREAK
2361 case 64:
2362 /* rule 64 can match eol */
2363 YY_RULE_SETUP
2364 if (dax__job_namespace_isset != 0) {FAIL("Multiple definition of attribute namespace in <dax__job>");} dax__job_namespace_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_namespace);
2365         YY_BREAK
2366 case 65:
2367 /* rule 65 can match eol */
2368 YY_RULE_SETUP
2369 if (dax__job_namespace_isset != 0) {FAIL("Multiple definition of attribute namespace in <dax__job>");}  dax__job_namespace_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_namespace);
2370         YY_BREAK
2371 case 66:
2372 /* rule 66 can match eol */
2373 YY_RULE_SETUP
2374 if (dax__job_runtime_isset != 0) {FAIL("Multiple definition of attribute runtime in <dax__job>");} dax__job_runtime_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_runtime);
2375         YY_BREAK
2376 case 67:
2377 /* rule 67 can match eol */
2378 YY_RULE_SETUP
2379 if (dax__job_runtime_isset != 0) {FAIL("Multiple definition of attribute runtime in <dax__job>");}  dax__job_runtime_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_runtime);
2380         YY_BREAK
2381 case 68:
2382 /* rule 68 can match eol */
2383 YY_RULE_SETUP
2384 if (dax__job_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__job>");} dax__job_version_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_version);
2385         YY_BREAK
2386 case 69:
2387 /* rule 69 can match eol */
2388 YY_RULE_SETUP
2389 if (dax__job_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__job>");}  dax__job_version_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_version);
2390         YY_BREAK
2391 case 70:
2392 YY_RULE_SETUP
2393 {
2394   if (!AX_dax__job_id) FAIL("Required attribute `id' not set for `job' element.");
2395   if (!AX_dax__job_name) FAIL("Required attribute `name' not set for `job' element.");
2396   if (!AX_dax__job_runtime) FAIL("Required attribute `runtime' not set for `job' element.");
2397   LEAVE; STag_dax__job();dax__pcdata_ix = 0; ENTER(S_dax__job);
2398  }
2399         YY_BREAK
2400 case 71:
2401 YY_RULE_SETUP
2402 {
2403   if (!AX_dax__job_id) FAIL("Required attribute `id' not set for `job' element.");
2404   if (!AX_dax__job_name) FAIL("Required attribute `name' not set for `job' element.");
2405   if (!AX_dax__job_runtime) FAIL("Required attribute `runtime' not set for `job' element.");
2406   LEAVE; STag_dax__job(); dax__pcdata_ix = 0; ETag_dax__job(); popbuffer(); /* attribute */
2407   switch (YY_START) {
2408    case S_dax__adag: case S_dax__adag_2: case S_dax__adag_3: SET(S_dax__adag_3); break;
2409   }
2410  }
2411         YY_BREAK
2412 case 72:
2413 YY_RULE_SETUP
2414 FAIL("Unexpected character `%c' in attribute list of job element.", dax_text[0]);
2415         YY_BREAK
2416 case 73:
2417 YY_RULE_SETUP
2418 FAIL("Bad attribute `%s' in `job' element start tag.",dax_text);
2419         YY_BREAK
2420 case YY_STATE_EOF(AL_dax__job):
2421 FAIL("EOF in attribute list of `job' element.");
2422         YY_BREAK
2423
2424 case 74:
2425 /* rule 74 can match eol */
2426 YY_RULE_SETUP
2427 {
2428   LEAVE;
2429   ETag_dax__job();
2430   popbuffer(); /* attribute */
2431   switch (YY_START) {
2432    case S_dax__adag: case S_dax__adag_2: case S_dax__adag_3: SET(S_dax__adag_3); break;
2433   }
2434  }
2435         YY_BREAK
2436 case 75:
2437 /* rule 75 can match eol */
2438 YY_RULE_SETUP
2439 FAIL("Unexpected end-tag `%s': `</job>' expected.",dax_text);
2440         YY_BREAK
2441 case 76:
2442 YY_RULE_SETUP
2443 FAIL("Unexpected character `%c': `</job>' expected.",dax_text[0]);
2444         YY_BREAK
2445 case YY_STATE_EOF(E_dax__job):
2446 case YY_STATE_EOF(S_dax__job):
2447 case YY_STATE_EOF(S_dax__job_2):
2448 FAIL("Premature EOF: `</job>' expected.");
2449         YY_BREAK
2450
2451 case 77:
2452 /* rule 77 can match eol */
2453 YY_RULE_SETUP
2454 FAIL("Starting tag <parent> is not allowed here.");
2455         YY_BREAK
2456 case 78:
2457 /* rule 78 can match eol */
2458 YY_RULE_SETUP
2459 {
2460   AX_dax__parent_ref = 0;
2461   dax__parent_ref_isset = 0;
2462   ENTER(AL_dax__parent); pushbuffer(0);
2463   }
2464         YY_BREAK
2465
2466 case 79:
2467 /* rule 79 can match eol */
2468 YY_RULE_SETUP
2469 if (dax__parent_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__parent>");} dax__parent_ref_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__parent_ref);
2470         YY_BREAK
2471 case 80:
2472 /* rule 80 can match eol */
2473 YY_RULE_SETUP
2474 if (dax__parent_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__parent>");}  dax__parent_ref_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__parent_ref);
2475         YY_BREAK
2476 case 81:
2477 YY_RULE_SETUP
2478 {
2479   if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element.");
2480   LEAVE; STag_dax__parent();dax__pcdata_ix = 0; ENTER(E_dax__parent);
2481  }
2482         YY_BREAK
2483 case 82:
2484 YY_RULE_SETUP
2485 {
2486   if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element.");
2487   LEAVE; STag_dax__parent(); dax__pcdata_ix = 0; ETag_dax__parent(); popbuffer(); /* attribute */
2488   switch (YY_START) {
2489    case S_dax__child: case S_dax__child_1: case S_dax__child_2: SET(S_dax__child_2); break;
2490   }
2491  }
2492         YY_BREAK
2493 case 83:
2494 YY_RULE_SETUP
2495 FAIL("Unexpected character `%c' in attribute list of parent element.", dax_text[0]);
2496         YY_BREAK
2497 case 84:
2498 YY_RULE_SETUP
2499 FAIL("Bad attribute `%s' in `parent' element start tag.",dax_text);
2500         YY_BREAK
2501 case YY_STATE_EOF(AL_dax__parent):
2502 FAIL("EOF in attribute list of `parent' element.");
2503         YY_BREAK
2504
2505 case 85:
2506 /* rule 85 can match eol */
2507 YY_RULE_SETUP
2508 {
2509   LEAVE;
2510   ETag_dax__parent();
2511   popbuffer(); /* attribute */
2512   switch (YY_START) {
2513    case S_dax__child: case S_dax__child_1: case S_dax__child_2: SET(S_dax__child_2); break;
2514   }
2515  }
2516         YY_BREAK
2517 case 86:
2518 /* rule 86 can match eol */
2519 YY_RULE_SETUP
2520 FAIL("Unexpected end-tag `%s': `</parent>' expected.",dax_text);
2521         YY_BREAK
2522 case 87:
2523 YY_RULE_SETUP
2524 FAIL("Unexpected character `%c': `</parent>' expected.",dax_text[0]);
2525         YY_BREAK
2526 case YY_STATE_EOF(E_dax__parent):
2527 FAIL("Premature EOF: `</parent>' expected.");
2528         YY_BREAK
2529
2530 /* <!-- ignored -->
2531   * <!-- ignored -->  */
2532 case 88:
2533 /* rule 88 can match eol */
2534 YY_RULE_SETUP
2535 FAIL("Starting tag <uses> is not allowed here.");
2536         YY_BREAK
2537 case 89:
2538 /* rule 89 can match eol */
2539 YY_RULE_SETUP
2540 {
2541   AX_dax__uses_file = 0;
2542   dax__uses_file_isset = 0;
2543   AX_dax__uses_link = AU_dax__uses_link;
2544   dax__uses_link_isset = 0;
2545   AX_dax__uses_optional = A_dax__uses_optional_false;
2546   dax__uses_optional_isset = 0;
2547   AX_dax__uses_register = A_dax__uses_register_true;
2548   dax__uses_register_isset = 0;
2549   AX_dax__uses_size = 0;
2550   dax__uses_size_isset = 0;
2551   AX_dax__uses_transfer = A_dax__uses_transfer_true;
2552   dax__uses_transfer_isset = 0;
2553   AX_dax__uses_type = 161;
2554   dax__uses_type_isset = 0;
2555   ENTER(AL_dax__uses); pushbuffer(0);
2556   }
2557         YY_BREAK
2558
2559 case 90:
2560 /* rule 90 can match eol */
2561 YY_RULE_SETUP
2562 if (dax__uses_file_isset != 0) {FAIL("Multiple definition of attribute file in <dax__uses>");} dax__uses_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_file);
2563         YY_BREAK
2564 case 91:
2565 /* rule 91 can match eol */
2566 YY_RULE_SETUP
2567 if (dax__uses_file_isset != 0) {FAIL("Multiple definition of attribute file in <dax__uses>");}  dax__uses_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_file);
2568         YY_BREAK
2569 case 92:
2570 /* rule 92 can match eol */
2571 case 93:
2572 /* rule 93 can match eol */
2573 YY_RULE_SETUP
2574 A_dax__uses_link = A_dax__uses_link_input;
2575         YY_BREAK
2576 case 94:
2577 /* rule 94 can match eol */
2578 case 95:
2579 /* rule 95 can match eol */
2580 YY_RULE_SETUP
2581 A_dax__uses_link = A_dax__uses_link_output;
2582         YY_BREAK
2583 case 96:
2584 /* rule 96 can match eol */
2585 case 97:
2586 /* rule 97 can match eol */
2587 YY_RULE_SETUP
2588 A_dax__uses_optional = A_dax__uses_optional_false;
2589         YY_BREAK
2590 case 98:
2591 /* rule 98 can match eol */
2592 case 99:
2593 /* rule 99 can match eol */
2594 YY_RULE_SETUP
2595 A_dax__uses_optional = A_dax__uses_optional_true;
2596         YY_BREAK
2597 case 100:
2598 /* rule 100 can match eol */
2599 case 101:
2600 /* rule 101 can match eol */
2601 YY_RULE_SETUP
2602 A_dax__uses_register = A_dax__uses_register_false;
2603         YY_BREAK
2604 case 102:
2605 /* rule 102 can match eol */
2606 case 103:
2607 /* rule 103 can match eol */
2608 YY_RULE_SETUP
2609 A_dax__uses_register = A_dax__uses_register_true;
2610         YY_BREAK
2611 case 104:
2612 /* rule 104 can match eol */
2613 YY_RULE_SETUP
2614 if (dax__uses_size_isset != 0) {FAIL("Multiple definition of attribute size in <dax__uses>");} dax__uses_size_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_size);
2615         YY_BREAK
2616 case 105:
2617 /* rule 105 can match eol */
2618 YY_RULE_SETUP
2619 if (dax__uses_size_isset != 0) {FAIL("Multiple definition of attribute size in <dax__uses>");}  dax__uses_size_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_size);
2620         YY_BREAK
2621 case 106:
2622 /* rule 106 can match eol */
2623 case 107:
2624 /* rule 107 can match eol */
2625 YY_RULE_SETUP
2626 A_dax__uses_transfer = A_dax__uses_transfer_false;
2627         YY_BREAK
2628 case 108:
2629 /* rule 108 can match eol */
2630 case 109:
2631 /* rule 109 can match eol */
2632 YY_RULE_SETUP
2633 A_dax__uses_transfer = A_dax__uses_transfer_true;
2634         YY_BREAK
2635 case 110:
2636 /* rule 110 can match eol */
2637 YY_RULE_SETUP
2638 if (dax__uses_type_isset != 0) {FAIL("Multiple definition of attribute type in <dax__uses>");} dax__uses_type_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_type);
2639         YY_BREAK
2640 case 111:
2641 /* rule 111 can match eol */
2642 YY_RULE_SETUP
2643 if (dax__uses_type_isset != 0) {FAIL("Multiple definition of attribute type in <dax__uses>");}  dax__uses_type_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_type);
2644         YY_BREAK
2645 case 112:
2646 YY_RULE_SETUP
2647 {
2648   if (!AX_dax__uses_file) FAIL("Required attribute `file' not set for `uses' element.");
2649   if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element.");
2650   LEAVE; STag_dax__uses();dax__pcdata_ix = 0; ENTER(E_dax__uses);
2651  }
2652         YY_BREAK
2653 case 113:
2654 YY_RULE_SETUP
2655 {
2656   if (!AX_dax__uses_file) FAIL("Required attribute `file' not set for `uses' element.");
2657   if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element.");
2658   LEAVE; STag_dax__uses(); dax__pcdata_ix = 0; ETag_dax__uses(); popbuffer(); /* attribute */
2659   switch (YY_START) {
2660    case S_dax__job: case S_dax__job_1: case S_dax__job_2: SET(S_dax__job_2); break;
2661   }
2662  }
2663         YY_BREAK
2664 case 114:
2665 YY_RULE_SETUP
2666 FAIL("Unexpected character `%c' in attribute list of uses element.", dax_text[0]);
2667         YY_BREAK
2668 case 115:
2669 YY_RULE_SETUP
2670 FAIL("Bad attribute `%s' in `uses' element start tag.",dax_text);
2671         YY_BREAK
2672 case YY_STATE_EOF(AL_dax__uses):
2673 FAIL("EOF in attribute list of `uses' element.");
2674         YY_BREAK
2675
2676 case 116:
2677 /* rule 116 can match eol */
2678 YY_RULE_SETUP
2679 {
2680   LEAVE;
2681   ETag_dax__uses();
2682   popbuffer(); /* attribute */
2683   switch (YY_START) {
2684    case S_dax__job: case S_dax__job_1: case S_dax__job_2: SET(S_dax__job_2); break;
2685   }
2686  }
2687         YY_BREAK
2688 case 117:
2689 /* rule 117 can match eol */
2690 YY_RULE_SETUP
2691 FAIL("Unexpected end-tag `%s': `</uses>' expected.",dax_text);
2692         YY_BREAK
2693 case 118:
2694 YY_RULE_SETUP
2695 FAIL("Unexpected character `%c': `</uses>' expected.",dax_text[0]);
2696         YY_BREAK
2697 case YY_STATE_EOF(E_dax__uses):
2698 FAIL("Premature EOF: `</uses>' expected.");
2699         YY_BREAK
2700
2701 /* EPILOG: after the root element. */
2702
2703 case 119:
2704 YY_RULE_SETUP
2705 {SET(PROLOG); yyless(0); CLEANUP; return -1;}
2706         YY_BREAK
2707 case YY_STATE_EOF(EPILOG):
2708 SUCCEED;
2709         YY_BREAK
2710
2711 /* CHARACTER DATA. */
2712
2713 /* Non-defined standard entities... */
2714 case 120:
2715 YY_RULE_SETUP
2716 BUFFERPUTC('&');
2717         YY_BREAK
2718 case 121:
2719 YY_RULE_SETUP
2720 BUFFERPUTC('<');
2721         YY_BREAK
2722 case 122:
2723 YY_RULE_SETUP
2724 BUFFERPUTC('>');
2725         YY_BREAK
2726 case 123:
2727 YY_RULE_SETUP
2728 BUFFERPUTC('\'');
2729         YY_BREAK
2730 case 124:
2731 YY_RULE_SETUP
2732 BUFFERPUTC('"');
2733         YY_BREAK
2734 /* Character entities. */
2735 case 125:
2736 YY_RULE_SETUP
2737 BUFFERPUTC((unsigned char)atoi(dax_text+2));
2738         YY_BREAK
2739 case 126:
2740 YY_RULE_SETUP
2741 BUFFERPUTC((unsigned char)strtol(dax_text+3,NULL,16));
2742         YY_BREAK
2743
2744 case 127:
2745 /* rule 127 can match eol */
2746 case 128:
2747 /* rule 128 can match eol */
2748 case 129:
2749 /* rule 129 can match eol */
2750 case 130:
2751 /* rule 130 can match eol */
2752 YY_RULE_SETUP
2753 BUFFERPUTC('\n');
2754         YY_BREAK
2755
2756 case 131:
2757 YY_RULE_SETUP
2758 ENTER(CDATA);
2759         YY_BREAK
2760 case 132:
2761 YY_RULE_SETUP
2762 FAIL("Unexpected `]""]>' in character data.");
2763         YY_BREAK
2764
2765 case 133:
2766 YY_RULE_SETUP
2767 BUFFERDONE; LEAVE;
2768         YY_BREAK
2769 case YY_STATE_EOF(VALUE1):
2770 FAIL("EOF in literal (\"'\" expected).");
2771         YY_BREAK
2772
2773 case 134:
2774 YY_RULE_SETUP
2775 BUFFERDONE; LEAVE;
2776         YY_BREAK
2777 case YY_STATE_EOF(VALUE2):
2778 FAIL("EOF in literal (`\"' expected).");
2779         YY_BREAK
2780
2781 case 135:
2782 /* rule 135 can match eol */
2783 YY_RULE_SETUP
2784 BUFFERPUTC(dax_text[0]);
2785         YY_BREAK
2786 case 136:
2787 YY_RULE_SETUP
2788 FAIL("Spurious `%c' in character data.",dax_text[0]);
2789         YY_BREAK
2790
2791 case 137:
2792 YY_RULE_SETUP
2793 LEAVE;
2794         YY_BREAK
2795 /* "]""]"               BUFFERPUTC(dax_text[0]); BUFFERPUTC(dax_text[1]); */
2796 case 138:
2797 YY_RULE_SETUP
2798 BUFFERPUTC(dax_text[0]);
2799         YY_BREAK
2800 case YY_STATE_EOF(CDATA):
2801 FAIL("EOF in CDATA section.");
2802         YY_BREAK
2803
2804 /* Impossible rules to avoid warnings from flex(1). */
2805 /* Ideally, this should be replaced by code in flexml.pl that
2806     generates just the states not covered by other rules. */
2807
2808 case 139:
2809 /* rule 139 can match eol */
2810 YY_RULE_SETUP
2811 FAIL("Syntax error on character `%c'.", dax_text[0]);
2812         YY_BREAK
2813
2814 case 140:
2815 YY_RULE_SETUP
2816 ECHO;
2817         YY_BREAK
2818 case YY_STATE_EOF(INITIAL):
2819 case YY_STATE_EOF(ROOT_dax__adag):
2820 case YY_STATE_EOF(S_dax__adag_2):
2821 case YY_STATE_EOF(S_dax__adag_4):
2822 case YY_STATE_EOF(S_dax__child_1):
2823 case YY_STATE_EOF(S_dax__job_1):
2824 case YY_STATE_EOF(IMPOSSIBLE):
2825         yyterminate();
2826
2827         case YY_END_OF_BUFFER:
2828                 {
2829                 /* Amount of text matched not including the EOB char. */
2830                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2831
2832                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2833                 *yy_cp = (yy_hold_char);
2834                 YY_RESTORE_YY_MORE_OFFSET
2835
2836                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2837                         {
2838                         /* We're scanning a new file or input source.  It's
2839                          * possible that this happened because the user
2840                          * just pointed dax_in at a new source and called
2841                          * dax_lex().  If so, then we have to assure
2842                          * consistency between YY_CURRENT_BUFFER and our
2843                          * globals.  Here is the right place to do so, because
2844                          * this is the first action (other than possibly a
2845                          * back-up) that will match for the new input source.
2846                          */
2847                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2848                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = dax_in;
2849                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2850                         }
2851
2852                 /* Note that here we test for yy_c_buf_p "<=" to the position
2853                  * of the first EOB in the buffer, since yy_c_buf_p will
2854                  * already have been incremented past the NUL character
2855                  * (since all states make transitions on EOB to the
2856                  * end-of-buffer state).  Contrast this with the test
2857                  * in input().
2858                  */
2859                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2860                         { /* This was really a NUL. */
2861                         yy_state_type yy_next_state;
2862
2863                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2864
2865                         yy_current_state = yy_get_previous_state(  );
2866
2867                         /* Okay, we're now positioned to make the NUL
2868                          * transition.  We couldn't have
2869                          * yy_get_previous_state() go ahead and do it
2870                          * for us because it doesn't know how to deal
2871                          * with the possibility of jamming (and we don't
2872                          * want to build jamming into it because then it
2873                          * will run more slowly).
2874                          */
2875
2876                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2877
2878                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2879
2880                         if ( yy_next_state )
2881                                 {
2882                                 /* Consume the NUL. */
2883                                 yy_cp = ++(yy_c_buf_p);
2884                                 yy_current_state = yy_next_state;
2885                                 goto yy_match;
2886                                 }
2887
2888                         else
2889                                 {
2890                                 yy_cp = (yy_c_buf_p);
2891                                 goto yy_find_action;
2892                                 }
2893                         }
2894
2895                 else switch ( yy_get_next_buffer(  ) )
2896                         {
2897                         case EOB_ACT_END_OF_FILE:
2898                                 {
2899                                 (yy_did_buffer_switch_on_eof) = 0;
2900
2901                                 if ( dax_wrap( ) )
2902                                         {
2903                                         /* Note: because we've taken care in
2904                                          * yy_get_next_buffer() to have set up
2905                                          * dax_text, we can now set up
2906                                          * yy_c_buf_p so that if some total
2907                                          * hoser (like flex itself) wants to
2908                                          * call the scanner after we return the
2909                                          * YY_NULL, it'll still work - another
2910                                          * YY_NULL will get returned.
2911                                          */
2912                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2913
2914                                         yy_act = YY_STATE_EOF(YY_START);
2915                                         goto do_action;
2916                                         }
2917
2918                                 else
2919                                         {
2920                                         if ( ! (yy_did_buffer_switch_on_eof) )
2921                                                 YY_NEW_FILE;
2922                                         }
2923                                 break;
2924                                 }
2925
2926                         case EOB_ACT_CONTINUE_SCAN:
2927                                 (yy_c_buf_p) =
2928                                         (yytext_ptr) + yy_amount_of_matched_text;
2929
2930                                 yy_current_state = yy_get_previous_state(  );
2931
2932                                 yy_cp = (yy_c_buf_p);
2933                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2934                                 goto yy_match;
2935
2936                         case EOB_ACT_LAST_MATCH:
2937                                 (yy_c_buf_p) =
2938                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2939
2940                                 yy_current_state = yy_get_previous_state(  );
2941
2942                                 yy_cp = (yy_c_buf_p);
2943                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2944                                 goto yy_find_action;
2945                         }
2946                 break;
2947                 }
2948
2949         default:
2950                 YY_FATAL_ERROR(
2951                         "fatal flex scanner internal error--no action found" );
2952         } /* end of action switch */
2953                 } /* end of scanning one token */
2954         } /* end of user's declarations */
2955 } /* end of dax_lex */
2956
2957 /* yy_get_next_buffer - try to read in a new buffer
2958  *
2959  * Returns a code representing an action:
2960  *      EOB_ACT_LAST_MATCH -
2961  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2962  *      EOB_ACT_END_OF_FILE - end of file
2963  */
2964 static int yy_get_next_buffer (void)
2965 {
2966         char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2967         char *source = (yytext_ptr);
2968         yy_size_t number_to_move, i;
2969         int ret_val;
2970
2971         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2972                 YY_FATAL_ERROR(
2973                 "fatal flex scanner internal error--end of buffer missed" );
2974
2975         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2976                 { /* Don't try to fill the buffer, so this is an EOF. */
2977                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2978                         {
2979                         /* We matched a single character, the EOB, so
2980                          * treat this as a final EOF.
2981                          */
2982                         return EOB_ACT_END_OF_FILE;
2983                         }
2984
2985                 else
2986                         {
2987                         /* We matched some text prior to the EOB, first
2988                          * process it.
2989                          */
2990                         return EOB_ACT_LAST_MATCH;
2991                         }
2992                 }
2993
2994         /* Try to read more data. */
2995
2996         /* First move last chars to start of buffer. */
2997         number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2998
2999         for ( i = 0; i < number_to_move; ++i )
3000                 *(dest++) = *(source++);
3001
3002         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
3003                 /* don't do the read, it's not guaranteed to return an EOF,
3004                  * just force an EOF
3005                  */
3006                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
3007
3008         else
3009                 {
3010                         yy_size_t num_to_read =
3011                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
3012
3013                 while ( num_to_read <= 0 )
3014                         { /* Not enough room in the buffer - grow it. */
3015
3016                         /* just a shorter name for the current buffer */
3017                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
3018
3019                         int yy_c_buf_p_offset =
3020                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
3021
3022                         if ( b->yy_is_our_buffer )
3023                                 {
3024                                 yy_size_t new_size = b->yy_buf_size * 2;
3025
3026                                 if ( new_size <= 0 )
3027                                         b->yy_buf_size += b->yy_buf_size / 8;
3028                                 else
3029                                         b->yy_buf_size *= 2;
3030
3031                                 b->yy_ch_buf = (char *)
3032                                         /* Include room in for 2 EOB chars. */
3033                                         dax_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
3034                                 }
3035                         else
3036                                 /* Can't grow it, we don't own it. */
3037                                 b->yy_ch_buf = 0;
3038
3039                         if ( ! b->yy_ch_buf )
3040                                 YY_FATAL_ERROR(
3041                                 "fatal error - scanner input buffer overflow" );
3042
3043                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
3044
3045                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
3046                                                 number_to_move - 1;
3047
3048                         }
3049
3050                 if ( num_to_read > YY_READ_BUF_SIZE )
3051                         num_to_read = YY_READ_BUF_SIZE;
3052
3053                 /* Read in more data. */
3054                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
3055                         (yy_n_chars), num_to_read );
3056
3057                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3058                 }
3059
3060         if ( (yy_n_chars) == 0 )
3061                 {
3062                 if ( number_to_move == YY_MORE_ADJ )
3063                         {
3064                         ret_val = EOB_ACT_END_OF_FILE;
3065                         dax_restart(dax_in  );
3066                         }
3067
3068                 else
3069                         {
3070                         ret_val = EOB_ACT_LAST_MATCH;
3071                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3072                                 YY_BUFFER_EOF_PENDING;
3073                         }
3074                 }
3075
3076         else
3077                 ret_val = EOB_ACT_CONTINUE_SCAN;
3078
3079         if ((unsigned int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
3080                 /* Extend the array by 50%, plus the number we really need. */
3081                 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
3082                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) dax_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
3083                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3084                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3085         }
3086
3087         (yy_n_chars) += number_to_move;
3088         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
3089         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
3090
3091         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3092
3093         return ret_val;
3094 }
3095
3096 /* yy_get_previous_state - get the state just before the EOB char was reached */
3097
3098     static yy_state_type yy_get_previous_state (void)
3099 {
3100         yy_state_type yy_current_state;
3101         char *yy_cp;
3102     
3103         yy_current_state = (yy_start);
3104
3105         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3106                 {
3107                 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
3108                 if ( yy_accept[yy_current_state] )
3109                         {
3110                         (yy_last_accepting_state) = yy_current_state;
3111                         (yy_last_accepting_cpos) = yy_cp;
3112                         }
3113                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3114                         {
3115                         yy_current_state = (int) yy_def[yy_current_state];
3116                         if ( yy_current_state >= 775 )
3117                                 yy_c = yy_meta[(unsigned int) yy_c];
3118                         }
3119                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3120                 }
3121
3122         return yy_current_state;
3123 }
3124
3125 /* yy_try_NUL_trans - try to make a transition on the NUL character
3126  *
3127  * synopsis
3128  *      next_state = yy_try_NUL_trans( current_state );
3129  */
3130     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
3131 {
3132         int yy_is_jam;
3133         char *yy_cp = (yy_c_buf_p);
3134
3135         YY_CHAR yy_c = 1;
3136         if ( yy_accept[yy_current_state] )
3137                 {
3138                 (yy_last_accepting_state) = yy_current_state;
3139                 (yy_last_accepting_cpos) = yy_cp;
3140                 }
3141         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3142                 {
3143                 yy_current_state = (int) yy_def[yy_current_state];
3144                 if ( yy_current_state >= 775 )
3145                         yy_c = yy_meta[(unsigned int) yy_c];
3146                 }
3147         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3148         yy_is_jam = (yy_current_state == 774);
3149
3150                 return yy_is_jam ? 0 : yy_current_state;
3151 }
3152
3153 #ifndef YY_NO_UNPUT
3154
3155 #endif
3156
3157 #ifndef YY_NO_INPUT
3158 #ifdef __cplusplus
3159     static int yyinput (void)
3160 #else
3161     static int input  (void)
3162 #endif
3163
3164 {
3165         int c;
3166     
3167         *(yy_c_buf_p) = (yy_hold_char);
3168
3169         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
3170                 {
3171                 /* yy_c_buf_p now points to the character we want to return.
3172                  * If this occurs *before* the EOB characters, then it's a
3173                  * valid NUL; if not, then we've hit the end of the buffer.
3174                  */
3175                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3176                         /* This was really a NUL. */
3177                         *(yy_c_buf_p) = '\0';
3178
3179                 else
3180                         { /* need more input */
3181                         yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
3182                         ++(yy_c_buf_p);
3183
3184                         switch ( yy_get_next_buffer(  ) )
3185                                 {
3186                                 case EOB_ACT_LAST_MATCH:
3187                                         /* This happens because yy_g_n_b()
3188                                          * sees that we've accumulated a
3189                                          * token and flags that we need to
3190                                          * try matching the token before
3191                                          * proceeding.  But for input(),
3192                                          * there's no matching to consider.
3193                                          * So convert the EOB_ACT_LAST_MATCH
3194                                          * to EOB_ACT_END_OF_FILE.
3195                                          */
3196
3197                                         /* Reset buffer status. */
3198                                         dax_restart(dax_in );
3199
3200                                         /*FALLTHROUGH*/
3201
3202                                 case EOB_ACT_END_OF_FILE:
3203                                         {
3204                                         if ( dax_wrap( ) )
3205                                                 return EOF;
3206
3207                                         if ( ! (yy_did_buffer_switch_on_eof) )
3208                                                 YY_NEW_FILE;
3209 #ifdef __cplusplus
3210                                         return yyinput();
3211 #else
3212                                         return input();
3213 #endif
3214                                         }
3215
3216                                 case EOB_ACT_CONTINUE_SCAN:
3217                                         (yy_c_buf_p) = (yytext_ptr) + offset;
3218                                         break;
3219                                 }
3220                         }
3221                 }
3222
3223         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
3224         *(yy_c_buf_p) = '\0';   /* preserve dax_text */
3225         (yy_hold_char) = *++(yy_c_buf_p);
3226
3227         if ( c == '\n' )
3228                    
3229     dax_lineno++;
3230 ;
3231
3232         return c;
3233 }
3234 #endif  /* ifndef YY_NO_INPUT */
3235
3236 /** Immediately switch to a different input stream.
3237  * @param input_file A readable stream.
3238  * 
3239  * @note This function does not reset the start condition to @c INITIAL .
3240  */
3241     void dax_restart  (FILE * input_file )
3242 {
3243     
3244         if ( ! YY_CURRENT_BUFFER ){
3245         dax_ensure_buffer_stack ();
3246                 YY_CURRENT_BUFFER_LVALUE =
3247             dax__create_buffer(dax_in,YY_BUF_SIZE );
3248         }
3249
3250         dax__init_buffer(YY_CURRENT_BUFFER,input_file );
3251         dax__load_buffer_state( );
3252 }
3253
3254 /** Switch to a different input buffer.
3255  * @param new_buffer The new input buffer.
3256  * 
3257  */
3258     void dax__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
3259 {
3260     
3261         /* TODO. We should be able to replace this entire function body
3262          * with
3263          *              dax_pop_buffer_state();
3264          *              dax_push_buffer_state(new_buffer);
3265      */
3266         dax_ensure_buffer_stack ();
3267         if ( YY_CURRENT_BUFFER == new_buffer )
3268                 return;
3269
3270         if ( YY_CURRENT_BUFFER )
3271                 {
3272                 /* Flush out information for old buffer. */
3273                 *(yy_c_buf_p) = (yy_hold_char);
3274                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3275                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3276                 }
3277
3278         YY_CURRENT_BUFFER_LVALUE = new_buffer;
3279         dax__load_buffer_state( );
3280
3281         /* We don't actually know whether we did this switch during
3282          * EOF (dax_wrap()) processing, but the only time this flag
3283          * is looked at is after dax_wrap() is called, so it's safe
3284          * to go ahead and always set it.
3285          */
3286         (yy_did_buffer_switch_on_eof) = 1;
3287 }
3288
3289 static void dax__load_buffer_state  (void)
3290 {
3291         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3292         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
3293         dax_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
3294         (yy_hold_char) = *(yy_c_buf_p);
3295 }
3296
3297 /** Allocate and initialize an input buffer state.
3298  * @param file A readable stream.
3299  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
3300  * 
3301  * @return the allocated buffer state.
3302  */
3303     YY_BUFFER_STATE dax__create_buffer  (FILE * file, int  size )
3304 {
3305         YY_BUFFER_STATE b;
3306     
3307         b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
3308         if ( ! b )
3309                 YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
3310
3311         b->yy_buf_size = (yy_size_t)size;
3312
3313         /* yy_ch_buf has to be 2 characters longer than the size given because
3314          * we need to put in 2 end-of-buffer characters.
3315          */
3316         b->yy_ch_buf = (char *) dax_alloc(b->yy_buf_size + 2  );
3317         if ( ! b->yy_ch_buf )
3318                 YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
3319
3320         b->yy_is_our_buffer = 1;
3321
3322         dax__init_buffer(b,file );
3323
3324         return b;
3325 }
3326
3327 /** Destroy the buffer.
3328  * @param b a buffer created with dax__create_buffer()
3329  * 
3330  */
3331     void dax__delete_buffer (YY_BUFFER_STATE  b )
3332 {
3333     
3334         if ( ! b )
3335                 return;
3336
3337         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3338                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3339
3340         if ( b->yy_is_our_buffer )
3341                 dax_free((void *) b->yy_ch_buf  );
3342
3343         dax_free((void *) b  );
3344 }
3345
3346 /* Initializes or reinitializes a buffer.
3347  * This function is sometimes called more than once on the same buffer,
3348  * such as during a dax_restart() or at EOF.
3349  */
3350     static void dax__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
3351
3352 {
3353         int oerrno = errno;
3354     
3355         dax__flush_buffer(b );
3356
3357         b->yy_input_file = file;
3358         b->yy_fill_buffer = 1;
3359
3360     /* If b is the current buffer, then dax__init_buffer was _probably_
3361      * called from dax_restart() or through yy_get_next_buffer.
3362      * In that case, we don't want to reset the lineno or column.
3363      */
3364     if (b != YY_CURRENT_BUFFER){
3365         b->yy_bs_lineno = 1;
3366         b->yy_bs_column = 0;
3367     }
3368
3369         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3370     
3371         errno = oerrno;
3372 }
3373
3374 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
3375  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
3376  * 
3377  */
3378     void dax__flush_buffer (YY_BUFFER_STATE  b )
3379 {
3380         if ( ! b )
3381                 return;
3382
3383         b->yy_n_chars = 0;
3384
3385         /* We always need two end-of-buffer characters.  The first causes
3386          * a transition to the end-of-buffer state.  The second causes
3387          * a jam in that state.
3388          */
3389         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3390         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3391
3392         b->yy_buf_pos = &b->yy_ch_buf[0];
3393
3394         b->yy_at_bol = 1;
3395         b->yy_buffer_status = YY_BUFFER_NEW;
3396
3397         if ( b == YY_CURRENT_BUFFER )
3398                 dax__load_buffer_state( );
3399 }
3400
3401 /** Pushes the new state onto the stack. The new state becomes
3402  *  the current state. This function will allocate the stack
3403  *  if necessary.
3404  *  @param new_buffer The new state.
3405  *  
3406  */
3407 void dax_push_buffer_state (YY_BUFFER_STATE new_buffer )
3408 {
3409         if (new_buffer == NULL)
3410                 return;
3411
3412         dax_ensure_buffer_stack();
3413
3414         /* This block is copied from dax__switch_to_buffer. */
3415         if ( YY_CURRENT_BUFFER )
3416                 {
3417                 /* Flush out information for old buffer. */
3418                 *(yy_c_buf_p) = (yy_hold_char);
3419                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3420                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3421                 }
3422
3423         /* Only push if top exists. Otherwise, replace top. */
3424         if (YY_CURRENT_BUFFER)
3425                 (yy_buffer_stack_top)++;
3426         YY_CURRENT_BUFFER_LVALUE = new_buffer;
3427
3428         /* copied from dax__switch_to_buffer. */
3429         dax__load_buffer_state( );
3430         (yy_did_buffer_switch_on_eof) = 1;
3431 }
3432
3433 /** Removes and deletes the top of the stack, if present.
3434  *  The next element becomes the new top.
3435  *  
3436  */
3437 void dax_pop_buffer_state (void)
3438 {
3439         if (!YY_CURRENT_BUFFER)
3440                 return;
3441
3442         dax__delete_buffer(YY_CURRENT_BUFFER );
3443         YY_CURRENT_BUFFER_LVALUE = NULL;
3444         if ((yy_buffer_stack_top) > 0)
3445                 --(yy_buffer_stack_top);
3446
3447         if (YY_CURRENT_BUFFER) {
3448                 dax__load_buffer_state( );
3449                 (yy_did_buffer_switch_on_eof) = 1;
3450         }
3451 }
3452
3453 /* Allocates the stack if it does not exist.
3454  *  Guarantees space for at least one push.
3455  */
3456 static void dax_ensure_buffer_stack (void)
3457 {
3458         yy_size_t num_to_alloc;
3459     
3460         if (!(yy_buffer_stack)) {
3461
3462                 /* First allocation is just for 2 elements, since we don't know if this
3463                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
3464                  * immediate realloc on the next call.
3465          */
3466                 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
3467                 (yy_buffer_stack) = (struct yy_buffer_state**)dax_alloc
3468                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
3469                                                                 );
3470                 if ( ! (yy_buffer_stack) )
3471                         YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
3472                                                                   
3473                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3474                                 
3475                 (yy_buffer_stack_max) = num_to_alloc;
3476                 (yy_buffer_stack_top) = 0;
3477                 return;
3478         }
3479
3480         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3481
3482                 /* Increase the buffer to prepare for a possible push. */
3483                 yy_size_t grow_size = 8 /* arbitrary grow size */;
3484
3485                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
3486                 (yy_buffer_stack) = (struct yy_buffer_state**)dax_realloc
3487                                                                 ((yy_buffer_stack),
3488                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
3489                                                                 );
3490                 if ( ! (yy_buffer_stack) )
3491                         YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
3492
3493                 /* zero only the new slots.*/
3494                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3495                 (yy_buffer_stack_max) = num_to_alloc;
3496         }
3497 }
3498
3499 /** Setup the input buffer state to scan directly from a user-specified character buffer.
3500  * @param base the character buffer
3501  * @param size the size in bytes of the character buffer
3502  * 
3503  * @return the newly allocated buffer state object. 
3504  */
3505 YY_BUFFER_STATE dax__scan_buffer  (char * base, yy_size_t  size )
3506 {
3507         YY_BUFFER_STATE b;
3508     
3509         if ( size < 2 ||
3510              base[size-2] != YY_END_OF_BUFFER_CHAR ||
3511              base[size-1] != YY_END_OF_BUFFER_CHAR )
3512                 /* They forgot to leave room for the EOB's. */
3513                 return 0;
3514
3515         b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
3516         if ( ! b )
3517                 YY_FATAL_ERROR( "out of dynamic memory in dax__scan_buffer()" );
3518
3519         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
3520         b->yy_buf_pos = b->yy_ch_buf = base;
3521         b->yy_is_our_buffer = 0;
3522         b->yy_input_file = 0;
3523         b->yy_n_chars = b->yy_buf_size;
3524         b->yy_is_interactive = 0;
3525         b->yy_at_bol = 1;
3526         b->yy_fill_buffer = 0;
3527         b->yy_buffer_status = YY_BUFFER_NEW;
3528
3529         dax__switch_to_buffer(b  );
3530
3531         return b;
3532 }
3533
3534 /** Setup the input buffer state to scan a string. The next call to dax_lex() will
3535  * scan from a @e copy of @a str.
3536  * @param yystr a NUL-terminated string to scan
3537  * 
3538  * @return the newly allocated buffer state object.
3539  * @note If you want to scan bytes that may contain NUL values, then use
3540  *       dax__scan_bytes() instead.
3541  */
3542 YY_BUFFER_STATE dax__scan_string (yyconst char * yystr )
3543 {
3544     
3545         return dax__scan_bytes(yystr,strlen(yystr) );
3546 }
3547
3548 /** Setup the input buffer state to scan the given bytes. The next call to dax_lex() will
3549  * scan from a @e copy of @a bytes.
3550  * @param yybytes the byte buffer to scan
3551  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
3552  * 
3553  * @return the newly allocated buffer state object.
3554  */
3555 YY_BUFFER_STATE dax__scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
3556 {
3557         YY_BUFFER_STATE b;
3558         char *buf;
3559         yy_size_t n;
3560         yy_size_t i;
3561     
3562         /* Get memory for full buffer, including space for trailing EOB's. */
3563         n = _yybytes_len + 2;
3564         buf = (char *) dax_alloc(n  );
3565         if ( ! buf )
3566                 YY_FATAL_ERROR( "out of dynamic memory in dax__scan_bytes()" );
3567
3568         for ( i = 0; i < _yybytes_len; ++i )
3569                 buf[i] = yybytes[i];
3570
3571         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3572
3573         b = dax__scan_buffer(buf,n );
3574         if ( ! b )
3575                 YY_FATAL_ERROR( "bad buffer in dax__scan_bytes()" );
3576
3577         /* It's okay to grow etc. this buffer, and we should throw it
3578          * away when we're done.
3579          */
3580         b->yy_is_our_buffer = 1;
3581
3582         return b;
3583 }
3584
3585     static void yy_push_state (int  _new_state )
3586 {
3587         if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
3588                 {
3589                 yy_size_t new_size;
3590
3591                 (yy_start_stack_depth) += YY_START_STACK_INCR;
3592                 new_size = (yy_start_stack_depth) * sizeof( int );
3593
3594                 if ( ! (yy_start_stack) )
3595                         (yy_start_stack) = (int *) dax_alloc(new_size  );
3596
3597                 else
3598                         (yy_start_stack) = (int *) dax_realloc((void *) (yy_start_stack),new_size  );
3599
3600                 if ( ! (yy_start_stack) )
3601                         YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
3602                 }
3603
3604         (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
3605
3606         BEGIN(_new_state);
3607 }
3608
3609     static void yy_pop_state  (void)
3610 {
3611         if ( --(yy_start_stack_ptr) < 0 )
3612                 YY_FATAL_ERROR( "start-condition stack underflow" );
3613
3614         BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
3615 }
3616
3617 #ifndef YY_EXIT_FAILURE
3618 #define YY_EXIT_FAILURE 2
3619 #endif
3620
3621 static void yy_fatal_error (yyconst char* msg )
3622 {
3623                         (void) fprintf( stderr, "%s\n", msg );
3624         exit( YY_EXIT_FAILURE );
3625 }
3626
3627 /* Redefine yyless() so it works in section 3 code. */
3628
3629 #undef yyless
3630 #define yyless(n) \
3631         do \
3632                 { \
3633                 /* Undo effects of setting up dax_text. */ \
3634         int yyless_macro_arg = (n); \
3635         YY_LESS_LINENO(yyless_macro_arg);\
3636                 dax_text[dax_leng] = (yy_hold_char); \
3637                 (yy_c_buf_p) = dax_text + yyless_macro_arg; \
3638                 (yy_hold_char) = *(yy_c_buf_p); \
3639                 *(yy_c_buf_p) = '\0'; \
3640                 dax_leng = yyless_macro_arg; \
3641                 } \
3642         while ( 0 )
3643
3644 /* Accessor  methods (get/set functions) to struct members. */
3645
3646 /** Get the current line number.
3647  * 
3648  */
3649 int dax_get_lineno  (void)
3650 {
3651         
3652     return dax_lineno;
3653 }
3654
3655 /** Get the input stream.
3656  * 
3657  */
3658 FILE *dax_get_in  (void)
3659 {
3660         return dax_in;
3661 }
3662
3663 /** Get the output stream.
3664  * 
3665  */
3666 FILE *dax_get_out  (void)
3667 {
3668         return dax_out;
3669 }
3670
3671 /** Get the length of the current token.
3672  * 
3673  */
3674 yy_size_t dax_get_leng  (void)
3675 {
3676         return dax_leng;
3677 }
3678
3679 /** Get the current token.
3680  * 
3681  */
3682
3683 char *dax_get_text  (void)
3684 {
3685         return dax_text;
3686 }
3687
3688 /** Set the current line number.
3689  * @param _line_number line number
3690  * 
3691  */
3692 void dax_set_lineno (int  _line_number )
3693 {
3694     
3695     dax_lineno = _line_number;
3696 }
3697
3698 /** Set the input stream. This does not discard the current
3699  * input buffer.
3700  * @param _in_str A readable stream.
3701  * 
3702  * @see dax__switch_to_buffer
3703  */
3704 void dax_set_in (FILE *  _in_str )
3705 {
3706         dax_in = _in_str ;
3707 }
3708
3709 void dax_set_out (FILE *  _out_str )
3710 {
3711         dax_out = _out_str ;
3712 }
3713
3714 int dax_get_debug  (void)
3715 {
3716         return dax__flex_debug;
3717 }
3718
3719 void dax_set_debug (int  _bdebug )
3720 {
3721         dax__flex_debug = _bdebug ;
3722 }
3723
3724 static int yy_init_globals (void)
3725 {
3726         /* Initialization is the same as for the non-reentrant scanner.
3727      * This function is called from dax_lex_destroy(), so don't allocate here.
3728      */
3729
3730     /* We do not touch dax_lineno unless the option is enabled. */
3731     dax_lineno =  1;
3732     
3733     (yy_buffer_stack) = 0;
3734     (yy_buffer_stack_top) = 0;
3735     (yy_buffer_stack_max) = 0;
3736     (yy_c_buf_p) = (char *) 0;
3737     (yy_init) = 0;
3738     (yy_start) = 0;
3739
3740     (yy_start_stack_ptr) = 0;
3741     (yy_start_stack_depth) = 0;
3742     (yy_start_stack) =  NULL;
3743
3744 /* Defined in main.c */
3745 #ifdef YY_STDINIT
3746     dax_in = stdin;
3747     dax_out = stdout;
3748 #else
3749     dax_in = (FILE *) 0;
3750     dax_out = (FILE *) 0;
3751 #endif
3752
3753     /* For future reference: Set errno on error, since we are called by
3754      * dax_lex_init()
3755      */
3756     return 0;
3757 }
3758
3759 /* dax_lex_destroy is for both reentrant and non-reentrant scanners. */
3760 int dax_lex_destroy  (void)
3761 {
3762     
3763     /* Pop the buffer stack, destroying each element. */
3764         while(YY_CURRENT_BUFFER){
3765                 dax__delete_buffer(YY_CURRENT_BUFFER  );
3766                 YY_CURRENT_BUFFER_LVALUE = NULL;
3767                 dax_pop_buffer_state();
3768         }
3769
3770         /* Destroy the stack itself. */
3771         dax_free((yy_buffer_stack) );
3772         (yy_buffer_stack) = NULL;
3773
3774     /* Destroy the start condition stack. */
3775         dax_free((yy_start_stack)  );
3776         (yy_start_stack) = NULL;
3777
3778     /* Reset the globals. This is important in a non-reentrant scanner so the next time
3779      * dax_lex() is called, initialization will occur. */
3780     yy_init_globals( );
3781
3782     return 0;
3783 }
3784
3785 /*
3786  * Internal utility routines.
3787  */
3788
3789 #ifndef yytext_ptr
3790 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
3791 {
3792                 
3793         int i;
3794         for ( i = 0; i < n; ++i )
3795                 s1[i] = s2[i];
3796 }
3797 #endif
3798
3799 #ifdef YY_NEED_STRLEN
3800 static int yy_flex_strlen (yyconst char * s )
3801 {
3802         int n;
3803         for ( n = 0; s[n]; ++n )
3804                 ;
3805
3806         return n;
3807 }
3808 #endif
3809
3810 void *dax_alloc (yy_size_t  size )
3811 {
3812                         return (void *) malloc( size );
3813 }
3814
3815 void *dax_realloc  (void * ptr, yy_size_t  size )
3816 {
3817                 
3818         /* The cast to (char *) in the following accommodates both
3819          * implementations that use char* generic pointers, and those
3820          * that use void* generic pointers.  It works with the latter
3821          * because both ANSI C and C++ allow castless assignment from
3822          * any pointer type to void*, and deal with argument conversions
3823          * as though doing an assignment.
3824          */
3825         return (void *) realloc( (char *) ptr, size );
3826 }
3827
3828 void dax_free (void * ptr )
3829 {
3830                         free( (char *) ptr );   /* see dax_realloc() for (char *) cast */
3831 }
3832
3833 #define YYTABLES_NAME "yytables"
3834
3835 /* Element context stack lookup. */
3836 int dax__element_context(int i)
3837 {
3838   return (0<i && i<yy_start_stack_depth
3839           ? yy_start_stack[yy_start_stack_ptr - i]
3840           : 0);
3841 }
3842
3843 #ifdef FLEX_DEBUG
3844 void print_yy_stack(char* fmt, ...)
3845 {
3846   int i = 0; va_list ap; va_start(ap, fmt);
3847   vfprintf(stderr, fmt, ap);
3848   if (dax__statenames) {
3849       for (i=1; i<yy_start_stack_ptr; i++) {
3850           fprintf(stderr, "%s/", dax__statenames[yy_start_stack[i] ]);
3851       }
3852       fprintf(stderr,"%s\n", dax__statenames[YY_START]);
3853   }
3854   va_end(ap);
3855 }
3856
3857 void print_dax__bufferstack()
3858 {
3859     int i;
3860     fputs("Buffer: ", stderr);
3861     for (i = 0; i < blimit; i++) {
3862        if ( dax__bufferstack[i] == '\377' ) break;
3863          putc(dax__bufferstack[i], stderr);
3864     }
3865     putc('\n', stderr);
3866 }
3867
3868 static void debug_enter(int state, const char* statename) {
3869   yy_push_state(state);
3870   if (dax__flex_debug) {
3871        print_yy_stack("--ENTER(%s) : ",statename);
3872        print_dax__bufferstack();
3873   }
3874 }
3875
3876 static void debug_leave(void) {
3877     if (dax__flex_debug) {
3878         print_yy_stack("--LEAVE : ");
3879         print_dax__bufferstack();
3880     }
3881   yy_pop_state();
3882 }
3883
3884 static void debug_set(int state, const char* statename) {
3885   BEGIN(state);
3886   if (dax__flex_debug) print_yy_stack("--SET(%s) : ",statename);
3887 }
3888 #endif
3889
3890 static void cleanup(void)
3891 {
3892     if (dax__statenames) {
3893         free(dax__statenames);
3894         dax__statenames = NULL;
3895     }
3896     free(dax__bufferstack);
3897     dax__bufferstack = NULL;
3898
3899     free(indexstack);
3900     indexstack = NULL;
3901 }
3902
3903 static int fail(const char* fmt, ...)
3904 {
3905     int chars_left, used;
3906     va_list ap; va_start(ap, fmt);
3907 #ifdef FLEXML_yylineno
3908     used = sprintf(flexml_err_msg,
3909                    "Invalid XML (XML input line %d, state %d): ",
3910                    dax_lineno, YY_START);
3911 #else
3912     used = sprintf(flexml_err_msg,
3913                    "Invalid XML (state %d): ",
3914                    YY_START);
3915 #endif
3916     chars_left = flexml_max_err_msg_size - used - 1;
3917     vsnprintf(flexml_err_msg + used, chars_left, fmt, ap);
3918     va_end(ap);
3919
3920 #ifndef FLEXML_quiet_parser
3921     /* print directly to sdterr */
3922     fprintf(stderr, "%s\n", flexml_err_msg);
3923     flexml_err_msg[0] = '\0';
3924 #endif
3925
3926     cleanup();
3927
3928     return 1;
3929 }
3930