Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Visual C++ already declare the isatty function in io.h. So this change avoids a warni...
[simgrid.git] / src / xbt / graphxml.c
index d2e6a61..2b1a8ef 100644 (file)
@@ -1,9 +1,5 @@
-#include "xbt/graphxml.h"
 
-
-#line 2 "xbt/graphxml.c"
-
-#line 4 "xbt/graphxml.c"
+#line 3 "xbt/graphxml.c"
 
 #define  YY_INT_ALIGNED short int
 
@@ -12,7 +8,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 31
+#define YY_FLEX_SUBMINOR_VERSION 33
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
 
 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
 
-#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
+#if __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
 #include <inttypes.h>
 typedef int8_t flex_int8_t;
 typedef uint8_t flex_uint8_t;
@@ -138,6 +142,10 @@ typedef unsigned int flex_uint32_t;
 #define YY_BUF_SIZE 16384
 #endif
 
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 #define YY_TYPEDEF_YY_BUFFER_STATE
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
@@ -284,7 +292,7 @@ int xbt_graph_parse_leng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;                /* whether we need to initialize */
+static int yy_init = 0;                /* whether we need to initialize */
 static int yy_start = 0;       /* start state number */
 
 /* Flag which is used to allow xbt_graph_parse_wrap()'s to do buffer switches
@@ -1003,14 +1011,13 @@ int xbt_graph_parse__flex_debug = 0;
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 char *xbt_graph_parse_text;
-#line 1 "xbt/graphxml.l"
 /* Validating XML processor for xbt/graphxml.dtd.
- * Generated 2006/07/18 21:02:16.
+ * Generated 2007/08/09 10:57:49.
  *
  * This program was generated with the FleXML XML processor generator.
  * FleXML is Copyright (C) 1999-2005 Kristoffer Rose.  All rights reserved.
  * FleXML is Copyright (C) 2003-2006 Martin Quinson.  All rights reserved.
- * (Id: flexml.pl,v 1.53 2006/07/18 12:12:06 mquinson Exp).
+ * (Id: flexml.pl,v 1.61 2006/09/13 16:34:33 wdowling Exp).
  * 
  * There are two, intertwined parts to this program, part A and part B.
  *
@@ -1050,16 +1057,15 @@ char *xbt_graph_parse_text;
  * by the author of or contributors to FleXML.
  * 
  */
-#line 49 "xbt/graphxml.l"
 
 /* Version strings. */
 const char rcs_graphxml_flexml_skeleton[] =
- "$" "Id: skel,v 1.31 2006/07/18 18:21:13 mquinson Exp $";
+ "$" "Id: skel,v 1.38 2006/09/12 18:05:45 wdowling Exp $";
 const char rcs_graphxml_flexml[] =
- "$" "Id: flexml.pl,v 1.53 2006/07/18 12:12:06 mquinson Exp $";
+ "$" "Id: flexml.pl,v 1.61 2006/09/13 16:34:33 wdowling Exp $";
 
 /* ANSI headers. */
-
+/* ANSI headers. */
 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__)
 #  ifndef __STRICT_ANSI__
 #    include <io.h>
@@ -1068,32 +1074,52 @@ const char rcs_graphxml_flexml[] =
 #else
 #  include <unistd.h>
 #endif
-
 #include <stdio.h>
 #include <string.h>
 #include <assert.h>
 #include <stdarg.h>
 #include <ctype.h>
 
+#ifndef FLEXML_INDEXSTACKSIZE
+#define FLEXML_INDEXSTACKSIZE 1000
+#endif
+
 /* Generated definitions. */
 #define FLEXML_yylineno
+#ifndef FLEXML_BUFFERSTACKSIZE
 #define FLEXML_BUFFERSTACKSIZE 1000000
+#endif
+#define FLEXML_NEED_BUFFERLIT
 
 /* XML processor api. */
 /* FleXML-provided data. */
-const char* graphxml_pcdata;
-AT_graphxml_node_name A_graphxml_node_name;
-AT_graphxml_edge_source A_graphxml_edge_source;
-AT_graphxml_node_position_y A_graphxml_node_position_y;
-AT_graphxml_node_position_x A_graphxml_node_position_x;
-AT_graphxml_edge_data A_graphxml_edge_data;
-AT_graphxml_edge_target A_graphxml_edge_target;
-AT_graphxml_graph_isDirected A_graphxml_graph_isDirected;
-AT_graphxml_node_label A_graphxml_node_label;
-AT_graphxml_node_data A_graphxml_node_data;
-AT_graphxml_edge_label A_graphxml_edge_label;
-AT_graphxml_edge_length A_graphxml_edge_length;
-AT_graphxml_edge_name A_graphxml_edge_name;
+int graphxml_pcdata_ix;
+extern char *graphxml_bufferstack;
+#define graphxml_pcdata (graphxml_bufferstack + graphxml_pcdata_ix)
+AT_graphxml_node_name AX_graphxml_node_name;
+#define A_graphxml_node_name (graphxml_bufferstack + AX_graphxml_node_name)
+AT_graphxml_edge_source AX_graphxml_edge_source;
+#define A_graphxml_edge_source (graphxml_bufferstack + AX_graphxml_edge_source)
+AT_graphxml_node_position_y AX_graphxml_node_position_y;
+#define A_graphxml_node_position_y (graphxml_bufferstack + AX_graphxml_node_position_y)
+AT_graphxml_node_position_x AX_graphxml_node_position_x;
+#define A_graphxml_node_position_x (graphxml_bufferstack + AX_graphxml_node_position_x)
+AT_graphxml_edge_data AX_graphxml_edge_data;
+#define A_graphxml_edge_data (graphxml_bufferstack + AX_graphxml_edge_data)
+AT_graphxml_edge_target AX_graphxml_edge_target;
+#define A_graphxml_edge_target (graphxml_bufferstack + AX_graphxml_edge_target)
+AT_graphxml_graph_isDirected AX_graphxml_graph_isDirected;
+#define A_graphxml_graph_isDirected AX_graphxml_graph_isDirected
+AT_graphxml_node_label AX_graphxml_node_label;
+#define A_graphxml_node_label (graphxml_bufferstack + AX_graphxml_node_label)
+AT_graphxml_node_data AX_graphxml_node_data;
+#define A_graphxml_node_data (graphxml_bufferstack + AX_graphxml_node_data)
+AT_graphxml_edge_label AX_graphxml_edge_label;
+#define A_graphxml_edge_label (graphxml_bufferstack + AX_graphxml_edge_label)
+AT_graphxml_edge_length AX_graphxml_edge_length;
+#define A_graphxml_edge_length (graphxml_bufferstack + AX_graphxml_edge_length)
+AT_graphxml_edge_name AX_graphxml_edge_name;
+#define A_graphxml_edge_name (graphxml_bufferstack + AX_graphxml_edge_name)
 
 /* XML state. */
 #ifdef FLEX_DEBUG
@@ -1115,64 +1141,97 @@ AT_graphxml_edge_name A_graphxml_edge_name;
 
 #define FAIL   return fail
 static int fail(const char*, ...);
-const char * graphxml_parse_err_msg(void);
+
+enum {flexml_max_err_msg_size = 512};
+static char flexml_err_msg[flexml_max_err_msg_size];
+const char * graphxml_parse_err_msg()
+{
+    return flexml_err_msg;
+}
+static void reset_graphxml_parse_err_msg()
+{
+    flexml_err_msg[0] = '\0';
+}
 
 /* Cleanup */
 static void cleanup(void);
 #define CLEANUP  cleanup()
 
 /* Text buffer stack handling. */
-static char bufferstack[FLEXML_BUFFERSTACKSIZE];
-static char* limit = bufferstack + FLEXML_BUFFERSTACKSIZE;
-typedef struct BufferLast_s {
-  struct BufferLast_s *old; const char* saved; char new1[1];
-} BufferLast;
-#ifdef FLEXML_HasMixed
-static BufferLast* last = (BufferLast*)0;
-#endif
-static char* next = bufferstack;
+char *graphxml_bufferstack = NULL;
+static int blimit = FLEXML_BUFFERSTACKSIZE;
+static int bnext = 1;
+
+static int *indexstack = NULL;
+static int ilimit = FLEXML_INDEXSTACKSIZE;
+static int inext = 1;
 
-#define BUFFERSET(P)  (P = next)
-#define BUFFERPUTC(C) (assert(next<limit), *(next++) = (C))
+#define BUFFERSET(P)  (P = bnext)
+#define BUFFERPUTC(C) (ck_blimit(), graphxml_bufferstack[bnext++] = (C))
 #define BUFFERDONE    (BUFFERPUTC('\0'))
 
-#define BUFFERLITERAL(C,P) bufferliteral(C,&(P),xbt_graph_parse_text)
-static void bufferliteral(char c, const char** pp, char* text)
+#define BUFFERLITERAL(C, P) graphxml_bufferliteral(C, &(P), xbt_graph_parse_text)
+
+/* after this is called, there are at least 2 slots left in the stack */
+static int ck_blimit()
 {
-  char *s = strchr(text,c), *e = strrchr(text,c);
+     if (bnext >= blimit) {
+        blimit += FLEXML_BUFFERSTACKSIZE + 2;
+        {
+            char *temp = (char *) realloc(graphxml_bufferstack, blimit);
+            assert(temp);
+            graphxml_bufferstack = temp;
+        }
+     }
+     return 0;
+}
+
+/* after this is called, there are at least 2 slots left in the stack */
+static int ck_ilimit()
+{
+     if (inext >= ilimit) {
+        ilimit += FLEXML_INDEXSTACKSIZE + 2;
+        {
+            int *temp = (int *) realloc(indexstack, ilimit);
+            assert(temp);
+            indexstack = temp;
+        }
+     }
+     return 0;
+}
+
+#ifdef FLEXML_NEED_BUFFERLIT
+static void graphxml_bufferliteral(char c, int* pp, const char* text)
+{
+  const char *s = (c ? strchr(text,c) : text-1), *e = strrchr(text,c);
   assert(s <= e); BUFFERSET(*pp);
   while (++s<e) {
-    if (isspace(*s)) { BUFFERPUTC(' '); while (isspace(*s)) ++s; }
+    if (isspace(*s) && c) { BUFFERPUTC(' '); while (isspace(*s)) ++s; }
     else BUFFERPUTC(*s);
   }
   BUFFERDONE;
 }
+#endif
 
-#ifdef FLEXML_HasMixed
-static void pushbuffer(const char* p)
+static void pushbuffer(int p)
 {
-  BufferLast* l = (BufferLast*)next;
-  assert(next < limit);
-  l->old = last;
-  l->saved = p;
-  next = l->new1;
-  last = l;
+    ck_ilimit();
+    indexstack[inext++] = p;
+    indexstack[inext++] = bnext;    
 }
 
-static const char* popbuffer(void)
+static int popbuffer(void)
 {
-  BufferLast* l = last;
-  assert(last != (BufferLast*)0);
-  last = l->old;
-  next = (char*)l;
-  return l->saved;
+    assert(inext >= 2);
+    bnext = indexstack[--inext];
+    return indexstack[--inext];
 }
-#endif
 
 /* General internal entities are `unput' back onto the input stream... */
 #define ENTITYTEXT(T) \
   { char *s = (T), *e = s+strlen(s);\
     while (--e >= s) { unput(*e); }}
+
 /* Flex standard options. */
 #define YY_NO_INPUT 1
 /* Flex user-requested options. */
@@ -1196,14 +1255,8 @@ static const char* popbuffer(void)
  * IMPOSSIBLE  dummy to permit disabling rules; must be last
  */
 
-
-
-
-
-#line 216 "xbt/graphxml.l"
 /* State names. */
 const char* *graphxml_statenames=NULL;
-#line 1195 "xbt/graphxml.c"
 
 #define INITIAL 0
 #define PROLOG 1
@@ -1236,6 +1289,7 @@ const char* *graphxml_statenames=NULL;
  * down here because we want the user's section 1 to have been scanned first.
  * The user has a chance to override it with an option.
  */
+/* ANSI headers. */
 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__TOS_WIN__)
 #  ifndef __STRICT_ANSI__
 #    include <io.h>
@@ -1250,6 +1304,8 @@ const char* *graphxml_statenames=NULL;
 #define YY_EXTRA_TYPE void *
 #endif
 
+static int yy_init_globals (void );
+
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
@@ -1282,7 +1338,7 @@ static int input (void );
 
         static int yy_start_stack_ptr = 0;
         static int yy_start_stack_depth = 0;
-        static int *yy_start_stack = 0;
+        static int *yy_start_stack = NULL;
     
     static void yy_push_state (int new_state );
     
@@ -1391,13 +1447,29 @@ YY_DECL
        register char *yy_cp, *yy_bp;
        register int yy_act;
     
-#line 220 "xbt/graphxml.l"
-
-
  /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
  SET(PROLOG);
+ reset_graphxml_parse_err_msg();
+ graphxml_bufferstack = (char *) malloc(FLEXML_BUFFERSTACKSIZE);
+ assert(graphxml_bufferstack);
+ #ifdef FLEX_DEBUG
+ {
+     int i;
+     for (i = 0; i < blimit; i++) {
+         graphxml_bufferstack[i] = '\377';
+     }
+ }
+ #endif
+ graphxml_bufferstack[0] = '\0';
+ indexstack = (int *) malloc(FLEXML_INDEXSTACKSIZE * sizeof(int));
+ assert(indexstack);
+ indexstack[0] = 0;
+
   /* FleXML_init */
-  next = bufferstack;
+  bnext = inext = 1;
+  graphxml_bufferliteral('\0', &bnext, "-1.0");
+  graphxml_bufferliteral('\0', &bnext, "-1.0");
+  graphxml_bufferliteral('\0', &bnext, "-1.0");
   if(!graphxml_statenames) {graphxml_statenames= (const char **)calloc(IMPOSSIBLE,sizeof(char*));
   graphxml_statenames[PROLOG] = NULL;
   graphxml_statenames[DOCTYPE] = NULL;
@@ -1426,11 +1498,9 @@ YY_DECL
 
  /* COMMENTS and PIs: handled uniformly for efficiency. */
 
-#line 1411 "xbt/graphxml.c"
-
-       if ( (yy_init) )
+       if ( !(yy_init) )
                {
-               (yy_init) = 0;
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
                YY_USER_INIT;
@@ -1521,52 +1591,39 @@ do_action:      /* This label is used only to access EOF actions. */
 
 case 1:
 YY_RULE_SETUP
-#line 255 "xbt/graphxml.l"
 ENTER(INCOMMENT);
        YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 256 "xbt/graphxml.l"
 ENTER(INPI);
        YY_BREAK
 
-
 case 3:
 YY_RULE_SETUP
-#line 259 "xbt/graphxml.l"
 LEAVE;
        YY_BREAK
 case 4:
-#line 261 "xbt/graphxml.l"
 case 5:
-#line 262 "xbt/graphxml.l"
 case 6:
 /* rule 6 can match eol */
 YY_RULE_SETUP
-#line 262 "xbt/graphxml.l"
 SKIP;
        YY_BREAK
 case YY_STATE_EOF(INCOMMENT):
-#line 263 "xbt/graphxml.l"
 FAIL("EOF in comment.");
        YY_BREAK
 
-
 case 7:
 YY_RULE_SETUP
-#line 266 "xbt/graphxml.l"
 LEAVE;
        YY_BREAK
 case 8:
-#line 268 "xbt/graphxml.l"
 case 9:
 /* rule 9 can match eol */
 YY_RULE_SETUP
-#line 268 "xbt/graphxml.l"
 SKIP;
        YY_BREAK
 case YY_STATE_EOF(INPI):
-#line 269 "xbt/graphxml.l"
 FAIL("EOF in PI (processing instruction).");
        YY_BREAK
 
@@ -1574,7 +1631,6 @@ FAIL("EOF in PI (processing instruction).");
 case 10:
 /* rule 10 can match eol */
 YY_RULE_SETUP
-#line 274 "xbt/graphxml.l"
 SKIP;
        YY_BREAK
 /* PROLOG: determine root element and process it. */
@@ -1582,49 +1638,40 @@ SKIP;
 case 11:
 /* rule 11 can match eol */
 YY_RULE_SETUP
-#line 279 "xbt/graphxml.l"
 SET(DOCTYPE); 
        YY_BREAK
 case 12:
 /* rule 12 can match eol */
 YY_RULE_SETUP
-#line 280 "xbt/graphxml.l"
 FAIL("Bad declaration %s.",xbt_graph_parse_text);
        YY_BREAK
 
-
 case 13:
 /* rule 13 can match eol */
 YY_RULE_SETUP
-#line 284 "xbt/graphxml.l"
 SET(ROOT_graphxml_edge);
        YY_BREAK
 case 14:
 /* rule 14 can match eol */
 YY_RULE_SETUP
-#line 285 "xbt/graphxml.l"
 SET(ROOT_graphxml_node);
        YY_BREAK
 case 15:
 /* rule 15 can match eol */
 YY_RULE_SETUP
-#line 286 "xbt/graphxml.l"
 SET(ROOT_graphxml_graph);
        YY_BREAK
 case 16:
 /* rule 16 can match eol */
 YY_RULE_SETUP
-#line 287 "xbt/graphxml.l"
 FAIL("Bad declaration %s.",xbt_graph_parse_text);
        YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 288 "xbt/graphxml.l"
 FAIL("Unexpected character `%c' in prolog.", xbt_graph_parse_text[0]);
        YY_BREAK
 case YY_STATE_EOF(PROLOG):
 case YY_STATE_EOF(DOCTYPE):
-#line 289 "xbt/graphxml.l"
 FAIL("EOF in prolog.");
        YY_BREAK
 
@@ -1635,43 +1682,36 @@ FAIL("EOF in prolog.");
 case 18:
 /* rule 18 can match eol */
 YY_RULE_SETUP
-#line 299 "xbt/graphxml.l"
 {
-  A_graphxml_graph_isDirected = A_graphxml_graph_isDirected_true;
-  ENTER(AL_graphxml_graph);
+  AX_graphxml_graph_isDirected = A_graphxml_graph_isDirected_true;
+  ENTER(AL_graphxml_graph); pushbuffer(0);
   }
        YY_BREAK
 
 case 19:
 /* rule 19 can match eol */
-#line 306 "xbt/graphxml.l"
 case 20:
 /* rule 20 can match eol */
 YY_RULE_SETUP
-#line 306 "xbt/graphxml.l"
 A_graphxml_graph_isDirected = A_graphxml_graph_isDirected_true;
        YY_BREAK
 case 21:
 /* rule 21 can match eol */
-#line 308 "xbt/graphxml.l"
 case 22:
 /* rule 22 can match eol */
 YY_RULE_SETUP
-#line 308 "xbt/graphxml.l"
 A_graphxml_graph_isDirected = A_graphxml_graph_isDirected_false;
        YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 310 "xbt/graphxml.l"
 {
-  LEAVE; STag_graphxml_graph();graphxml_pcdata = NULL; ENTER(S_graphxml_graph);
+  LEAVE; STag_graphxml_graph();graphxml_pcdata_ix = 0; ENTER(S_graphxml_graph);
  }
        YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 313 "xbt/graphxml.l"
 {
-  LEAVE; STag_graphxml_graph(); graphxml_pcdata = NULL; ETag_graphxml_graph();
+  LEAVE; STag_graphxml_graph(); graphxml_pcdata_ix = 0; ETag_graphxml_graph(); popbuffer(); /* attribute */
   switch (YY_START) {
    case ROOT_graphxml_graph: SET(EPILOG); break;
   }
@@ -1679,27 +1719,23 @@ YY_RULE_SETUP
        YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 319 "xbt/graphxml.l"
 FAIL("Unexpected character `%c' in attribute list of graph element.", xbt_graph_parse_text[0]);
        YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 320 "xbt/graphxml.l"
 FAIL("Bad attribute `%s' in `graph' element start tag.",xbt_graph_parse_text);
        YY_BREAK
 case YY_STATE_EOF(AL_graphxml_graph):
-#line 321 "xbt/graphxml.l"
 FAIL("EOF in attribute list of `graph' element.");
        YY_BREAK
 
-
 case 27:
 /* rule 27 can match eol */
 YY_RULE_SETUP
-#line 325 "xbt/graphxml.l"
 {
   LEAVE;
   ETag_graphxml_graph();
+  popbuffer(); /* attribute */
   switch (YY_START) {
    case ROOT_graphxml_graph: SET(EPILOG); break;
   }
@@ -1708,12 +1744,10 @@ YY_RULE_SETUP
 case 28:
 /* rule 28 can match eol */
 YY_RULE_SETUP
-#line 332 "xbt/graphxml.l"
 FAIL("Unexpected end-tag `%s': `</graph>' expected.",xbt_graph_parse_text);
        YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 333 "xbt/graphxml.l"
 FAIL("Unexpected character `%c': `</graph>' expected.",xbt_graph_parse_text[0]);
        YY_BREAK
 case YY_STATE_EOF(S_graphxml_graph_1):
@@ -1721,7 +1755,6 @@ case YY_STATE_EOF(E_graphxml_graph):
 case YY_STATE_EOF(S_graphxml_graph_3):
 case YY_STATE_EOF(S_graphxml_graph_5):
 case YY_STATE_EOF(S_graphxml_graph):
-#line 334 "xbt/graphxml.l"
 FAIL("Premature EOF: `</graph>' expected.");
        YY_BREAK
 
@@ -1734,91 +1767,78 @@ FAIL("Premature EOF: `</graph>' expected.");
 case 30:
 /* rule 30 can match eol */
 YY_RULE_SETUP
-#line 344 "xbt/graphxml.l"
 {
-  A_graphxml_node_label = NULL;
-  A_graphxml_node_name = NULL;
-  A_graphxml_node_data = NULL;
-  A_graphxml_node_position_x = "-1.0";
-  A_graphxml_node_position_y = "-1.0";
-  ENTER(AL_graphxml_node);
+  AX_graphxml_node_label = 0;
+  AX_graphxml_node_name = 0;
+  AX_graphxml_node_data = 0;
+  AX_graphxml_node_position_x = 1;
+  AX_graphxml_node_position_y = 6;
+  ENTER(AL_graphxml_node); pushbuffer(0);
   }
        YY_BREAK
 
 case 31:
 /* rule 31 can match eol */
 YY_RULE_SETUP
-#line 354 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_node_label);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_node_label);
        YY_BREAK
 case 32:
 /* rule 32 can match eol */
 YY_RULE_SETUP
-#line 355 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_node_label);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_node_label);
        YY_BREAK
 case 33:
 /* rule 33 can match eol */
 YY_RULE_SETUP
-#line 357 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_node_name);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_node_name);
        YY_BREAK
 case 34:
 /* rule 34 can match eol */
 YY_RULE_SETUP
-#line 358 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_node_name);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_node_name);
        YY_BREAK
 case 35:
 /* rule 35 can match eol */
 YY_RULE_SETUP
-#line 360 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_node_data);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_node_data);
        YY_BREAK
 case 36:
 /* rule 36 can match eol */
 YY_RULE_SETUP
-#line 361 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_node_data);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_node_data);
        YY_BREAK
 case 37:
 /* rule 37 can match eol */
 YY_RULE_SETUP
-#line 363 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_node_position_x);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_node_position_x);
        YY_BREAK
 case 38:
 /* rule 38 can match eol */
 YY_RULE_SETUP
-#line 364 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_node_position_x);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_node_position_x);
        YY_BREAK
 case 39:
 /* rule 39 can match eol */
 YY_RULE_SETUP
-#line 366 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_node_position_y);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_node_position_y);
        YY_BREAK
 case 40:
 /* rule 40 can match eol */
 YY_RULE_SETUP
-#line 367 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_node_position_y);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_node_position_y);
        YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 369 "xbt/graphxml.l"
 {
-  if (!A_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element.");
-  LEAVE; STag_graphxml_node();graphxml_pcdata = NULL; ENTER(E_graphxml_node);
+  if (!AX_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element.");
+  LEAVE; STag_graphxml_node();graphxml_pcdata_ix = 0; ENTER(E_graphxml_node);
  }
        YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 373 "xbt/graphxml.l"
 {
-  if (!A_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element.");
-  LEAVE; STag_graphxml_node(); graphxml_pcdata = NULL; ETag_graphxml_node();
+  if (!AX_graphxml_node_name) FAIL("Required attribute `name' not set for `node' element.");
+  LEAVE; STag_graphxml_node(); graphxml_pcdata_ix = 0; ETag_graphxml_node(); popbuffer(); /* attribute */
   switch (YY_START) {
    case S_graphxml_graph_2: case S_graphxml_graph_3: case S_graphxml_graph: SET(S_graphxml_graph_3); break;
    case ROOT_graphxml_node: SET(EPILOG); break;
@@ -1827,27 +1847,23 @@ YY_RULE_SETUP
        YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 381 "xbt/graphxml.l"
 FAIL("Unexpected character `%c' in attribute list of node element.", xbt_graph_parse_text[0]);
        YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 382 "xbt/graphxml.l"
 FAIL("Bad attribute `%s' in `node' element start tag.",xbt_graph_parse_text);
        YY_BREAK
 case YY_STATE_EOF(AL_graphxml_node):
-#line 383 "xbt/graphxml.l"
 FAIL("EOF in attribute list of `node' element.");
        YY_BREAK
 
-
 case 45:
 /* rule 45 can match eol */
 YY_RULE_SETUP
-#line 387 "xbt/graphxml.l"
 {
   LEAVE;
   ETag_graphxml_node();
+  popbuffer(); /* attribute */
   switch (YY_START) {
    case S_graphxml_graph_2: case S_graphxml_graph_3: case S_graphxml_graph: SET(S_graphxml_graph_3); break;
    case ROOT_graphxml_node: SET(EPILOG); break;
@@ -1857,16 +1873,13 @@ YY_RULE_SETUP
 case 46:
 /* rule 46 can match eol */
 YY_RULE_SETUP
-#line 395 "xbt/graphxml.l"
 FAIL("Unexpected end-tag `%s': `</node>' expected.",xbt_graph_parse_text);
        YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 396 "xbt/graphxml.l"
 FAIL("Unexpected character `%c': `</node>' expected.",xbt_graph_parse_text[0]);
        YY_BREAK
 case YY_STATE_EOF(E_graphxml_node):
-#line 397 "xbt/graphxml.l"
 FAIL("Premature EOF: `</node>' expected.");
        YY_BREAK
 
@@ -1880,106 +1893,91 @@ FAIL("Premature EOF: `</node>' expected.");
 case 48:
 /* rule 48 can match eol */
 YY_RULE_SETUP
-#line 408 "xbt/graphxml.l"
 {
-  A_graphxml_edge_label = NULL;
-  A_graphxml_edge_name = NULL;
-  A_graphxml_edge_source = NULL;
-  A_graphxml_edge_target = NULL;
-  A_graphxml_edge_length = "-1.0";
-  A_graphxml_edge_data = NULL;
-  ENTER(AL_graphxml_edge);
+  AX_graphxml_edge_label = 0;
+  AX_graphxml_edge_name = 0;
+  AX_graphxml_edge_source = 0;
+  AX_graphxml_edge_target = 0;
+  AX_graphxml_edge_length = 11;
+  AX_graphxml_edge_data = 0;
+  ENTER(AL_graphxml_edge); pushbuffer(0);
   }
        YY_BREAK
 
 case 49:
 /* rule 49 can match eol */
 YY_RULE_SETUP
-#line 419 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_edge_label);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_label);
        YY_BREAK
 case 50:
 /* rule 50 can match eol */
 YY_RULE_SETUP
-#line 420 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_edge_label);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_label);
        YY_BREAK
 case 51:
 /* rule 51 can match eol */
 YY_RULE_SETUP
-#line 422 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_edge_name);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_name);
        YY_BREAK
 case 52:
 /* rule 52 can match eol */
 YY_RULE_SETUP
-#line 423 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_edge_name);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_name);
        YY_BREAK
 case 53:
 /* rule 53 can match eol */
 YY_RULE_SETUP
-#line 425 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_edge_source);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_source);
        YY_BREAK
 case 54:
 /* rule 54 can match eol */
 YY_RULE_SETUP
-#line 426 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_edge_source);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_source);
        YY_BREAK
 case 55:
 /* rule 55 can match eol */
 YY_RULE_SETUP
-#line 428 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_edge_target);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_target);
        YY_BREAK
 case 56:
 /* rule 56 can match eol */
 YY_RULE_SETUP
-#line 429 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_edge_target);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_target);
        YY_BREAK
 case 57:
 /* rule 57 can match eol */
 YY_RULE_SETUP
-#line 431 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_edge_length);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_length);
        YY_BREAK
 case 58:
 /* rule 58 can match eol */
 YY_RULE_SETUP
-#line 432 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_edge_length);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_length);
        YY_BREAK
 case 59:
 /* rule 59 can match eol */
 YY_RULE_SETUP
-#line 434 "xbt/graphxml.l"
-ENTER(VALUE1); BUFFERSET(A_graphxml_edge_data);
+ENTER(VALUE1); BUFFERSET(AX_graphxml_edge_data);
        YY_BREAK
 case 60:
 /* rule 60 can match eol */
 YY_RULE_SETUP
-#line 435 "xbt/graphxml.l"
-ENTER(VALUE2); BUFFERSET(A_graphxml_edge_data);
+ENTER(VALUE2); BUFFERSET(AX_graphxml_edge_data);
        YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 437 "xbt/graphxml.l"
 {
-  if (!A_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element.");
-  if (!A_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element.");
-  LEAVE; STag_graphxml_edge();graphxml_pcdata = NULL; ENTER(E_graphxml_edge);
+  if (!AX_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element.");
+  if (!AX_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element.");
+  LEAVE; STag_graphxml_edge();graphxml_pcdata_ix = 0; ENTER(E_graphxml_edge);
  }
        YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 442 "xbt/graphxml.l"
 {
-  if (!A_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element.");
-  if (!A_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element.");
-  LEAVE; STag_graphxml_edge(); graphxml_pcdata = NULL; ETag_graphxml_edge();
+  if (!AX_graphxml_edge_source) FAIL("Required attribute `source' not set for `edge' element.");
+  if (!AX_graphxml_edge_target) FAIL("Required attribute `target' not set for `edge' element.");
+  LEAVE; STag_graphxml_edge(); graphxml_pcdata_ix = 0; ETag_graphxml_edge(); popbuffer(); /* attribute */
   switch (YY_START) {
    case S_graphxml_graph_1: case S_graphxml_graph_3: case S_graphxml_graph_5: case S_graphxml_graph_4: case S_graphxml_graph: SET(S_graphxml_graph_5); break;
    case ROOT_graphxml_edge: SET(EPILOG); break;
@@ -1988,27 +1986,23 @@ YY_RULE_SETUP
        YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 451 "xbt/graphxml.l"
 FAIL("Unexpected character `%c' in attribute list of edge element.", xbt_graph_parse_text[0]);
        YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 452 "xbt/graphxml.l"
 FAIL("Bad attribute `%s' in `edge' element start tag.",xbt_graph_parse_text);
        YY_BREAK
 case YY_STATE_EOF(AL_graphxml_edge):
-#line 453 "xbt/graphxml.l"
 FAIL("EOF in attribute list of `edge' element.");
        YY_BREAK
 
-
 case 65:
 /* rule 65 can match eol */
 YY_RULE_SETUP
-#line 457 "xbt/graphxml.l"
 {
   LEAVE;
   ETag_graphxml_edge();
+  popbuffer(); /* attribute */
   switch (YY_START) {
    case S_graphxml_graph_1: case S_graphxml_graph_3: case S_graphxml_graph_5: case S_graphxml_graph_4: case S_graphxml_graph: SET(S_graphxml_graph_5); break;
    case ROOT_graphxml_edge: SET(EPILOG); break;
@@ -2018,16 +2012,13 @@ YY_RULE_SETUP
 case 66:
 /* rule 66 can match eol */
 YY_RULE_SETUP
-#line 465 "xbt/graphxml.l"
 FAIL("Unexpected end-tag `%s': `</edge>' expected.",xbt_graph_parse_text);
        YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 466 "xbt/graphxml.l"
 FAIL("Unexpected character `%c': `</edge>' expected.",xbt_graph_parse_text[0]);
        YY_BREAK
 case YY_STATE_EOF(E_graphxml_edge):
-#line 467 "xbt/graphxml.l"
 FAIL("Premature EOF: `</edge>' expected.");
        YY_BREAK
 
@@ -2035,11 +2026,9 @@ FAIL("Premature EOF: `</edge>' expected.");
 
 case 68:
 YY_RULE_SETUP
-#line 473 "xbt/graphxml.l"
 {SET(PROLOG); yyless(0); CLEANUP; return -1;}
        YY_BREAK
 case YY_STATE_EOF(EPILOG):
-#line 474 "xbt/graphxml.l"
 SUCCEED;
        YY_BREAK
 
@@ -2048,119 +2037,91 @@ SUCCEED;
 /* Non-defined standard entities... */
 case 69:
 YY_RULE_SETUP
-#line 481 "xbt/graphxml.l"
 BUFFERPUTC('&');
        YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 482 "xbt/graphxml.l"
 BUFFERPUTC('<');
        YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 483 "xbt/graphxml.l"
 BUFFERPUTC('>');
        YY_BREAK
 case 72:
 YY_RULE_SETUP
-#line 484 "xbt/graphxml.l"
 BUFFERPUTC('\'');
        YY_BREAK
 case 73:
 YY_RULE_SETUP
-#line 485 "xbt/graphxml.l"
 BUFFERPUTC('"');
        YY_BREAK
 /* Character entities. */
 case 74:
 YY_RULE_SETUP
-#line 488 "xbt/graphxml.l"
 BUFFERPUTC((unsigned char)atoi(xbt_graph_parse_text+2));
        YY_BREAK
 case 75:
 YY_RULE_SETUP
-#line 489 "xbt/graphxml.l"
 BUFFERPUTC((unsigned char)strtol(xbt_graph_parse_text+3,NULL,16));
        YY_BREAK
 
-
 case 76:
 /* rule 76 can match eol */
-#line 494 "xbt/graphxml.l"
 case 77:
 /* rule 77 can match eol */
-#line 495 "xbt/graphxml.l"
 case 78:
 /* rule 78 can match eol */
-#line 496 "xbt/graphxml.l"
 case 79:
 /* rule 79 can match eol */
 YY_RULE_SETUP
-#line 496 "xbt/graphxml.l"
 BUFFERPUTC('\n');
        YY_BREAK
 
-
 case 80:
 YY_RULE_SETUP
-#line 500 "xbt/graphxml.l"
 ENTER(CDATA);
        YY_BREAK
 case 81:
 YY_RULE_SETUP
-#line 501 "xbt/graphxml.l"
 FAIL("Unexpected `]""]>' in character data.");
        YY_BREAK
 
-
 case 82:
 YY_RULE_SETUP
-#line 505 "xbt/graphxml.l"
 BUFFERDONE; LEAVE;
        YY_BREAK
 case YY_STATE_EOF(VALUE1):
-#line 506 "xbt/graphxml.l"
 FAIL("EOF in literal (\"'\" expected).");
        YY_BREAK
 
-
 case 83:
 YY_RULE_SETUP
-#line 510 "xbt/graphxml.l"
 BUFFERDONE; LEAVE;
        YY_BREAK
 case YY_STATE_EOF(VALUE2):
-#line 511 "xbt/graphxml.l"
 FAIL("EOF in literal (`\"' expected).");
        YY_BREAK
 
-
 case 84:
 /* rule 84 can match eol */
 YY_RULE_SETUP
-#line 515 "xbt/graphxml.l"
 BUFFERPUTC(xbt_graph_parse_text[0]);
        YY_BREAK
 case 85:
 YY_RULE_SETUP
-#line 516 "xbt/graphxml.l"
 FAIL("Spurious `%c' in character data.",xbt_graph_parse_text[0]);
        YY_BREAK
 
-
 case 86:
 YY_RULE_SETUP
-#line 520 "xbt/graphxml.l"
 LEAVE;
        YY_BREAK
 /* "]""]"              BUFFERPUTC(xbt_graph_parse_text[0]); BUFFERPUTC(xbt_graph_parse_text[1]); */
 case 87:
 YY_RULE_SETUP
-#line 522 "xbt/graphxml.l"
 BUFFERPUTC(xbt_graph_parse_text[0]);
        YY_BREAK
 case YY_STATE_EOF(CDATA):
-#line 523 "xbt/graphxml.l"
 FAIL("EOF in CDATA section.");
        YY_BREAK
 
@@ -2171,16 +2132,13 @@ FAIL("EOF in CDATA section.");
 case 88:
 /* rule 88 can match eol */
 YY_RULE_SETUP
-#line 530 "xbt/graphxml.l"
 FAIL("Syntax error on character `%c'.", xbt_graph_parse_text[0]);
        YY_BREAK
 
 case 89:
 YY_RULE_SETUP
-#line 533 "xbt/graphxml.l"
 ECHO;
        YY_BREAK
-#line 2165 "xbt/graphxml.c"
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(ROOT_graphxml_graph):
 case YY_STATE_EOF(S_graphxml_graph_2):
@@ -2417,7 +2375,7 @@ static int yy_get_next_buffer (void)
 
                /* Read in more data. */
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-                       (yy_n_chars), num_to_read );
+                       (yy_n_chars), (size_t) num_to_read );
 
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                }
@@ -2696,7 +2654,7 @@ static void xbt_graph_parse__load_buffer_state  (void)
        xbt_graph_parse_free((void *) b  );
 }
 
-#ifndef __cplusplus
+#if !defined(__cplusplus) && !defined(WIN32) 
 extern int isatty (int );
 #endif /* __cplusplus */
     
@@ -2886,16 +2844,16 @@ YY_BUFFER_STATE xbt_graph_parse__scan_buffer  (char * base, yy_size_t  size )
 
 /** Setup the input buffer state to scan a string. The next call to xbt_graph_parse_lex() will
  * scan from a @e copy of @a str.
- * @param str a NUL-terminated string to scan
+ * @param yystr a NUL-terminated string to scan
  * 
  * @return the newly allocated buffer state object.
  * @note If you want to scan bytes that may contain NUL values, then use
  *       xbt_graph_parse__scan_bytes() instead.
  */
-YY_BUFFER_STATE xbt_graph_parse__scan_string (yyconst char * yy_str )
+YY_BUFFER_STATE xbt_graph_parse__scan_string (yyconst char * yystr )
 {
     
-       return xbt_graph_parse__scan_bytes(yy_str,strlen(yy_str) );
+       return xbt_graph_parse__scan_bytes(yystr,strlen(yystr) );
 }
 
 /** Setup the input buffer state to scan the given bytes. The next call to xbt_graph_parse_lex() will
@@ -2905,7 +2863,7 @@ YY_BUFFER_STATE xbt_graph_parse__scan_string (yyconst char * yy_str )
  * 
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE xbt_graph_parse__scan_bytes  (yyconst char * bytes, int  len )
+YY_BUFFER_STATE xbt_graph_parse__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 {
        YY_BUFFER_STATE b;
        char *buf;
@@ -2913,15 +2871,15 @@ YY_BUFFER_STATE xbt_graph_parse__scan_bytes  (yyconst char * bytes, int  len )
        int i;
     
        /* Get memory for full buffer, including space for trailing EOB's. */
-       n = len + 2;
+       n = _yybytes_len + 2;
        buf = (char *) xbt_graph_parse_alloc(n  );
        if ( ! buf )
                YY_FATAL_ERROR( "out of dynamic memory in xbt_graph_parse__scan_bytes()" );
 
-       for ( i = 0; i < len; ++i )
-               buf[i] = bytes[i];
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
 
-       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
        b = xbt_graph_parse__scan_buffer(buf,n );
        if ( ! b )
@@ -3075,6 +3033,41 @@ void xbt_graph_parse_set_debug (int  bdebug )
         xbt_graph_parse__flex_debug = bdebug ;
 }
 
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from xbt_graph_parse_lex_destroy(), so don't allocate here.
+     */
+
+    /* We do not touch xbt_graph_parse_lineno unless the option is enabled. */
+    xbt_graph_parse_lineno =  1;
+    
+    (yy_buffer_stack) = 0;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = (char *) 0;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+    (yy_start_stack_ptr) = 0;
+    (yy_start_stack_depth) = 0;
+    (yy_start_stack) =  NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    xbt_graph_parse_in = stdin;
+    xbt_graph_parse_out = stdout;
+#else
+    xbt_graph_parse_in = (FILE *) 0;
+    xbt_graph_parse_out = (FILE *) 0;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * xbt_graph_parse_lex_init()
+     */
+    return 0;
+}
+
 /* xbt_graph_parse_lex_destroy is for both reentrant and non-reentrant scanners. */
 int xbt_graph_parse_lex_destroy  (void)
 {
@@ -3094,6 +3087,10 @@ int xbt_graph_parse_lex_destroy  (void)
         xbt_graph_parse_free((yy_start_stack)  );
         (yy_start_stack) = NULL;
 
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * xbt_graph_parse_lex() is called, initialization will occur. */
+    yy_init_globals( );
+
     return 0;
 }
 
@@ -3105,7 +3102,7 @@ int xbt_graph_parse_lex_destroy  (void)
 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 {
        register int i;
-       for ( i = 0; i < n; ++i )
+       for ( i = 0; i < n; ++i )
                s1[i] = s2[i];
 }
 #endif
@@ -3114,7 +3111,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 static int yy_flex_strlen (yyconst char * s )
 {
        register int n;
-       for ( n = 0; s[n]; ++n )
+       for ( n = 0; s[n]; ++n )
                ;
 
        return n;
@@ -3145,22 +3142,6 @@ void xbt_graph_parse_free (void * ptr )
 
 #define YYTABLES_NAME "yytables"
 
-#undef YY_NEW_FILE
-#undef YY_FLUSH_BUFFER
-#undef yy_set_bol
-#undef yy_new_buffer
-#undef yy_set_interactive
-#undef yytext_ptr
-#undef YY_DO_BEFORE_ACTION
-
-#ifdef YY_DECL_IS_OURS
-#undef YY_DECL_IS_OURS
-#undef YY_DECL
-#endif
-#line 533 "xbt/graphxml.l"
-
-
-
 /* Element context stack lookup. */
 int graphxml_element_context(int i)
 {
@@ -3174,19 +3155,39 @@ void print_yy_stack(char* fmt, ...)
 {
   int i = 0; va_list ap; va_start(ap, fmt);
   vfprintf(stderr, fmt, ap);
-  for (i=1; i<yy_start_stack_ptr; i++)
-    fprintf(stderr, "%s/", graphxml_statenames[yy_start_stack[i] ]);
-  fprintf(stderr,"%s\n", graphxml_statenames[YY_START]);
+  if (graphxml_statenames) {
+      for (i=1; i<yy_start_stack_ptr; i++) {
+          fprintf(stderr, "%s/", graphxml_statenames[yy_start_stack[i] ]);
+      }
+      fprintf(stderr,"%s\n", graphxml_statenames[YY_START]);
+  }
   va_end(ap);
 }
 
+void print_graphxml_bufferstack()
+{
+    int i;
+    fputs("Buffer: ", stderr);
+    for (i = 0; i < blimit; i++) {
+       if ( graphxml_bufferstack[i] == '\377' ) break;
+         putc(graphxml_bufferstack[i], stderr);
+    }
+    putc('\n', stderr);
+}
+
 static void debug_enter(int state, const char* statename) {
   yy_push_state(state);
-  if (xbt_graph_parse__flex_debug) print_yy_stack("--ENTER(%s) : ",statename);
+  if (xbt_graph_parse__flex_debug) {
+       print_yy_stack("--ENTER(%s) : ",statename);
+       print_graphxml_bufferstack();
+  }
 }
 
 static void debug_leave(void) {
-  if (xbt_graph_parse__flex_debug) print_yy_stack("--LEAVE : ");
+    if (xbt_graph_parse__flex_debug) {
+        print_yy_stack("--LEAVE : ");
+       print_graphxml_bufferstack();
+    }
   yy_pop_state();
 }
 
@@ -3196,28 +3197,18 @@ static void debug_set(int state, const char* statename) {
 }
 #endif
 
-enum {flexml_max_err_msg_size = 512};
-
-static char flexml_err_msg[flexml_max_err_msg_size];
-const char * graphxml_parse_err_msg()
-{
-    return flexml_err_msg;
-}
-
-static void reset_graphxml_parse_err_msg()
-{
-    flexml_err_msg[0] = '\0';
-}
-
-
 static void cleanup(void)
 {
     if (graphxml_statenames) {
         free(graphxml_statenames);
        graphxml_statenames = NULL;
     }
-}
+    free(graphxml_bufferstack);
+    graphxml_bufferstack = NULL;
 
+    free(indexstack);
+    indexstack = NULL;
+}
 
 static int fail(const char* fmt, ...)
 {