Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix missing proto for PID functions
[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-2011 Martin Quinson.  All rights reserved.
1263  * (Id: flexml.pl,v 1.69 2012/12/20 00:13:40 mquinson Exp).
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-2011 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 rcs_dax__flexml_skeleton[] =
1306  "$" "Id: skel,v 1.40 2007/10/11 09:57:24 mquinson Exp $";
1307 const char rcs_dax__flexml[] =
1308  "$" "Id: flexml.pl,v 1.69 2012/12/20 00:13:40 mquinson Exp $";
1309
1310 /* ANSI headers. */
1311 #include <stdlib.h> /* for realloc() -- needed here when using flex 2.5.4 */
1312 #include <stdio.h>
1313 #include <string.h>
1314 #include <assert.h>
1315 #include <stdarg.h>
1316 #include <ctype.h>
1317      
1318 #if defined(_XBT_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__)
1319 # ifndef __STRICT_ANSI__
1320 #  include <io.h>
1321 #  include <process.h>
1322 # endif
1323 #else
1324 # include <unistd.h>
1325 #endif
1326      
1327 #ifndef FLEXML_INDEXSTACKSIZE
1328 #define FLEXML_INDEXSTACKSIZE 1000
1329 #endif
1330
1331 /* Generated definitions. */
1332 #define FLEXML_yylineno
1333 #ifndef FLEXML_BUFFERSTACKSIZE
1334 #define FLEXML_BUFFERSTACKSIZE 1000000
1335 #endif
1336 #define FLEXML_NEED_BUFFERLIT
1337
1338 /* XML processor api. */
1339 /* FleXML-provided data. */
1340 int dax__pcdata_ix;
1341 extern char *dax__bufferstack;
1342 #define dax__pcdata (dax__bufferstack + dax__pcdata_ix)
1343 AT_dax__adag_version AX_dax__adag_version;
1344 #define A_dax__adag_version (dax__bufferstack + AX_dax__adag_version)
1345 short int dax__adag_version_isset;
1346 AT_dax__uses_type AX_dax__uses_type;
1347 #define A_dax__uses_type (dax__bufferstack + AX_dax__uses_type)
1348 short int dax__uses_type_isset;
1349 AT_dax__uses_optional AX_dax__uses_optional;
1350 #define A_dax__uses_optional AX_dax__uses_optional
1351 short int dax__uses_optional_isset;
1352 AT_dax__adag_name AX_dax__adag_name;
1353 #define A_dax__adag_name (dax__bufferstack + AX_dax__adag_name)
1354 short int dax__adag_name_isset;
1355 AT_dax__child_ref AX_dax__child_ref;
1356 #define A_dax__child_ref (dax__bufferstack + AX_dax__child_ref)
1357 short int dax__child_ref_isset;
1358 AT_dax__adag_xmlns AX_dax__adag_xmlns;
1359 #define A_dax__adag_xmlns (dax__bufferstack + AX_dax__adag_xmlns)
1360 short int dax__adag_xmlns_isset;
1361 AT_dax__uses_transfer AX_dax__uses_transfer;
1362 #define A_dax__uses_transfer AX_dax__uses_transfer
1363 short int dax__uses_transfer_isset;
1364 AT_dax__job_id AX_dax__job_id;
1365 #define A_dax__job_id (dax__bufferstack + AX_dax__job_id)
1366 short int dax__job_id_isset;
1367 AT_dax__uses_file AX_dax__uses_file;
1368 #define A_dax__uses_file (dax__bufferstack + AX_dax__uses_file)
1369 short int dax__uses_file_isset;
1370 AT_dax__parent_ref AX_dax__parent_ref;
1371 #define A_dax__parent_ref (dax__bufferstack + AX_dax__parent_ref)
1372 short int dax__parent_ref_isset;
1373 AT_dax__adag_count AX_dax__adag_count;
1374 #define A_dax__adag_count (dax__bufferstack + AX_dax__adag_count)
1375 short int dax__adag_count_isset;
1376 AT_dax__adag_xmlns_c_xsi AX_dax__adag_xmlns_c_xsi;
1377 #define A_dax__adag_xmlns_c_xsi (dax__bufferstack + AX_dax__adag_xmlns_c_xsi)
1378 short int dax__adag_xmlns_c_xsi_isset;
1379 AT_dax__adag_index AX_dax__adag_index;
1380 #define A_dax__adag_index (dax__bufferstack + AX_dax__adag_index)
1381 short int dax__adag_index_isset;
1382 AT_dax__uses_size AX_dax__uses_size;
1383 #define A_dax__uses_size (dax__bufferstack + AX_dax__uses_size)
1384 short int dax__uses_size_isset;
1385 AT_dax__adag_childCount AX_dax__adag_childCount;
1386 #define A_dax__adag_childCount (dax__bufferstack + AX_dax__adag_childCount)
1387 short int dax__adag_childCount_isset;
1388 AT_dax__uses_link AX_dax__uses_link;
1389 #define A_dax__uses_link AX_dax__uses_link
1390 short int dax__uses_link_isset;
1391 AT_dax__job_runtime AX_dax__job_runtime;
1392 #define A_dax__job_runtime (dax__bufferstack + AX_dax__job_runtime)
1393 short int dax__job_runtime_isset;
1394 AT_dax__job_level AX_dax__job_level;
1395 #define A_dax__job_level (dax__bufferstack + AX_dax__job_level)
1396 short int dax__job_level_isset;
1397 AT_dax__job_namespace AX_dax__job_namespace;
1398 #define A_dax__job_namespace (dax__bufferstack + AX_dax__job_namespace)
1399 short int dax__job_namespace_isset;
1400 AT_dax__job_name AX_dax__job_name;
1401 #define A_dax__job_name (dax__bufferstack + AX_dax__job_name)
1402 short int dax__job_name_isset;
1403 AT_dax__adag_jobCount AX_dax__adag_jobCount;
1404 #define A_dax__adag_jobCount (dax__bufferstack + AX_dax__adag_jobCount)
1405 short int dax__adag_jobCount_isset;
1406 AT_dax__job_version AX_dax__job_version;
1407 #define A_dax__job_version (dax__bufferstack + AX_dax__job_version)
1408 short int dax__job_version_isset;
1409 AT_dax__adag_xsi_c_schemaLocation AX_dax__adag_xsi_c_schemaLocation;
1410 #define A_dax__adag_xsi_c_schemaLocation (dax__bufferstack + AX_dax__adag_xsi_c_schemaLocation)
1411 short int dax__adag_xsi_c_schemaLocation_isset;
1412 AT_dax__uses_register AX_dax__uses_register;
1413 #define A_dax__uses_register AX_dax__uses_register
1414 short int dax__uses_register_isset;
1415 AT_dax__adag_fileCount AX_dax__adag_fileCount;
1416 #define A_dax__adag_fileCount (dax__bufferstack + AX_dax__adag_fileCount)
1417 short int dax__adag_fileCount_isset;
1418
1419 /* XML state. */
1420 #ifdef FLEX_DEBUG
1421 # define ENTER(state)   debug_enter(state,#state)
1422 # define LEAVE          debug_leave()
1423 # define SET(state)     debug_set(state,#state)
1424   static void debug_enter(int, const char*);
1425   static void debug_leave(void);
1426   static void debug_set(int, const char*);
1427 #else
1428 # define ENTER(state)   (yy_push_state(state))
1429 # define LEAVE          (yy_pop_state())
1430 # define SET(state)     BEGIN(state)
1431 #endif
1432
1433 /* Generic actions. */
1434 #define SKIP    /*skip*/
1435 #define SUCCEED        CLEANUP; return 0
1436
1437 #define FAIL    return fail
1438 static int fail(const char*, ...);
1439
1440 enum {flexml_max_err_msg_size = 512};
1441 static char flexml_err_msg[flexml_max_err_msg_size];
1442 const char * dax__parse_err_msg()
1443 {
1444     return flexml_err_msg;
1445 }
1446 static void reset_dax__parse_err_msg()
1447 {
1448     flexml_err_msg[0] = '\0';
1449 }
1450
1451 /* Cleanup */
1452 static void cleanup(void);
1453 #define CLEANUP  cleanup()
1454
1455 /* Text buffer stack handling. */
1456 char *dax__bufferstack = NULL;
1457 static int blimit = FLEXML_BUFFERSTACKSIZE;
1458 static int bnext = 1;
1459
1460 static int *indexstack = NULL;
1461 static int ilimit = FLEXML_INDEXSTACKSIZE;
1462 static int inext = 1;
1463
1464 #define BUFFERSET(P)  (P = bnext)
1465 #define BUFFERPUTC(C) (ck_blimit(), dax__bufferstack[bnext++] = (C))
1466 #define BUFFERDONE    (BUFFERPUTC('\0'))
1467
1468 #define BUFFERLITERAL(C, P) dax__bufferliteral(C, &(P), dax_text)
1469
1470 /* after this is called, there are at least 2 slots left in the stack */
1471 static int ck_blimit()
1472 {
1473      if (bnext >= blimit) {
1474          blimit += FLEXML_BUFFERSTACKSIZE + 2;
1475          {
1476              char *temp = (char *) realloc(dax__bufferstack, blimit);
1477              assert(temp);
1478              dax__bufferstack = temp;
1479          }
1480      }
1481      return 0;
1482 }
1483
1484 /* after this is called, there are at least 2 slots left in the stack */
1485 static int ck_ilimit()
1486 {
1487      if (inext >= ilimit) {
1488          ilimit += FLEXML_INDEXSTACKSIZE + 2;
1489          {
1490              int *temp = (int *) realloc(indexstack, ilimit);
1491              assert(temp);
1492              indexstack = temp;
1493          }
1494      }
1495      return 0;
1496 }
1497
1498 #ifdef FLEXML_NEED_BUFFERLIT
1499 static void dax__bufferliteral(char c, int* pp, const char* text)
1500 {
1501    BUFFERSET(*pp);
1502    if (c) {
1503       const char *s = strchr(text, c), *e = strrchr(text, c);
1504       assert(s && e && s <= e);
1505       ++s;
1506       while (s < e) {
1507          if (isspace(*s)) {
1508             BUFFERPUTC(' ');
1509             do ++s; while (s < e && isspace(*s));
1510          } else
1511            BUFFERPUTC(*s++);
1512       }
1513    } else {
1514       const char *s = text;
1515       while (*s)
1516         BUFFERPUTC(*s++);
1517    }
1518    BUFFERDONE;
1519 }
1520 #endif
1521
1522 static void pushbuffer(int p)
1523 {
1524     ck_ilimit();
1525     indexstack[inext++] = p;
1526     indexstack[inext++] = bnext;    
1527 }
1528
1529 static int popbuffer(void)
1530 {
1531     assert(inext >= 2);
1532     bnext = indexstack[--inext];
1533     return indexstack[--inext];
1534 }
1535
1536 /* General internal entities are `unput' back onto the input stream... */
1537 #define ENTITYTEXT(T) \
1538   { char *s = (T), *e = s+strlen(s);\
1539     while (--e >= s) { unput(*e); }}
1540
1541 /* Flex standard options. */
1542 #define YY_NO_INPUT 1
1543 /* Flex user-requested options. */
1544 /* XML character classes (currently restricted to ASCII). */
1545 /* "Common syntactic structures." */
1546 /* "Names and Tokens." */
1547 /* Miscellaneous. */
1548 /* Parser states (flex `exclusive start conditions'):
1549  *
1550  * PROLOG       the XML prolog of the document before <?xml...>
1551  * DOCTYPE      the XML prolog of the document after <?xml...>
1552  * EPILOG       after the root element
1553  * INCOMMENT    inside an XML comment <!--....-->
1554  * INPI         inside an XML PI <?...?>
1555  * VALUE1       inside a '...'-delimited literal
1556  * VALUE2       inside a "..."-delimited literal
1557  * CDATA        inside a <![CDATA[...] ]> section.
1558  * ROOT_<tag>   expect root element <tag>
1559  * AL_<tag>     inside the attribute list for <tag>
1560  * IN_<tag>     inside a <tag> with element contents (ready for end tag)
1561  * IMPOSSIBLE   dummy to permit disabling rules; must be last
1562  */
1563
1564 /* State names. */
1565 const char* *dax__statenames=NULL;
1566
1567 #define INITIAL 0
1568 #define PROLOG 1
1569 #define DOCTYPE 2
1570 #define EPILOG 3
1571 #define INCOMMENT 4
1572 #define INPI 5
1573 #define VALUE1 6
1574 #define VALUE2 7
1575 #define CDATA 8
1576 #define ROOT_dax__adag 9
1577 #define AL_dax__adag 10
1578 #define S_dax__adag 11
1579 #define S_dax__adag_1 12
1580 #define S_dax__adag_2 13
1581 #define S_dax__adag_3 14
1582 #define S_dax__adag_4 15
1583 #define S_dax__adag_5 16
1584 #define E_dax__adag 17
1585 #define AL_dax__job 18
1586 #define S_dax__job 19
1587 #define S_dax__job_1 20
1588 #define S_dax__job_2 21
1589 #define E_dax__job 22
1590 #define AL_dax__uses 23
1591 #define E_dax__uses 24
1592 #define AL_dax__child 25
1593 #define S_dax__child 26
1594 #define S_dax__child_1 27
1595 #define S_dax__child_2 28
1596 #define E_dax__child 29
1597 #define AL_dax__parent 30
1598 #define E_dax__parent 31
1599 #define IMPOSSIBLE 32
1600
1601 #ifndef YY_NO_UNISTD_H
1602 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1603  * down here because we want the user's section 1 to have been scanned first.
1604  * The user has a chance to override it with an option.
1605  */
1606 #if defined(_XBT_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__)
1607 #  ifndef __STRICT_ANSI__
1608 #    include <io.h>
1609 #    include <process.h>
1610 #  endif
1611 #else
1612 #  include <unistd.h>
1613 #endif
1614 #endif
1615
1616 #ifndef YY_EXTRA_TYPE
1617 #define YY_EXTRA_TYPE void *
1618 #endif
1619
1620 static int yy_init_globals (void );
1621
1622 /* Accessor methods to globals.
1623    These are made visible to non-reentrant scanners for convenience. */
1624
1625 int dax_lex_destroy (void );
1626
1627 int dax_get_debug (void );
1628
1629 void dax_set_debug (int debug_flag  );
1630
1631 YY_EXTRA_TYPE dax_get_extra (void );
1632
1633 void dax_set_extra (YY_EXTRA_TYPE user_defined  );
1634
1635 FILE *dax_get_in (void );
1636
1637 void dax_set_in  (FILE * in_str  );
1638
1639 FILE *dax_get_out (void );
1640
1641 void dax_set_out  (FILE * out_str  );
1642
1643 int dax_get_leng (void );
1644
1645 char *dax_get_text (void );
1646
1647 int dax_get_lineno (void );
1648
1649 void dax_set_lineno (int line_number  );
1650
1651 /* Macros after this point can all be overridden by user definitions in
1652  * section 1.
1653  */
1654
1655 #ifndef YY_SKIP_YYWRAP
1656 #ifdef __cplusplus
1657 extern "C" int dax_wrap (void );
1658 #else
1659 extern int dax_wrap (void );
1660 #endif
1661 #endif
1662
1663 #ifndef yytext_ptr
1664 static void yy_flex_strncpy (char *,yyconst char *,int );
1665 #endif
1666
1667 #ifdef YY_NEED_STRLEN
1668 static int yy_flex_strlen (yyconst char * );
1669 #endif
1670
1671 #ifndef YY_NO_INPUT
1672
1673 #ifdef __cplusplus
1674 static int yyinput (void );
1675 #else
1676 static int input (void );
1677 #endif
1678
1679 #endif
1680
1681         static int yy_start_stack_ptr = 0;
1682         static int yy_start_stack_depth = 0;
1683         static int *yy_start_stack = NULL;
1684     
1685     static void yy_push_state (int new_state );
1686     
1687     static void yy_pop_state (void );
1688     
1689 /* Amount of stuff to slurp up with each read. */
1690 #ifndef YY_READ_BUF_SIZE
1691 #ifdef __ia64__
1692 /* On IA-64, the buffer size is 16k, not 8k */
1693 #define YY_READ_BUF_SIZE 16384
1694 #else
1695 #define YY_READ_BUF_SIZE 8192
1696 #endif /* __ia64__ */
1697 #endif
1698
1699 /* Copy whatever the last rule matched to the standard output. */
1700 #ifndef ECHO
1701 /* This used to be an fputs(), but since the string might contain NUL's,
1702  * we now use fwrite().
1703  */
1704 #define ECHO do { if (fwrite( dax_text, dax_leng, 1, dax_out )) {} } while (0)
1705 #endif
1706
1707 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1708  * is returned in "result".
1709  */
1710 #ifndef YY_INPUT
1711 #define YY_INPUT(buf,result,max_size) \
1712         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1713                 { \
1714                 int c = '*'; \
1715                 size_t n; \
1716                 for ( n = 0; n < max_size && \
1717                              (c = getc( dax_in )) != EOF && c != '\n'; ++n ) \
1718                         buf[n] = (char) c; \
1719                 if ( c == '\n' ) \
1720                         buf[n++] = (char) c; \
1721                 if ( c == EOF && ferror( dax_in ) ) \
1722                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1723                 result = n; \
1724                 } \
1725         else \
1726                 { \
1727                 errno=0; \
1728                 while ( (result = fread(buf, 1, max_size, dax_in))==0 && ferror(dax_in)) \
1729                         { \
1730                         if( errno != EINTR) \
1731                                 { \
1732                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1733                                 break; \
1734                                 } \
1735                         errno=0; \
1736                         clearerr(dax_in); \
1737                         } \
1738                 }\
1739 \
1740
1741 #endif
1742
1743 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1744  * we don't want an extra ';' after the "return" because that will cause
1745  * some compilers to complain about unreachable statements.
1746  */
1747 #ifndef yyterminate
1748 #define yyterminate() return YY_NULL
1749 #endif
1750
1751 /* Number of entries by which start-condition stack grows. */
1752 #ifndef YY_START_STACK_INCR
1753 #define YY_START_STACK_INCR 25
1754 #endif
1755
1756 /* Report a fatal error. */
1757 #ifndef YY_FATAL_ERROR
1758 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1759 #endif
1760
1761 /* end tables serialization structures and prototypes */
1762
1763 /* Default declaration of generated scanner - a define so the user can
1764  * easily add parameters.
1765  */
1766 #ifndef YY_DECL
1767 #define YY_DECL_IS_OURS 1
1768
1769 extern int dax_lex (void);
1770
1771 #define YY_DECL int dax_lex (void)
1772 #endif /* !YY_DECL */
1773
1774 /* Code executed at the beginning of each rule, after dax_text and dax_leng
1775  * have been set up.
1776  */
1777 #ifndef YY_USER_ACTION
1778 #define YY_USER_ACTION
1779 #endif
1780
1781 /* Code executed at the end of each rule. */
1782 #ifndef YY_BREAK
1783 #define YY_BREAK break;
1784 #endif
1785
1786 #define YY_RULE_SETUP \
1787         YY_USER_ACTION
1788
1789 /** The main scanner function which does all the work.
1790  */
1791 YY_DECL
1792 {
1793         register yy_state_type yy_current_state;
1794         register char *yy_cp, *yy_bp;
1795         register int yy_act;
1796     
1797  /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
1798  SET(PROLOG);
1799  reset_dax__parse_err_msg();
1800  dax__bufferstack = (char *) malloc(FLEXML_BUFFERSTACKSIZE);
1801  assert(dax__bufferstack);
1802  #ifdef FLEX_DEBUG
1803  {
1804      int i;
1805      for (i = 0; i < blimit; i++) {
1806          dax__bufferstack[i] = '\377';
1807      }
1808  }
1809  #endif
1810  dax__bufferstack[0] = '\0';
1811  indexstack = (int *) malloc(FLEXML_INDEXSTACKSIZE * sizeof(int));
1812  assert(indexstack);
1813  indexstack[0] = 0;
1814
1815   /* FleXML_init */
1816   bnext = inext = 1;
1817   dax__bufferliteral('\0', &bnext, "http://pegasus.isi.edu/schema/DAX");
1818   dax__bufferliteral('\0', &bnext, "http://www.w3.org/2001/XMLSchema-instance");
1819   dax__bufferliteral('\0', &bnext, "http://pegasus.isi.edu/schema/DAX http://pegasus.isi.edu/schema/dax-2.1.xsd");
1820   dax__bufferliteral('\0', &bnext, "1.0");
1821   dax__bufferliteral('\0', &bnext, "0.0");
1822   dax__bufferliteral('\0', &bnext, "data");
1823   if(!dax__statenames) {dax__statenames= (const char **)calloc(IMPOSSIBLE,sizeof(char*));
1824   dax__statenames[PROLOG] = NULL;
1825   dax__statenames[DOCTYPE] = NULL;
1826   dax__statenames[EPILOG] = NULL;
1827   dax__statenames[INCOMMENT] = NULL;
1828   dax__statenames[INPI] = NULL;
1829   dax__statenames[VALUE1] = NULL;
1830   dax__statenames[VALUE2] = NULL;
1831   dax__statenames[CDATA] = NULL;
1832   dax__statenames[ROOT_dax__adag] = NULL;
1833   dax__statenames[AL_dax__adag] = NULL;
1834   dax__statenames[S_dax__adag] = "adag";
1835   dax__statenames[S_dax__adag_1] = "adag";
1836   dax__statenames[S_dax__adag_2] = "adag";
1837   dax__statenames[S_dax__adag_3] = "adag";
1838   dax__statenames[S_dax__adag_4] = "adag";
1839   dax__statenames[S_dax__adag_5] = "adag";
1840   dax__statenames[E_dax__adag] = "adag";
1841   dax__statenames[AL_dax__job] = NULL;
1842   dax__statenames[S_dax__job] = "job";
1843   dax__statenames[S_dax__job_1] = "job";
1844   dax__statenames[S_dax__job_2] = "job";
1845   dax__statenames[E_dax__job] = "job";
1846   dax__statenames[AL_dax__uses] = NULL;
1847   dax__statenames[E_dax__uses] = "uses";
1848   dax__statenames[AL_dax__child] = NULL;
1849   dax__statenames[S_dax__child] = "child";
1850   dax__statenames[S_dax__child_1] = "child";
1851   dax__statenames[S_dax__child_2] = "child";
1852   dax__statenames[E_dax__child] = "child";
1853   dax__statenames[AL_dax__parent] = NULL;
1854   dax__statenames[E_dax__parent] = "parent";
1855   }
1856
1857  /* COMMENTS and PIs: handled uniformly for efficiency. */
1858
1859         if ( !(yy_init) )
1860                 {
1861                 (yy_init) = 1;
1862
1863 #ifdef YY_USER_INIT
1864                 YY_USER_INIT;
1865 #endif
1866
1867                 if ( ! (yy_start) )
1868                         (yy_start) = 1; /* first start state */
1869
1870                 if ( ! dax_in )
1871                         dax_in = stdin;
1872
1873                 if ( ! dax_out )
1874                         dax_out = stdout;
1875
1876                 if ( ! YY_CURRENT_BUFFER ) {
1877                         dax_ensure_buffer_stack ();
1878                         YY_CURRENT_BUFFER_LVALUE =
1879                                 dax__create_buffer(dax_in,YY_BUF_SIZE );
1880                 }
1881
1882                 dax__load_buffer_state( );
1883                 }
1884
1885         while ( 1 )             /* loops until end-of-file is reached */
1886                 {
1887                 yy_cp = (yy_c_buf_p);
1888
1889                 /* Support of dax_text. */
1890                 *yy_cp = (yy_hold_char);
1891
1892                 /* yy_bp points to the position in yy_ch_buf of the start of
1893                  * the current run.
1894                  */
1895                 yy_bp = yy_cp;
1896
1897                 yy_current_state = (yy_start);
1898 yy_match:
1899                 do
1900                         {
1901                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1902                         if ( yy_accept[yy_current_state] )
1903                                 {
1904                                 (yy_last_accepting_state) = yy_current_state;
1905                                 (yy_last_accepting_cpos) = yy_cp;
1906                                 }
1907                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1908                                 {
1909                                 yy_current_state = (int) yy_def[yy_current_state];
1910                                 if ( yy_current_state >= 775 )
1911                                         yy_c = yy_meta[(unsigned int) yy_c];
1912                                 }
1913                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1914                         ++yy_cp;
1915                         }
1916                 while ( yy_base[yy_current_state] != 2164 );
1917
1918 yy_find_action:
1919                 yy_act = yy_accept[yy_current_state];
1920                 if ( yy_act == 0 )
1921                         { /* have to back up */
1922                         yy_cp = (yy_last_accepting_cpos);
1923                         yy_current_state = (yy_last_accepting_state);
1924                         yy_act = yy_accept[yy_current_state];
1925                         }
1926
1927                 YY_DO_BEFORE_ACTION;
1928
1929                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1930                         {
1931                         int yyl;
1932                         for ( yyl = 0; yyl < dax_leng; ++yyl )
1933                                 if ( dax_text[yyl] == '\n' )
1934                                            
1935     dax_lineno++;
1936 ;
1937                         }
1938
1939 do_action:      /* This label is used only to access EOF actions. */
1940
1941                 switch ( yy_act )
1942         { /* beginning of action switch */
1943                         case 0: /* must back up */
1944                         /* undo the effects of YY_DO_BEFORE_ACTION */
1945                         *yy_cp = (yy_hold_char);
1946                         yy_cp = (yy_last_accepting_cpos);
1947                         yy_current_state = (yy_last_accepting_state);
1948                         goto yy_find_action;
1949
1950 case 1:
1951 YY_RULE_SETUP
1952 ENTER(INCOMMENT);
1953         YY_BREAK
1954 case 2:
1955 YY_RULE_SETUP
1956 ENTER(INPI);
1957         YY_BREAK
1958
1959 case 3:
1960 YY_RULE_SETUP
1961 LEAVE;
1962         YY_BREAK
1963 case 4:
1964 case 5:
1965 case 6:
1966 /* rule 6 can match eol */
1967 YY_RULE_SETUP
1968 SKIP;
1969         YY_BREAK
1970 case YY_STATE_EOF(INCOMMENT):
1971 FAIL("EOF in comment.");
1972         YY_BREAK
1973
1974 case 7:
1975 YY_RULE_SETUP
1976 LEAVE;
1977         YY_BREAK
1978 case 8:
1979 case 9:
1980 /* rule 9 can match eol */
1981 YY_RULE_SETUP
1982 SKIP;
1983         YY_BREAK
1984 case YY_STATE_EOF(INPI):
1985 FAIL("EOF in PI (processing instruction).");
1986         YY_BREAK
1987
1988 /* SPACES: skipped uniformly */
1989 case 10:
1990 /* rule 10 can match eol */
1991 YY_RULE_SETUP
1992 SKIP;
1993         YY_BREAK
1994 /* PROLOG: determine root element and process it. */
1995
1996 case 11:
1997 /* rule 11 can match eol */
1998 YY_RULE_SETUP
1999 SET(ROOT_dax__adag); 
2000         YY_BREAK
2001 case 12:
2002 /* rule 12 can match eol */
2003 YY_RULE_SETUP
2004 FAIL("Bad declaration %s.",dax_text);
2005         YY_BREAK
2006
2007 case 13:
2008 /* rule 13 can match eol */
2009 YY_RULE_SETUP
2010 SET(ROOT_dax__adag);
2011         YY_BREAK
2012 case 14:
2013 /* rule 14 can match eol */
2014 YY_RULE_SETUP
2015 FAIL("Bad declaration %s.",dax_text);
2016         YY_BREAK
2017 case 15:
2018 YY_RULE_SETUP
2019 FAIL("Unexpected character `%c' in prolog.", dax_text[0]);
2020         YY_BREAK
2021 case YY_STATE_EOF(PROLOG):
2022 case YY_STATE_EOF(DOCTYPE):
2023 FAIL("EOF in prolog.");
2024         YY_BREAK
2025
2026 /* RULES DERIVED FROM DTD. */
2027 /* <!-- Small DTD for DAX files. -->  */
2028 case 16:
2029 /* rule 16 can match eol */
2030 YY_RULE_SETUP
2031 FAIL("Starting tag <adag> is not allowed here.");
2032         YY_BREAK
2033 case 17:
2034 /* rule 17 can match eol */
2035 YY_RULE_SETUP
2036 {
2037   AX_dax__adag_xmlns = 1;
2038   dax__adag_xmlns_isset = 0;
2039   AX_dax__adag_xmlns_c_xsi = 35;
2040   dax__adag_xmlns_c_xsi_isset = 0;
2041   AX_dax__adag_xsi_c_schemaLocation = 77;
2042   dax__adag_xsi_c_schemaLocation_isset = 0;
2043   AX_dax__adag_version = 153;
2044   dax__adag_version_isset = 0;
2045   AX_dax__adag_count = 0;
2046   dax__adag_count_isset = 0;
2047   AX_dax__adag_index = 0;
2048   dax__adag_index_isset = 0;
2049   AX_dax__adag_name = 0;
2050   dax__adag_name_isset = 0;
2051   AX_dax__adag_jobCount = 0;
2052   dax__adag_jobCount_isset = 0;
2053   AX_dax__adag_fileCount = 0;
2054   dax__adag_fileCount_isset = 0;
2055   AX_dax__adag_childCount = 0;
2056   dax__adag_childCount_isset = 0;
2057   ENTER(AL_dax__adag); pushbuffer(0);
2058   }
2059         YY_BREAK
2060
2061 case 18:
2062 /* rule 18 can match eol */
2063 YY_RULE_SETUP
2064 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);
2065         YY_BREAK
2066 case 19:
2067 /* rule 19 can match eol */
2068 YY_RULE_SETUP
2069 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);
2070         YY_BREAK
2071 case 20:
2072 /* rule 20 can match eol */
2073 YY_RULE_SETUP
2074 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);
2075         YY_BREAK
2076 case 21:
2077 /* rule 21 can match eol */
2078 YY_RULE_SETUP
2079 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);
2080         YY_BREAK
2081 case 22:
2082 /* rule 22 can match eol */
2083 YY_RULE_SETUP
2084 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);
2085         YY_BREAK
2086 case 23:
2087 /* rule 23 can match eol */
2088 YY_RULE_SETUP
2089 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);
2090         YY_BREAK
2091 case 24:
2092 /* rule 24 can match eol */
2093 YY_RULE_SETUP
2094 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);
2095         YY_BREAK
2096 case 25:
2097 /* rule 25 can match eol */
2098 YY_RULE_SETUP
2099 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);
2100         YY_BREAK
2101 case 26:
2102 /* rule 26 can match eol */
2103 YY_RULE_SETUP
2104 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);
2105         YY_BREAK
2106 case 27:
2107 /* rule 27 can match eol */
2108 YY_RULE_SETUP
2109 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);
2110         YY_BREAK
2111 case 28:
2112 /* rule 28 can match eol */
2113 YY_RULE_SETUP
2114 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);
2115         YY_BREAK
2116 case 29:
2117 /* rule 29 can match eol */
2118 YY_RULE_SETUP
2119 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);
2120         YY_BREAK
2121 case 30:
2122 /* rule 30 can match eol */
2123 YY_RULE_SETUP
2124 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);
2125         YY_BREAK
2126 case 31:
2127 /* rule 31 can match eol */
2128 YY_RULE_SETUP
2129 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);
2130         YY_BREAK
2131 case 32:
2132 /* rule 32 can match eol */
2133 YY_RULE_SETUP
2134 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);
2135         YY_BREAK
2136 case 33:
2137 /* rule 33 can match eol */
2138 YY_RULE_SETUP
2139 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);
2140         YY_BREAK
2141 case 34:
2142 /* rule 34 can match eol */
2143 YY_RULE_SETUP
2144 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);
2145         YY_BREAK
2146 case 35:
2147 /* rule 35 can match eol */
2148 YY_RULE_SETUP
2149 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);
2150         YY_BREAK
2151 case 36:
2152 /* rule 36 can match eol */
2153 YY_RULE_SETUP
2154 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);
2155         YY_BREAK
2156 case 37:
2157 /* rule 37 can match eol */
2158 YY_RULE_SETUP
2159 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);
2160         YY_BREAK
2161 case 38:
2162 YY_RULE_SETUP
2163 {
2164   LEAVE; STag_dax__adag();dax__pcdata_ix = 0; ENTER(S_dax__adag);
2165  }
2166         YY_BREAK
2167 case 39:
2168 YY_RULE_SETUP
2169 {
2170   LEAVE; STag_dax__adag(); dax__pcdata_ix = 0; ETag_dax__adag(); popbuffer(); /* attribute */
2171   switch (YY_START) {
2172    case ROOT_dax__adag: SET(EPILOG); break;
2173   }
2174  }
2175         YY_BREAK
2176 case 40:
2177 YY_RULE_SETUP
2178 FAIL("Unexpected character `%c' in attribute list of adag element.", dax_text[0]);
2179         YY_BREAK
2180 case 41:
2181 YY_RULE_SETUP
2182 FAIL("Bad attribute `%s' in `adag' element start tag.",dax_text);
2183         YY_BREAK
2184 case YY_STATE_EOF(AL_dax__adag):
2185 FAIL("EOF in attribute list of `adag' element.");
2186         YY_BREAK
2187
2188 case 42:
2189 /* rule 42 can match eol */
2190 YY_RULE_SETUP
2191 {
2192   LEAVE;
2193   ETag_dax__adag();
2194   popbuffer(); /* attribute */
2195   switch (YY_START) {
2196    case ROOT_dax__adag: SET(EPILOG); break;
2197   }
2198  }
2199         YY_BREAK
2200 case 43:
2201 /* rule 43 can match eol */
2202 YY_RULE_SETUP
2203 FAIL("Unexpected end-tag `%s': `</adag>' expected.",dax_text);
2204         YY_BREAK
2205 case 44:
2206 YY_RULE_SETUP
2207 FAIL("Unexpected character `%c': `</adag>' expected.",dax_text[0]);
2208         YY_BREAK
2209 case YY_STATE_EOF(S_dax__adag_1):
2210 case YY_STATE_EOF(S_dax__adag_5):
2211 case YY_STATE_EOF(E_dax__adag):
2212 case YY_STATE_EOF(S_dax__adag_3):
2213 case YY_STATE_EOF(S_dax__adag):
2214 FAIL("Premature EOF: `</adag>' expected.");
2215         YY_BREAK
2216
2217 case 45:
2218 /* rule 45 can match eol */
2219 YY_RULE_SETUP
2220 FAIL("Starting tag <job> is not allowed here.");
2221         YY_BREAK
2222 case 46:
2223 /* rule 46 can match eol */
2224 YY_RULE_SETUP
2225 {
2226   AX_dax__job_id = 0;
2227   dax__job_id_isset = 0;
2228   AX_dax__job_namespace = 0;
2229   dax__job_namespace_isset = 0;
2230   AX_dax__job_name = 0;
2231   dax__job_name_isset = 0;
2232   AX_dax__job_version = 157;
2233   dax__job_version_isset = 0;
2234   AX_dax__job_runtime = 0;
2235   dax__job_runtime_isset = 0;
2236   AX_dax__job_level = 0;
2237   dax__job_level_isset = 0;
2238   ENTER(AL_dax__job); pushbuffer(0);
2239   }
2240         YY_BREAK
2241
2242 case 47:
2243 /* rule 47 can match eol */
2244 YY_RULE_SETUP
2245 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);
2246         YY_BREAK
2247 case 48:
2248 /* rule 48 can match eol */
2249 YY_RULE_SETUP
2250 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);
2251         YY_BREAK
2252 case 49:
2253 /* rule 49 can match eol */
2254 YY_RULE_SETUP
2255 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);
2256         YY_BREAK
2257 case 50:
2258 /* rule 50 can match eol */
2259 YY_RULE_SETUP
2260 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);
2261         YY_BREAK
2262 case 51:
2263 /* rule 51 can match eol */
2264 YY_RULE_SETUP
2265 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);
2266         YY_BREAK
2267 case 52:
2268 /* rule 52 can match eol */
2269 YY_RULE_SETUP
2270 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);
2271         YY_BREAK
2272 case 53:
2273 /* rule 53 can match eol */
2274 YY_RULE_SETUP
2275 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);
2276         YY_BREAK
2277 case 54:
2278 /* rule 54 can match eol */
2279 YY_RULE_SETUP
2280 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);
2281         YY_BREAK
2282 case 55:
2283 /* rule 55 can match eol */
2284 YY_RULE_SETUP
2285 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);
2286         YY_BREAK
2287 case 56:
2288 /* rule 56 can match eol */
2289 YY_RULE_SETUP
2290 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);
2291         YY_BREAK
2292 case 57:
2293 /* rule 57 can match eol */
2294 YY_RULE_SETUP
2295 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);
2296         YY_BREAK
2297 case 58:
2298 /* rule 58 can match eol */
2299 YY_RULE_SETUP
2300 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);
2301         YY_BREAK
2302 case 59:
2303 YY_RULE_SETUP
2304 {
2305   if (!AX_dax__job_id) FAIL("Required attribute `id' not set for `job' element.");
2306   if (!AX_dax__job_name) FAIL("Required attribute `name' not set for `job' element.");
2307   if (!AX_dax__job_runtime) FAIL("Required attribute `runtime' not set for `job' element.");
2308   LEAVE; STag_dax__job();dax__pcdata_ix = 0; ENTER(S_dax__job);
2309  }
2310         YY_BREAK
2311 case 60:
2312 YY_RULE_SETUP
2313 {
2314   if (!AX_dax__job_id) FAIL("Required attribute `id' not set for `job' element.");
2315   if (!AX_dax__job_name) FAIL("Required attribute `name' not set for `job' element.");
2316   if (!AX_dax__job_runtime) FAIL("Required attribute `runtime' not set for `job' element.");
2317   LEAVE; STag_dax__job(); dax__pcdata_ix = 0; ETag_dax__job(); popbuffer(); /* attribute */
2318   switch (YY_START) {
2319    case S_dax__adag_2: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_3); break;
2320   }
2321  }
2322         YY_BREAK
2323 case 61:
2324 YY_RULE_SETUP
2325 FAIL("Unexpected character `%c' in attribute list of job element.", dax_text[0]);
2326         YY_BREAK
2327 case 62:
2328 YY_RULE_SETUP
2329 FAIL("Bad attribute `%s' in `job' element start tag.",dax_text);
2330         YY_BREAK
2331 case YY_STATE_EOF(AL_dax__job):
2332 FAIL("EOF in attribute list of `job' element.");
2333         YY_BREAK
2334
2335 case 63:
2336 /* rule 63 can match eol */
2337 YY_RULE_SETUP
2338 {
2339   LEAVE;
2340   ETag_dax__job();
2341   popbuffer(); /* attribute */
2342   switch (YY_START) {
2343    case S_dax__adag_2: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_3); break;
2344   }
2345  }
2346         YY_BREAK
2347 case 64:
2348 /* rule 64 can match eol */
2349 YY_RULE_SETUP
2350 FAIL("Unexpected end-tag `%s': `</job>' expected.",dax_text);
2351         YY_BREAK
2352 case 65:
2353 YY_RULE_SETUP
2354 FAIL("Unexpected character `%c': `</job>' expected.",dax_text[0]);
2355         YY_BREAK
2356 case YY_STATE_EOF(S_dax__job):
2357 case YY_STATE_EOF(E_dax__job):
2358 case YY_STATE_EOF(S_dax__job_2):
2359 FAIL("Premature EOF: `</job>' expected.");
2360         YY_BREAK
2361
2362 /* <!-- ignored -->
2363   * <!-- ignored -->  */
2364 case 66:
2365 /* rule 66 can match eol */
2366 YY_RULE_SETUP
2367 FAIL("Starting tag <uses> is not allowed here.");
2368         YY_BREAK
2369 case 67:
2370 /* rule 67 can match eol */
2371 YY_RULE_SETUP
2372 {
2373   AX_dax__uses_file = 0;
2374   dax__uses_file_isset = 0;
2375   AX_dax__uses_link = AU_dax__uses_link;
2376   dax__uses_link_isset = 0;
2377   AX_dax__uses_register = A_dax__uses_register_true;
2378   dax__uses_register_isset = 0;
2379   AX_dax__uses_transfer = A_dax__uses_transfer_true;
2380   dax__uses_transfer_isset = 0;
2381   AX_dax__uses_optional = A_dax__uses_optional_false;
2382   dax__uses_optional_isset = 0;
2383   AX_dax__uses_type = 161;
2384   dax__uses_type_isset = 0;
2385   AX_dax__uses_size = 0;
2386   dax__uses_size_isset = 0;
2387   ENTER(AL_dax__uses); pushbuffer(0);
2388   }
2389         YY_BREAK
2390
2391 case 68:
2392 /* rule 68 can match eol */
2393 YY_RULE_SETUP
2394 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);
2395         YY_BREAK
2396 case 69:
2397 /* rule 69 can match eol */
2398 YY_RULE_SETUP
2399 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);
2400         YY_BREAK
2401 case 70:
2402 /* rule 70 can match eol */
2403 case 71:
2404 /* rule 71 can match eol */
2405 YY_RULE_SETUP
2406 A_dax__uses_link = A_dax__uses_link_input;
2407         YY_BREAK
2408 case 72:
2409 /* rule 72 can match eol */
2410 case 73:
2411 /* rule 73 can match eol */
2412 YY_RULE_SETUP
2413 A_dax__uses_link = A_dax__uses_link_output;
2414         YY_BREAK
2415 case 74:
2416 /* rule 74 can match eol */
2417 case 75:
2418 /* rule 75 can match eol */
2419 YY_RULE_SETUP
2420 A_dax__uses_register = A_dax__uses_register_false;
2421         YY_BREAK
2422 case 76:
2423 /* rule 76 can match eol */
2424 case 77:
2425 /* rule 77 can match eol */
2426 YY_RULE_SETUP
2427 A_dax__uses_register = A_dax__uses_register_true;
2428         YY_BREAK
2429 case 78:
2430 /* rule 78 can match eol */
2431 case 79:
2432 /* rule 79 can match eol */
2433 YY_RULE_SETUP
2434 A_dax__uses_transfer = A_dax__uses_transfer_false;
2435         YY_BREAK
2436 case 80:
2437 /* rule 80 can match eol */
2438 case 81:
2439 /* rule 81 can match eol */
2440 YY_RULE_SETUP
2441 A_dax__uses_transfer = A_dax__uses_transfer_true;
2442         YY_BREAK
2443 case 82:
2444 /* rule 82 can match eol */
2445 case 83:
2446 /* rule 83 can match eol */
2447 YY_RULE_SETUP
2448 A_dax__uses_optional = A_dax__uses_optional_false;
2449         YY_BREAK
2450 case 84:
2451 /* rule 84 can match eol */
2452 case 85:
2453 /* rule 85 can match eol */
2454 YY_RULE_SETUP
2455 A_dax__uses_optional = A_dax__uses_optional_true;
2456         YY_BREAK
2457 case 86:
2458 /* rule 86 can match eol */
2459 YY_RULE_SETUP
2460 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);
2461         YY_BREAK
2462 case 87:
2463 /* rule 87 can match eol */
2464 YY_RULE_SETUP
2465 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);
2466         YY_BREAK
2467 case 88:
2468 /* rule 88 can match eol */
2469 YY_RULE_SETUP
2470 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);
2471         YY_BREAK
2472 case 89:
2473 /* rule 89 can match eol */
2474 YY_RULE_SETUP
2475 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);
2476         YY_BREAK
2477 case 90:
2478 YY_RULE_SETUP
2479 {
2480   if (!AX_dax__uses_file) FAIL("Required attribute `file' not set for `uses' element.");
2481   if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element.");
2482   LEAVE; STag_dax__uses();dax__pcdata_ix = 0; ENTER(E_dax__uses);
2483  }
2484         YY_BREAK
2485 case 91:
2486 YY_RULE_SETUP
2487 {
2488   if (!AX_dax__uses_file) FAIL("Required attribute `file' not set for `uses' element.");
2489   if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element.");
2490   LEAVE; STag_dax__uses(); dax__pcdata_ix = 0; ETag_dax__uses(); popbuffer(); /* attribute */
2491   switch (YY_START) {
2492    case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break;
2493   }
2494  }
2495         YY_BREAK
2496 case 92:
2497 YY_RULE_SETUP
2498 FAIL("Unexpected character `%c' in attribute list of uses element.", dax_text[0]);
2499         YY_BREAK
2500 case 93:
2501 YY_RULE_SETUP
2502 FAIL("Bad attribute `%s' in `uses' element start tag.",dax_text);
2503         YY_BREAK
2504 case YY_STATE_EOF(AL_dax__uses):
2505 FAIL("EOF in attribute list of `uses' element.");
2506         YY_BREAK
2507
2508 case 94:
2509 /* rule 94 can match eol */
2510 YY_RULE_SETUP
2511 {
2512   LEAVE;
2513   ETag_dax__uses();
2514   popbuffer(); /* attribute */
2515   switch (YY_START) {
2516    case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break;
2517   }
2518  }
2519         YY_BREAK
2520 case 95:
2521 /* rule 95 can match eol */
2522 YY_RULE_SETUP
2523 FAIL("Unexpected end-tag `%s': `</uses>' expected.",dax_text);
2524         YY_BREAK
2525 case 96:
2526 YY_RULE_SETUP
2527 FAIL("Unexpected character `%c': `</uses>' expected.",dax_text[0]);
2528         YY_BREAK
2529 case YY_STATE_EOF(E_dax__uses):
2530 FAIL("Premature EOF: `</uses>' expected.");
2531         YY_BREAK
2532
2533 case 97:
2534 /* rule 97 can match eol */
2535 YY_RULE_SETUP
2536 FAIL("Starting tag <child> is not allowed here.");
2537         YY_BREAK
2538 case 98:
2539 /* rule 98 can match eol */
2540 YY_RULE_SETUP
2541 {
2542   AX_dax__child_ref = 0;
2543   dax__child_ref_isset = 0;
2544   ENTER(AL_dax__child); pushbuffer(0);
2545   }
2546         YY_BREAK
2547
2548 case 99:
2549 /* rule 99 can match eol */
2550 YY_RULE_SETUP
2551 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);
2552         YY_BREAK
2553 case 100:
2554 /* rule 100 can match eol */
2555 YY_RULE_SETUP
2556 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);
2557         YY_BREAK
2558 case 101:
2559 YY_RULE_SETUP
2560 {
2561   if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element.");
2562   LEAVE; STag_dax__child();dax__pcdata_ix = 0; ENTER(S_dax__child);
2563  }
2564         YY_BREAK
2565 case 102:
2566 YY_RULE_SETUP
2567 {
2568   if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element.");
2569   LEAVE; STag_dax__child(); dax__pcdata_ix = 0; ETag_dax__child(); popbuffer(); /* attribute */
2570   switch (YY_START) {
2571    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;
2572   }
2573  }
2574         YY_BREAK
2575 case 103:
2576 YY_RULE_SETUP
2577 FAIL("Unexpected character `%c' in attribute list of child element.", dax_text[0]);
2578         YY_BREAK
2579 case 104:
2580 YY_RULE_SETUP
2581 FAIL("Bad attribute `%s' in `child' element start tag.",dax_text);
2582         YY_BREAK
2583 case YY_STATE_EOF(AL_dax__child):
2584 FAIL("EOF in attribute list of `child' element.");
2585         YY_BREAK
2586
2587 case 105:
2588 /* rule 105 can match eol */
2589 YY_RULE_SETUP
2590 {
2591   LEAVE;
2592   ETag_dax__child();
2593   popbuffer(); /* attribute */
2594   switch (YY_START) {
2595    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;
2596   }
2597  }
2598         YY_BREAK
2599 case 106:
2600 /* rule 106 can match eol */
2601 YY_RULE_SETUP
2602 FAIL("Unexpected end-tag `%s': `</child>' expected.",dax_text);
2603         YY_BREAK
2604 case 107:
2605 YY_RULE_SETUP
2606 FAIL("Unexpected character `%c': `</child>' expected.",dax_text[0]);
2607         YY_BREAK
2608 case YY_STATE_EOF(S_dax__child_2):
2609 case YY_STATE_EOF(E_dax__child):
2610 case YY_STATE_EOF(S_dax__child):
2611 FAIL("Premature EOF: `</child>' expected.");
2612         YY_BREAK
2613
2614 case 108:
2615 /* rule 108 can match eol */
2616 YY_RULE_SETUP
2617 FAIL("Starting tag <parent> is not allowed here.");
2618         YY_BREAK
2619 case 109:
2620 /* rule 109 can match eol */
2621 YY_RULE_SETUP
2622 {
2623   AX_dax__parent_ref = 0;
2624   dax__parent_ref_isset = 0;
2625   ENTER(AL_dax__parent); pushbuffer(0);
2626   }
2627         YY_BREAK
2628
2629 case 110:
2630 /* rule 110 can match eol */
2631 YY_RULE_SETUP
2632 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);
2633         YY_BREAK
2634 case 111:
2635 /* rule 111 can match eol */
2636 YY_RULE_SETUP
2637 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);
2638         YY_BREAK
2639 case 112:
2640 YY_RULE_SETUP
2641 {
2642   if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element.");
2643   LEAVE; STag_dax__parent();dax__pcdata_ix = 0; ENTER(E_dax__parent);
2644  }
2645         YY_BREAK
2646 case 113:
2647 YY_RULE_SETUP
2648 {
2649   if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element.");
2650   LEAVE; STag_dax__parent(); dax__pcdata_ix = 0; ETag_dax__parent(); popbuffer(); /* attribute */
2651   switch (YY_START) {
2652    case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break;
2653   }
2654  }
2655         YY_BREAK
2656 case 114:
2657 YY_RULE_SETUP
2658 FAIL("Unexpected character `%c' in attribute list of parent element.", dax_text[0]);
2659         YY_BREAK
2660 case 115:
2661 YY_RULE_SETUP
2662 FAIL("Bad attribute `%s' in `parent' element start tag.",dax_text);
2663         YY_BREAK
2664 case YY_STATE_EOF(AL_dax__parent):
2665 FAIL("EOF in attribute list of `parent' element.");
2666         YY_BREAK
2667
2668 case 116:
2669 /* rule 116 can match eol */
2670 YY_RULE_SETUP
2671 {
2672   LEAVE;
2673   ETag_dax__parent();
2674   popbuffer(); /* attribute */
2675   switch (YY_START) {
2676    case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break;
2677   }
2678  }
2679         YY_BREAK
2680 case 117:
2681 /* rule 117 can match eol */
2682 YY_RULE_SETUP
2683 FAIL("Unexpected end-tag `%s': `</parent>' expected.",dax_text);
2684         YY_BREAK
2685 case 118:
2686 YY_RULE_SETUP
2687 FAIL("Unexpected character `%c': `</parent>' expected.",dax_text[0]);
2688         YY_BREAK
2689 case YY_STATE_EOF(E_dax__parent):
2690 FAIL("Premature EOF: `</parent>' expected.");
2691         YY_BREAK
2692
2693 /* EPILOG: after the root element. */
2694
2695 case 119:
2696 YY_RULE_SETUP
2697 {SET(PROLOG); yyless(0); CLEANUP; return -1;}
2698         YY_BREAK
2699 case YY_STATE_EOF(EPILOG):
2700 SUCCEED;
2701         YY_BREAK
2702
2703 /* CHARACTER DATA. */
2704
2705 /* Non-defined standard entities... */
2706 case 120:
2707 YY_RULE_SETUP
2708 BUFFERPUTC('&');
2709         YY_BREAK
2710 case 121:
2711 YY_RULE_SETUP
2712 BUFFERPUTC('<');
2713         YY_BREAK
2714 case 122:
2715 YY_RULE_SETUP
2716 BUFFERPUTC('>');
2717         YY_BREAK
2718 case 123:
2719 YY_RULE_SETUP
2720 BUFFERPUTC('\'');
2721         YY_BREAK
2722 case 124:
2723 YY_RULE_SETUP
2724 BUFFERPUTC('"');
2725         YY_BREAK
2726 /* Character entities. */
2727 case 125:
2728 YY_RULE_SETUP
2729 BUFFERPUTC((unsigned char)atoi(dax_text+2));
2730         YY_BREAK
2731 case 126:
2732 YY_RULE_SETUP
2733 BUFFERPUTC((unsigned char)strtol(dax_text+3,NULL,16));
2734         YY_BREAK
2735
2736 case 127:
2737 /* rule 127 can match eol */
2738 case 128:
2739 /* rule 128 can match eol */
2740 case 129:
2741 /* rule 129 can match eol */
2742 case 130:
2743 /* rule 130 can match eol */
2744 YY_RULE_SETUP
2745 BUFFERPUTC('\n');
2746         YY_BREAK
2747
2748 case 131:
2749 YY_RULE_SETUP
2750 ENTER(CDATA);
2751         YY_BREAK
2752 case 132:
2753 YY_RULE_SETUP
2754 FAIL("Unexpected `]""]>' in character data.");
2755         YY_BREAK
2756
2757 case 133:
2758 YY_RULE_SETUP
2759 BUFFERDONE; LEAVE;
2760         YY_BREAK
2761 case YY_STATE_EOF(VALUE1):
2762 FAIL("EOF in literal (\"'\" expected).");
2763         YY_BREAK
2764
2765 case 134:
2766 YY_RULE_SETUP
2767 BUFFERDONE; LEAVE;
2768         YY_BREAK
2769 case YY_STATE_EOF(VALUE2):
2770 FAIL("EOF in literal (`\"' expected).");
2771         YY_BREAK
2772
2773 case 135:
2774 /* rule 135 can match eol */
2775 YY_RULE_SETUP
2776 BUFFERPUTC(dax_text[0]);
2777         YY_BREAK
2778 case 136:
2779 YY_RULE_SETUP
2780 FAIL("Spurious `%c' in character data.",dax_text[0]);
2781         YY_BREAK
2782
2783 case 137:
2784 YY_RULE_SETUP
2785 LEAVE;
2786         YY_BREAK
2787 /* "]""]"               BUFFERPUTC(dax_text[0]); BUFFERPUTC(dax_text[1]); */
2788 case 138:
2789 YY_RULE_SETUP
2790 BUFFERPUTC(dax_text[0]);
2791         YY_BREAK
2792 case YY_STATE_EOF(CDATA):
2793 FAIL("EOF in CDATA section.");
2794         YY_BREAK
2795
2796 /* Impossible rules to avoid warnings from flex(1). */
2797 /* Ideally, this should be replaced by code in flexml.pl that
2798     generates just the states not covered by other rules. */
2799
2800 case 139:
2801 /* rule 139 can match eol */
2802 YY_RULE_SETUP
2803 FAIL("Syntax error on character `%c'.", dax_text[0]);
2804         YY_BREAK
2805
2806 case 140:
2807 YY_RULE_SETUP
2808 ECHO;
2809         YY_BREAK
2810 case YY_STATE_EOF(INITIAL):
2811 case YY_STATE_EOF(ROOT_dax__adag):
2812 case YY_STATE_EOF(S_dax__adag_2):
2813 case YY_STATE_EOF(S_dax__adag_4):
2814 case YY_STATE_EOF(S_dax__job_1):
2815 case YY_STATE_EOF(S_dax__child_1):
2816 case YY_STATE_EOF(IMPOSSIBLE):
2817         yyterminate();
2818
2819         case YY_END_OF_BUFFER:
2820                 {
2821                 /* Amount of text matched not including the EOB char. */
2822                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
2823
2824                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2825                 *yy_cp = (yy_hold_char);
2826                 YY_RESTORE_YY_MORE_OFFSET
2827
2828                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
2829                         {
2830                         /* We're scanning a new file or input source.  It's
2831                          * possible that this happened because the user
2832                          * just pointed dax_in at a new source and called
2833                          * dax_lex().  If so, then we have to assure
2834                          * consistency between YY_CURRENT_BUFFER and our
2835                          * globals.  Here is the right place to do so, because
2836                          * this is the first action (other than possibly a
2837                          * back-up) that will match for the new input source.
2838                          */
2839                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2840                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = dax_in;
2841                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
2842                         }
2843
2844                 /* Note that here we test for yy_c_buf_p "<=" to the position
2845                  * of the first EOB in the buffer, since yy_c_buf_p will
2846                  * already have been incremented past the NUL character
2847                  * (since all states make transitions on EOB to the
2848                  * end-of-buffer state).  Contrast this with the test
2849                  * in input().
2850                  */
2851                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2852                         { /* This was really a NUL. */
2853                         yy_state_type yy_next_state;
2854
2855                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
2856
2857                         yy_current_state = yy_get_previous_state(  );
2858
2859                         /* Okay, we're now positioned to make the NUL
2860                          * transition.  We couldn't have
2861                          * yy_get_previous_state() go ahead and do it
2862                          * for us because it doesn't know how to deal
2863                          * with the possibility of jamming (and we don't
2864                          * want to build jamming into it because then it
2865                          * will run more slowly).
2866                          */
2867
2868                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2869
2870                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2871
2872                         if ( yy_next_state )
2873                                 {
2874                                 /* Consume the NUL. */
2875                                 yy_cp = ++(yy_c_buf_p);
2876                                 yy_current_state = yy_next_state;
2877                                 goto yy_match;
2878                                 }
2879
2880                         else
2881                                 {
2882                                 yy_cp = (yy_c_buf_p);
2883                                 goto yy_find_action;
2884                                 }
2885                         }
2886
2887                 else switch ( yy_get_next_buffer(  ) )
2888                         {
2889                         case EOB_ACT_END_OF_FILE:
2890                                 {
2891                                 (yy_did_buffer_switch_on_eof) = 0;
2892
2893                                 if ( dax_wrap( ) )
2894                                         {
2895                                         /* Note: because we've taken care in
2896                                          * yy_get_next_buffer() to have set up
2897                                          * dax_text, we can now set up
2898                                          * yy_c_buf_p so that if some total
2899                                          * hoser (like flex itself) wants to
2900                                          * call the scanner after we return the
2901                                          * YY_NULL, it'll still work - another
2902                                          * YY_NULL will get returned.
2903                                          */
2904                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2905
2906                                         yy_act = YY_STATE_EOF(YY_START);
2907                                         goto do_action;
2908                                         }
2909
2910                                 else
2911                                         {
2912                                         if ( ! (yy_did_buffer_switch_on_eof) )
2913                                                 YY_NEW_FILE;
2914                                         }
2915                                 break;
2916                                 }
2917
2918                         case EOB_ACT_CONTINUE_SCAN:
2919                                 (yy_c_buf_p) =
2920                                         (yytext_ptr) + yy_amount_of_matched_text;
2921
2922                                 yy_current_state = yy_get_previous_state(  );
2923
2924                                 yy_cp = (yy_c_buf_p);
2925                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2926                                 goto yy_match;
2927
2928                         case EOB_ACT_LAST_MATCH:
2929                                 (yy_c_buf_p) =
2930                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2931
2932                                 yy_current_state = yy_get_previous_state(  );
2933
2934                                 yy_cp = (yy_c_buf_p);
2935                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2936                                 goto yy_find_action;
2937                         }
2938                 break;
2939                 }
2940
2941         default:
2942                 YY_FATAL_ERROR(
2943                         "fatal flex scanner internal error--no action found" );
2944         } /* end of action switch */
2945                 } /* end of scanning one token */
2946 } /* end of dax_lex */
2947
2948 /* yy_get_next_buffer - try to read in a new buffer
2949  *
2950  * Returns a code representing an action:
2951  *      EOB_ACT_LAST_MATCH -
2952  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2953  *      EOB_ACT_END_OF_FILE - end of file
2954  */
2955 static int yy_get_next_buffer (void)
2956 {
2957         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2958         register char *source = (yytext_ptr);
2959         register int number_to_move, i;
2960         int ret_val;
2961
2962         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2963                 YY_FATAL_ERROR(
2964                 "fatal flex scanner internal error--end of buffer missed" );
2965
2966         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2967                 { /* Don't try to fill the buffer, so this is an EOF. */
2968                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2969                         {
2970                         /* We matched a single character, the EOB, so
2971                          * treat this as a final EOF.
2972                          */
2973                         return EOB_ACT_END_OF_FILE;
2974                         }
2975
2976                 else
2977                         {
2978                         /* We matched some text prior to the EOB, first
2979                          * process it.
2980                          */
2981                         return EOB_ACT_LAST_MATCH;
2982                         }
2983                 }
2984
2985         /* Try to read more data. */
2986
2987         /* First move last chars to start of buffer. */
2988         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2989
2990         for ( i = 0; i < number_to_move; ++i )
2991                 *(dest++) = *(source++);
2992
2993         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2994                 /* don't do the read, it's not guaranteed to return an EOF,
2995                  * just force an EOF
2996                  */
2997                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2998
2999         else
3000                 {
3001                         int num_to_read =
3002                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
3003
3004                 while ( num_to_read <= 0 )
3005                         { /* Not enough room in the buffer - grow it. */
3006
3007                         /* just a shorter name for the current buffer */
3008                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
3009
3010                         int yy_c_buf_p_offset =
3011                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
3012
3013                         if ( b->yy_is_our_buffer )
3014                                 {
3015                                 int new_size = b->yy_buf_size * 2;
3016
3017                                 if ( new_size <= 0 )
3018                                         b->yy_buf_size += b->yy_buf_size / 8;
3019                                 else
3020                                         b->yy_buf_size *= 2;
3021
3022                                 b->yy_ch_buf = (char *)
3023                                         /* Include room in for 2 EOB chars. */
3024                                         dax_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
3025                                 }
3026                         else
3027                                 /* Can't grow it, we don't own it. */
3028                                 b->yy_ch_buf = 0;
3029
3030                         if ( ! b->yy_ch_buf )
3031                                 YY_FATAL_ERROR(
3032                                 "fatal error - scanner input buffer overflow" );
3033
3034                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
3035
3036                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
3037                                                 number_to_move - 1;
3038
3039                         }
3040
3041                 if ( num_to_read > YY_READ_BUF_SIZE )
3042                         num_to_read = YY_READ_BUF_SIZE;
3043
3044                 /* Read in more data. */
3045                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
3046                         (yy_n_chars), (size_t) num_to_read );
3047
3048                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3049                 }
3050
3051         if ( (yy_n_chars) == 0 )
3052                 {
3053                 if ( number_to_move == YY_MORE_ADJ )
3054                         {
3055                         ret_val = EOB_ACT_END_OF_FILE;
3056                         dax_restart(dax_in  );
3057                         }
3058
3059                 else
3060                         {
3061                         ret_val = EOB_ACT_LAST_MATCH;
3062                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
3063                                 YY_BUFFER_EOF_PENDING;
3064                         }
3065                 }
3066
3067         else
3068                 ret_val = EOB_ACT_CONTINUE_SCAN;
3069
3070         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
3071                 /* Extend the array by 50%, plus the number we really need. */
3072                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
3073                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) dax_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
3074                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3075                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3076         }
3077
3078         (yy_n_chars) += number_to_move;
3079         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
3080         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
3081
3082         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
3083
3084         return ret_val;
3085 }
3086
3087 /* yy_get_previous_state - get the state just before the EOB char was reached */
3088
3089     static yy_state_type yy_get_previous_state (void)
3090 {
3091         register yy_state_type yy_current_state;
3092         register char *yy_cp;
3093     
3094         yy_current_state = (yy_start);
3095
3096         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
3097                 {
3098                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
3099                 if ( yy_accept[yy_current_state] )
3100                         {
3101                         (yy_last_accepting_state) = yy_current_state;
3102                         (yy_last_accepting_cpos) = yy_cp;
3103                         }
3104                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3105                         {
3106                         yy_current_state = (int) yy_def[yy_current_state];
3107                         if ( yy_current_state >= 775 )
3108                                 yy_c = yy_meta[(unsigned int) yy_c];
3109                         }
3110                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3111                 }
3112
3113         return yy_current_state;
3114 }
3115
3116 /* yy_try_NUL_trans - try to make a transition on the NUL character
3117  *
3118  * synopsis
3119  *      next_state = yy_try_NUL_trans( current_state );
3120  */
3121     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
3122 {
3123         register int yy_is_jam;
3124         register char *yy_cp = (yy_c_buf_p);
3125
3126         register YY_CHAR yy_c = 1;
3127         if ( yy_accept[yy_current_state] )
3128                 {
3129                 (yy_last_accepting_state) = yy_current_state;
3130                 (yy_last_accepting_cpos) = yy_cp;
3131                 }
3132         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
3133                 {
3134                 yy_current_state = (int) yy_def[yy_current_state];
3135                 if ( yy_current_state >= 775 )
3136                         yy_c = yy_meta[(unsigned int) yy_c];
3137                 }
3138         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
3139         yy_is_jam = (yy_current_state == 774);
3140
3141         return yy_is_jam ? 0 : yy_current_state;
3142 }
3143
3144 #ifndef YY_NO_INPUT
3145 #ifdef __cplusplus
3146     static int yyinput (void)
3147 #else
3148     static int input  (void)
3149 #endif
3150
3151 {
3152         int c;
3153     
3154         *(yy_c_buf_p) = (yy_hold_char);
3155
3156         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
3157                 {
3158                 /* yy_c_buf_p now points to the character we want to return.
3159                  * If this occurs *before* the EOB characters, then it's a
3160                  * valid NUL; if not, then we've hit the end of the buffer.
3161                  */
3162                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3163                         /* This was really a NUL. */
3164                         *(yy_c_buf_p) = '\0';
3165
3166                 else
3167                         { /* need more input */
3168                         int offset = (yy_c_buf_p) - (yytext_ptr);
3169                         ++(yy_c_buf_p);
3170
3171                         switch ( yy_get_next_buffer(  ) )
3172                                 {
3173                                 case EOB_ACT_LAST_MATCH:
3174                                         /* This happens because yy_g_n_b()
3175                                          * sees that we've accumulated a
3176                                          * token and flags that we need to
3177                                          * try matching the token before
3178                                          * proceeding.  But for input(),
3179                                          * there's no matching to consider.
3180                                          * So convert the EOB_ACT_LAST_MATCH
3181                                          * to EOB_ACT_END_OF_FILE.
3182                                          */
3183
3184                                         /* Reset buffer status. */
3185                                         dax_restart(dax_in );
3186
3187                                         /*FALLTHROUGH*/
3188
3189                                 case EOB_ACT_END_OF_FILE:
3190                                         {
3191                                         if ( dax_wrap( ) )
3192                                                 return EOF;
3193
3194                                         if ( ! (yy_did_buffer_switch_on_eof) )
3195                                                 YY_NEW_FILE;
3196 #ifdef __cplusplus
3197                                         return yyinput();
3198 #else
3199                                         return input();
3200 #endif
3201                                         }
3202
3203                                 case EOB_ACT_CONTINUE_SCAN:
3204                                         (yy_c_buf_p) = (yytext_ptr) + offset;
3205                                         break;
3206                                 }
3207                         }
3208                 }
3209
3210         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
3211         *(yy_c_buf_p) = '\0';   /* preserve dax_text */
3212         (yy_hold_char) = *++(yy_c_buf_p);
3213
3214         if ( c == '\n' )
3215                    
3216     dax_lineno++;
3217 ;
3218
3219         return c;
3220 }
3221 #endif  /* ifndef YY_NO_INPUT */
3222
3223 /** Immediately switch to a different input stream.
3224  * @param input_file A readable stream.
3225  * 
3226  * @note This function does not reset the start condition to @c INITIAL .
3227  */
3228     void dax_restart  (FILE * input_file )
3229 {
3230     
3231         if ( ! YY_CURRENT_BUFFER ){
3232         dax_ensure_buffer_stack ();
3233                 YY_CURRENT_BUFFER_LVALUE =
3234             dax__create_buffer(dax_in,YY_BUF_SIZE );
3235         }
3236
3237         dax__init_buffer(YY_CURRENT_BUFFER,input_file );
3238         dax__load_buffer_state( );
3239 }
3240
3241 /** Switch to a different input buffer.
3242  * @param new_buffer The new input buffer.
3243  * 
3244  */
3245     void dax__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
3246 {
3247     
3248         /* TODO. We should be able to replace this entire function body
3249          * with
3250          *              dax_pop_buffer_state();
3251          *              dax_push_buffer_state(new_buffer);
3252      */
3253         dax_ensure_buffer_stack ();
3254         if ( YY_CURRENT_BUFFER == new_buffer )
3255                 return;
3256
3257         if ( YY_CURRENT_BUFFER )
3258                 {
3259                 /* Flush out information for old buffer. */
3260                 *(yy_c_buf_p) = (yy_hold_char);
3261                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3262                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3263                 }
3264
3265         YY_CURRENT_BUFFER_LVALUE = new_buffer;
3266         dax__load_buffer_state( );
3267
3268         /* We don't actually know whether we did this switch during
3269          * EOF (dax_wrap()) processing, but the only time this flag
3270          * is looked at is after dax_wrap() is called, so it's safe
3271          * to go ahead and always set it.
3272          */
3273         (yy_did_buffer_switch_on_eof) = 1;
3274 }
3275
3276 static void dax__load_buffer_state  (void)
3277 {
3278         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3279         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
3280         dax_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
3281         (yy_hold_char) = *(yy_c_buf_p);
3282 }
3283
3284 /** Allocate and initialize an input buffer state.
3285  * @param file A readable stream.
3286  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
3287  * 
3288  * @return the allocated buffer state.
3289  */
3290     YY_BUFFER_STATE dax__create_buffer  (FILE * file, int  size )
3291 {
3292         YY_BUFFER_STATE b;
3293     
3294         b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
3295         if ( ! b )
3296                 YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
3297
3298         b->yy_buf_size = size;
3299
3300         /* yy_ch_buf has to be 2 characters longer than the size given because
3301          * we need to put in 2 end-of-buffer characters.
3302          */
3303         b->yy_ch_buf = (char *) dax_alloc(b->yy_buf_size + 2  );
3304         if ( ! b->yy_ch_buf )
3305                 YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
3306
3307         b->yy_is_our_buffer = 1;
3308
3309         dax__init_buffer(b,file );
3310
3311         return b;
3312 }
3313
3314 /** Destroy the buffer.
3315  * @param b a buffer created with dax__create_buffer()
3316  * 
3317  */
3318     void dax__delete_buffer (YY_BUFFER_STATE  b )
3319 {
3320     
3321         if ( ! b )
3322                 return;
3323
3324         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
3325                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3326
3327         if ( b->yy_is_our_buffer )
3328                 dax_free((void *) b->yy_ch_buf  );
3329
3330         dax_free((void *) b  );
3331 }
3332
3333 #ifndef __cplusplus
3334 extern int isatty (int );
3335 #endif /* __cplusplus */
3336     
3337 /* Initializes or reinitializes a buffer.
3338  * This function is sometimes called more than once on the same buffer,
3339  * such as during a dax_restart() or at EOF.
3340  */
3341     static void dax__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
3342
3343 {
3344         int oerrno = errno;
3345     
3346         dax__flush_buffer(b );
3347
3348         b->yy_input_file = file;
3349         b->yy_fill_buffer = 1;
3350
3351     /* If b is the current buffer, then dax__init_buffer was _probably_
3352      * called from dax_restart() or through yy_get_next_buffer.
3353      * In that case, we don't want to reset the lineno or column.
3354      */
3355     if (b != YY_CURRENT_BUFFER){
3356         b->yy_bs_lineno = 1;
3357         b->yy_bs_column = 0;
3358     }
3359
3360         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3361     
3362         errno = oerrno;
3363 }
3364
3365 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
3366  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
3367  * 
3368  */
3369     void dax__flush_buffer (YY_BUFFER_STATE  b )
3370 {
3371         if ( ! b )
3372                 return;
3373
3374         b->yy_n_chars = 0;
3375
3376         /* We always need two end-of-buffer characters.  The first causes
3377          * a transition to the end-of-buffer state.  The second causes
3378          * a jam in that state.
3379          */
3380         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3381         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3382
3383         b->yy_buf_pos = &b->yy_ch_buf[0];
3384
3385         b->yy_at_bol = 1;
3386         b->yy_buffer_status = YY_BUFFER_NEW;
3387
3388         if ( b == YY_CURRENT_BUFFER )
3389                 dax__load_buffer_state( );
3390 }
3391
3392 /** Pushes the new state onto the stack. The new state becomes
3393  *  the current state. This function will allocate the stack
3394  *  if necessary.
3395  *  @param new_buffer The new state.
3396  *  
3397  */
3398 void dax_push_buffer_state (YY_BUFFER_STATE new_buffer )
3399 {
3400         if (new_buffer == NULL)
3401                 return;
3402
3403         dax_ensure_buffer_stack();
3404
3405         /* This block is copied from dax__switch_to_buffer. */
3406         if ( YY_CURRENT_BUFFER )
3407                 {
3408                 /* Flush out information for old buffer. */
3409                 *(yy_c_buf_p) = (yy_hold_char);
3410                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
3411                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
3412                 }
3413
3414         /* Only push if top exists. Otherwise, replace top. */
3415         if (YY_CURRENT_BUFFER)
3416                 (yy_buffer_stack_top)++;
3417         YY_CURRENT_BUFFER_LVALUE = new_buffer;
3418
3419         /* copied from dax__switch_to_buffer. */
3420         dax__load_buffer_state( );
3421         (yy_did_buffer_switch_on_eof) = 1;
3422 }
3423
3424 /** Removes and deletes the top of the stack, if present.
3425  *  The next element becomes the new top.
3426  *  
3427  */
3428 void dax_pop_buffer_state (void)
3429 {
3430         if (!YY_CURRENT_BUFFER)
3431                 return;
3432
3433         dax__delete_buffer(YY_CURRENT_BUFFER );
3434         YY_CURRENT_BUFFER_LVALUE = NULL;
3435         if ((yy_buffer_stack_top) > 0)
3436                 --(yy_buffer_stack_top);
3437
3438         if (YY_CURRENT_BUFFER) {
3439                 dax__load_buffer_state( );
3440                 (yy_did_buffer_switch_on_eof) = 1;
3441         }
3442 }
3443
3444 /* Allocates the stack if it does not exist.
3445  *  Guarantees space for at least one push.
3446  */
3447 static void dax_ensure_buffer_stack (void)
3448 {
3449         int num_to_alloc;
3450     
3451         if (!(yy_buffer_stack)) {
3452
3453                 /* First allocation is just for 2 elements, since we don't know if this
3454                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
3455                  * immediate realloc on the next call.
3456          */
3457                 num_to_alloc = 1;
3458                 (yy_buffer_stack) = (struct yy_buffer_state**)dax_alloc
3459                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
3460                                                                 );
3461                 if ( ! (yy_buffer_stack) )
3462                         YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
3463                                                                   
3464                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
3465                                 
3466                 (yy_buffer_stack_max) = num_to_alloc;
3467                 (yy_buffer_stack_top) = 0;
3468                 return;
3469         }
3470
3471         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
3472
3473                 /* Increase the buffer to prepare for a possible push. */
3474                 int grow_size = 8 /* arbitrary grow size */;
3475
3476                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
3477                 (yy_buffer_stack) = (struct yy_buffer_state**)dax_realloc
3478                                                                 ((yy_buffer_stack),
3479                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
3480                                                                 );
3481                 if ( ! (yy_buffer_stack) )
3482                         YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
3483
3484                 /* zero only the new slots.*/
3485                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
3486                 (yy_buffer_stack_max) = num_to_alloc;
3487         }
3488 }
3489
3490 /** Setup the input buffer state to scan directly from a user-specified character buffer.
3491  * @param base the character buffer
3492  * @param size the size in bytes of the character buffer
3493  * 
3494  * @return the newly allocated buffer state object. 
3495  */
3496 YY_BUFFER_STATE dax__scan_buffer  (char * base, yy_size_t  size )
3497 {
3498         YY_BUFFER_STATE b;
3499     
3500         if ( size < 2 ||
3501              base[size-2] != YY_END_OF_BUFFER_CHAR ||
3502              base[size-1] != YY_END_OF_BUFFER_CHAR )
3503                 /* They forgot to leave room for the EOB's. */
3504                 return 0;
3505
3506         b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
3507         if ( ! b )
3508                 YY_FATAL_ERROR( "out of dynamic memory in dax__scan_buffer()" );
3509
3510         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
3511         b->yy_buf_pos = b->yy_ch_buf = base;
3512         b->yy_is_our_buffer = 0;
3513         b->yy_input_file = 0;
3514         b->yy_n_chars = b->yy_buf_size;
3515         b->yy_is_interactive = 0;
3516         b->yy_at_bol = 1;
3517         b->yy_fill_buffer = 0;
3518         b->yy_buffer_status = YY_BUFFER_NEW;
3519
3520         dax__switch_to_buffer(b  );
3521
3522         return b;
3523 }
3524
3525 /** Setup the input buffer state to scan a string. The next call to dax_lex() will
3526  * scan from a @e copy of @a str.
3527  * @param yystr a NUL-terminated string to scan
3528  * 
3529  * @return the newly allocated buffer state object.
3530  * @note If you want to scan bytes that may contain NUL values, then use
3531  *       dax__scan_bytes() instead.
3532  */
3533 YY_BUFFER_STATE dax__scan_string (yyconst char * yystr )
3534 {
3535     
3536         return dax__scan_bytes(yystr,strlen(yystr) );
3537 }
3538
3539 /** Setup the input buffer state to scan the given bytes. The next call to dax_lex() will
3540  * scan from a @e copy of @a bytes.
3541  * @param yybytes the byte buffer to scan
3542  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
3543  * 
3544  * @return the newly allocated buffer state object.
3545  */
3546 YY_BUFFER_STATE dax__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
3547 {
3548         YY_BUFFER_STATE b;
3549         char *buf;
3550         yy_size_t n;
3551         int i;
3552     
3553         /* Get memory for full buffer, including space for trailing EOB's. */
3554         n = _yybytes_len + 2;
3555         buf = (char *) dax_alloc(n  );
3556         if ( ! buf )
3557                 YY_FATAL_ERROR( "out of dynamic memory in dax__scan_bytes()" );
3558
3559         for ( i = 0; i < _yybytes_len; ++i )
3560                 buf[i] = yybytes[i];
3561
3562         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
3563
3564         b = dax__scan_buffer(buf,n );
3565         if ( ! b )
3566                 YY_FATAL_ERROR( "bad buffer in dax__scan_bytes()" );
3567
3568         /* It's okay to grow etc. this buffer, and we should throw it
3569          * away when we're done.
3570          */
3571         b->yy_is_our_buffer = 1;
3572
3573         return b;
3574 }
3575
3576     static void yy_push_state (int  new_state )
3577 {
3578         if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
3579                 {
3580                 yy_size_t new_size;
3581
3582                 (yy_start_stack_depth) += YY_START_STACK_INCR;
3583                 new_size = (yy_start_stack_depth) * sizeof( int );
3584
3585                 if ( ! (yy_start_stack) )
3586                         (yy_start_stack) = (int *) dax_alloc(new_size  );
3587
3588                 else
3589                         (yy_start_stack) = (int *) dax_realloc((void *) (yy_start_stack),new_size  );
3590
3591                 if ( ! (yy_start_stack) )
3592                         YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
3593                 }
3594
3595         (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
3596
3597         BEGIN(new_state);
3598 }
3599
3600     static void yy_pop_state  (void)
3601 {
3602         if ( --(yy_start_stack_ptr) < 0 )
3603                 YY_FATAL_ERROR( "start-condition stack underflow" );
3604
3605         BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
3606 }
3607
3608 #ifndef YY_EXIT_FAILURE
3609 #define YY_EXIT_FAILURE 2
3610 #endif
3611
3612 static void yy_fatal_error (yyconst char* msg )
3613 {
3614         (void) fprintf( stderr, "%s\n", msg );
3615         exit( YY_EXIT_FAILURE );
3616 }
3617
3618 /* Redefine yyless() so it works in section 3 code. */
3619
3620 #undef yyless
3621 #define yyless(n) \
3622         do \
3623                 { \
3624                 /* Undo effects of setting up dax_text. */ \
3625         int yyless_macro_arg = (n); \
3626         YY_LESS_LINENO(yyless_macro_arg);\
3627                 dax_text[dax_leng] = (yy_hold_char); \
3628                 (yy_c_buf_p) = dax_text + yyless_macro_arg; \
3629                 (yy_hold_char) = *(yy_c_buf_p); \
3630                 *(yy_c_buf_p) = '\0'; \
3631                 dax_leng = yyless_macro_arg; \
3632                 } \
3633         while ( 0 )
3634
3635 /* Accessor  methods (get/set functions) to struct members. */
3636
3637 /** Get the current line number.
3638  * 
3639  */
3640 int dax_get_lineno  (void)
3641 {
3642         
3643     return dax_lineno;
3644 }
3645
3646 /** Get the input stream.
3647  * 
3648  */
3649 FILE *dax_get_in  (void)
3650 {
3651         return dax_in;
3652 }
3653
3654 /** Get the output stream.
3655  * 
3656  */
3657 FILE *dax_get_out  (void)
3658 {
3659         return dax_out;
3660 }
3661
3662 /** Get the length of the current token.
3663  * 
3664  */
3665 int dax_get_leng  (void)
3666 {
3667         return dax_leng;
3668 }
3669
3670 /** Get the current token.
3671  * 
3672  */
3673
3674 char *dax_get_text  (void)
3675 {
3676         return dax_text;
3677 }
3678
3679 /** Set the current line number.
3680  * @param line_number
3681  * 
3682  */
3683 void dax_set_lineno (int  line_number )
3684 {
3685     
3686     dax_lineno = line_number;
3687 }
3688
3689 /** Set the input stream. This does not discard the current
3690  * input buffer.
3691  * @param in_str A readable stream.
3692  * 
3693  * @see dax__switch_to_buffer
3694  */
3695 void dax_set_in (FILE *  in_str )
3696 {
3697         dax_in = in_str ;
3698 }
3699
3700 void dax_set_out (FILE *  out_str )
3701 {
3702         dax_out = out_str ;
3703 }
3704
3705 int dax_get_debug  (void)
3706 {
3707         return dax__flex_debug;
3708 }
3709
3710 void dax_set_debug (int  bdebug )
3711 {
3712         dax__flex_debug = bdebug ;
3713 }
3714
3715 static int yy_init_globals (void)
3716 {
3717         /* Initialization is the same as for the non-reentrant scanner.
3718      * This function is called from dax_lex_destroy(), so don't allocate here.
3719      */
3720
3721     /* We do not touch dax_lineno unless the option is enabled. */
3722     dax_lineno =  1;
3723     
3724     (yy_buffer_stack) = 0;
3725     (yy_buffer_stack_top) = 0;
3726     (yy_buffer_stack_max) = 0;
3727     (yy_c_buf_p) = (char *) 0;
3728     (yy_init) = 0;
3729     (yy_start) = 0;
3730
3731     (yy_start_stack_ptr) = 0;
3732     (yy_start_stack_depth) = 0;
3733     (yy_start_stack) =  NULL;
3734
3735 /* Defined in main.c */
3736 #ifdef YY_STDINIT
3737     dax_in = stdin;
3738     dax_out = stdout;
3739 #else
3740     dax_in = (FILE *) 0;
3741     dax_out = (FILE *) 0;
3742 #endif
3743
3744     /* For future reference: Set errno on error, since we are called by
3745      * dax_lex_init()
3746      */
3747     return 0;
3748 }
3749
3750 /* dax_lex_destroy is for both reentrant and non-reentrant scanners. */
3751 int dax_lex_destroy  (void)
3752 {
3753     
3754     /* Pop the buffer stack, destroying each element. */
3755         while(YY_CURRENT_BUFFER){
3756                 dax__delete_buffer(YY_CURRENT_BUFFER  );
3757                 YY_CURRENT_BUFFER_LVALUE = NULL;
3758                 dax_pop_buffer_state();
3759         }
3760
3761         /* Destroy the stack itself. */
3762         dax_free((yy_buffer_stack) );
3763         (yy_buffer_stack) = NULL;
3764
3765     /* Destroy the start condition stack. */
3766         dax_free((yy_start_stack)  );
3767         (yy_start_stack) = NULL;
3768
3769     /* Reset the globals. This is important in a non-reentrant scanner so the next time
3770      * dax_lex() is called, initialization will occur. */
3771     yy_init_globals( );
3772
3773     return 0;
3774 }
3775
3776 /*
3777  * Internal utility routines.
3778  */
3779
3780 #ifndef yytext_ptr
3781 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
3782 {
3783         register int i;
3784         for ( i = 0; i < n; ++i )
3785                 s1[i] = s2[i];
3786 }
3787 #endif
3788
3789 #ifdef YY_NEED_STRLEN
3790 static int yy_flex_strlen (yyconst char * s )
3791 {
3792         register int n;
3793         for ( n = 0; s[n]; ++n )
3794                 ;
3795
3796         return n;
3797 }
3798 #endif
3799
3800 void *dax_alloc (yy_size_t  size )
3801 {
3802         return (void *) malloc( size );
3803 }
3804
3805 void *dax_realloc  (void * ptr, yy_size_t  size )
3806 {
3807         /* The cast to (char *) in the following accommodates both
3808          * implementations that use char* generic pointers, and those
3809          * that use void* generic pointers.  It works with the latter
3810          * because both ANSI C and C++ allow castless assignment from
3811          * any pointer type to void*, and deal with argument conversions
3812          * as though doing an assignment.
3813          */
3814         return (void *) realloc( (char *) ptr, size );
3815 }
3816
3817 void dax_free (void * ptr )
3818 {
3819         free( (char *) ptr );   /* see dax_realloc() for (char *) cast */
3820 }
3821
3822 #define YYTABLES_NAME "yytables"
3823
3824 /* Element context stack lookup. */
3825 int dax__element_context(int i)
3826 {
3827   return (0<i && i<yy_start_stack_depth
3828           ? yy_start_stack[yy_start_stack_ptr - i]
3829           : 0);
3830 }
3831
3832 #ifdef FLEX_DEBUG
3833 void print_yy_stack(char* fmt, ...)
3834 {
3835   int i = 0; va_list ap; va_start(ap, fmt);
3836   vfprintf(stderr, fmt, ap);
3837   if (dax__statenames) {
3838       for (i=1; i<yy_start_stack_ptr; i++) {
3839           fprintf(stderr, "%s/", dax__statenames[yy_start_stack[i] ]);
3840       }
3841       fprintf(stderr,"%s\n", dax__statenames[YY_START]);
3842   }
3843   va_end(ap);
3844 }
3845
3846 void print_dax__bufferstack()
3847 {
3848     int i;
3849     fputs("Buffer: ", stderr);
3850     for (i = 0; i < blimit; i++) {
3851        if ( dax__bufferstack[i] == '\377' ) break;
3852          putc(dax__bufferstack[i], stderr);
3853     }
3854     putc('\n', stderr);
3855 }
3856
3857 static void debug_enter(int state, const char* statename) {
3858   yy_push_state(state);
3859   if (dax__flex_debug) {
3860        print_yy_stack("--ENTER(%s) : ",statename);
3861        print_dax__bufferstack();
3862   }
3863 }
3864
3865 static void debug_leave(void) {
3866     if (dax__flex_debug) {
3867         print_yy_stack("--LEAVE : ");
3868         print_dax__bufferstack();
3869     }
3870   yy_pop_state();
3871 }
3872
3873 static void debug_set(int state, const char* statename) {
3874   BEGIN(state);
3875   if (dax__flex_debug) print_yy_stack("--SET(%s) : ",statename);
3876 }
3877 #endif
3878
3879 static void cleanup(void)
3880 {
3881     if (dax__statenames) {
3882         free(dax__statenames);
3883         dax__statenames = NULL;
3884     }
3885     free(dax__bufferstack);
3886     dax__bufferstack = NULL;
3887
3888     free(indexstack);
3889     indexstack = NULL;
3890 }
3891
3892 static int fail(const char* fmt, ...)
3893 {
3894     int chars_left, used;
3895     va_list ap; va_start(ap, fmt);
3896 #ifdef FLEXML_yylineno
3897     used = sprintf(flexml_err_msg,
3898                    "Invalid XML (XML input line %d, state %d): ",
3899                    dax_lineno, YY_START);
3900 #else
3901     used = sprintf(flexml_err_msg,
3902                    "Invalid XML (state %d): ",
3903                    YY_START);
3904 #endif
3905     chars_left = flexml_max_err_msg_size - used - 1;
3906     vsnprintf(flexml_err_msg + used, chars_left, fmt, ap);
3907     va_end(ap);
3908
3909 #ifndef FLEXML_quiet_parser
3910     /* print directly to sdterr */
3911     fprintf(stderr, "%s\n", flexml_err_msg);
3912     flexml_err_msg[0] = '\0';
3913 #endif
3914
3915     cleanup();
3916
3917     return 1;
3918 }
3919