Logo AND Algorithmique Numérique Distribuée

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