Logo AND Algorithmique Numérique Distribuée

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