Logo AND Algorithmique Numérique Distribuée

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