Logo AND Algorithmique Numérique Distribuée

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