Logo AND Algorithmique Numérique Distribuée

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