Logo AND Algorithmique Numérique Distribuée

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