Logo AND Algorithmique Numérique Distribuée

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