Logo AND Algorithmique Numérique Distribuée

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