Logo AND Algorithmique Numérique Distribuée

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