Logo AND Algorithmique Numérique Distribuée

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