src/xbt/graphxml.c

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