Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Automatically cleaned flexml files.
[simgrid.git] / src / surf / surfxml.l
index f534db3..c717b83 100644 (file)
@@ -1,12 +1,22 @@
-/* Validating XML processor for surfxml.dtd.
- * Generated 2005/01/04 14:37:23.
+/* Validating XML processor for surf/surfxml.dtd.
+ * Generated 2007/08/09 10:57:49.
  *
- * This program was generated with the FleXML XML processor generator,
- * (Id: flexml.pl,v 1.29 2005/01/04 09:30:15 alegrand Exp).
- * Copyright © 1999 Kristoffer Rose.  All rights reserved.
+ * 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.61 2006/09/13 16:34:33 wdowling Exp).
+ * 
+ * There are two, intertwined parts to this program, part A and part B.
  *
- * You can redistribute and/or modify this program provided the following
- * two conditions hold:
+ * Part A
+ * ------
+ * 
+ * Some parts, here collectively called "Part A", are found in the 
+ * FleXML package.  They are Copyright (C) 1999-2005 Kristoffer Rose
+ * and Copyright (C) 2003-2006 Martin Quinson. All rights reserved.
+ *
+ * You can redistribute, use, perform, display and/or modify "Part A"
+ * provided the following two conditions hold:
  *
  * 1. The program is distributed WITHOUT ANY WARRANTY from the author of
  *    FleXML; without even the implied warranty of MERCHANTABILITY or
  * Notice that these are explicit rights granted to you for files
  * generated by the FleXML system.  For your rights in connection with
  * the FleXML system itself please consult the GNU General Public License.
+ * 
+ * Part B
+ * ------
+ * 
+ * The other parts, here collectively called "Part B", and which came 
+ * from the DTD used by FleXML to generate this program, can be 
+ * distributed (or not, as the case may be) under the terms of whoever
+ * wrote them, provided these terms respect and obey the two conditions 
+ * above under the heading "Part A".
+ *
+ * The author of and contributors to FleXML specifically disclaim
+ * any copyright interest in "Part B", unless "Part B" was written 
+ * by the author of or contributors to FleXML.
+ * 
  */
 
 %{
 
 /* Version strings. */
-const char rcs_flexml_skeleton[] =
- "$" "Id: skel,v 1.16 1999/12/09 04:01:51 krisrose Exp $";
-const char rcs_flexml[] =
- "$" "Id: flexml.pl,v 1.29 2005/01/04 09:30:15 alegrand Exp $";
+const char rcs_surfxml_flexml_skeleton[] =
+ "$" "Id: skel,v 1.38 2006/09/12 18:05:45 wdowling Exp $";
+const char rcs_surfxml_flexml[] =
+ "$" "Id: flexml.pl,v 1.61 2006/09/13 16:34:33 wdowling Exp $";
 
 /* ANSI headers. */
 #include <unistd.h>
@@ -37,33 +61,88 @@ const char rcs_flexml[] =
 #include <stdarg.h>
 #include <ctype.h>
 
+#ifndef FLEXML_INDEXSTACKSIZE
+#define FLEXML_INDEXSTACKSIZE 1000
+#endif
+
 /* Generated definitions. */
-#define FLEXML_BUFFERSTACKSIZE 10000000
+#define FLEXML_yylineno
+#ifndef FLEXML_BUFFERSTACKSIZE
+#define FLEXML_BUFFERSTACKSIZE 1000000
+#endif
+#define FLEXML_NEED_BUFFERLIT
 
 /* XML processor api. */
-#include "surf/surfxml.h"
-
 /* FleXML-provided data. */
-const char* pcdata;
-AT_network_link_bandwidth A_network_link_bandwidth;
-AT_cpu_name A_cpu_name;
-AT_network_link_state A_network_link_state;
-AT_argument_value A_argument_value;
-AT_cpu_availability_file A_cpu_availability_file;
-AT_process_host A_process_host;
-AT_route_src A_route_src;
-AT_network_link_latency_file A_network_link_latency_file;
-AT_cpu_availability A_cpu_availability;
-AT_network_link_name A_network_link_name;
-AT_route_element_name A_route_element_name;
-AT_cpu_power A_cpu_power;
-AT_process_function A_process_function;
-AT_cpu_state A_cpu_state;
-AT_route_dst A_route_dst;
-AT_network_link_latency A_network_link_latency;
-AT_cpu_state_file A_cpu_state_file;
-AT_network_link_state_file A_network_link_state_file;
-AT_network_link_bandwidth_file A_network_link_bandwidth_file;
+int surfxml_pcdata_ix;
+extern char *surfxml_bufferstack;
+#define surfxml_pcdata (surfxml_bufferstack + surfxml_pcdata_ix)
+AT_surfxml_network_link_bandwidth AX_surfxml_network_link_bandwidth;
+#define A_surfxml_network_link_bandwidth (surfxml_bufferstack + AX_surfxml_network_link_bandwidth)
+AT_surfxml_router_name AX_surfxml_router_name;
+#define A_surfxml_router_name (surfxml_bufferstack + AX_surfxml_router_name)
+AT_surfxml_process_host AX_surfxml_process_host;
+#define A_surfxml_process_host (surfxml_bufferstack + AX_surfxml_process_host)
+AT_surfxml_network_link_latency_file AX_surfxml_network_link_latency_file;
+#define A_surfxml_network_link_latency_file (surfxml_bufferstack + AX_surfxml_network_link_latency_file)
+AT_surfxml_route_impact_on_dst_with_other_send AX_surfxml_route_impact_on_dst_with_other_send;
+#define A_surfxml_route_impact_on_dst_with_other_send (surfxml_bufferstack + AX_surfxml_route_impact_on_dst_with_other_send)
+AT_surfxml_cpu_interference_send_recv AX_surfxml_cpu_interference_send_recv;
+#define A_surfxml_cpu_interference_send_recv (surfxml_bufferstack + AX_surfxml_cpu_interference_send_recv)
+AT_surfxml_route_impact_on_dst AX_surfxml_route_impact_on_dst;
+#define A_surfxml_route_impact_on_dst (surfxml_bufferstack + AX_surfxml_route_impact_on_dst)
+AT_surfxml_platform_description_version AX_surfxml_platform_description_version;
+#define A_surfxml_platform_description_version (surfxml_bufferstack + AX_surfxml_platform_description_version)
+AT_surfxml_route_impact_on_src_with_other_recv AX_surfxml_route_impact_on_src_with_other_recv;
+#define A_surfxml_route_impact_on_src_with_other_recv (surfxml_bufferstack + AX_surfxml_route_impact_on_src_with_other_recv)
+AT_surfxml_route_element_name AX_surfxml_route_element_name;
+#define A_surfxml_route_element_name (surfxml_bufferstack + AX_surfxml_route_element_name)
+AT_surfxml_process_start_time AX_surfxml_process_start_time;
+#define A_surfxml_process_start_time (surfxml_bufferstack + AX_surfxml_process_start_time)
+AT_surfxml_process_function AX_surfxml_process_function;
+#define A_surfxml_process_function (surfxml_bufferstack + AX_surfxml_process_function)
+AT_surfxml_cpu_state AX_surfxml_cpu_state;
+#define A_surfxml_cpu_state AX_surfxml_cpu_state
+AT_surfxml_cpu_interference_send AX_surfxml_cpu_interference_send;
+#define A_surfxml_cpu_interference_send (surfxml_bufferstack + AX_surfxml_cpu_interference_send)
+AT_surfxml_network_link_bandwidth_file AX_surfxml_network_link_bandwidth_file;
+#define A_surfxml_network_link_bandwidth_file (surfxml_bufferstack + AX_surfxml_network_link_bandwidth_file)
+AT_surfxml_cpu_name AX_surfxml_cpu_name;
+#define A_surfxml_cpu_name (surfxml_bufferstack + AX_surfxml_cpu_name)
+AT_surfxml_process_kill_time AX_surfxml_process_kill_time;
+#define A_surfxml_process_kill_time (surfxml_bufferstack + AX_surfxml_process_kill_time)
+AT_surfxml_network_link_state AX_surfxml_network_link_state;
+#define A_surfxml_network_link_state AX_surfxml_network_link_state
+AT_surfxml_cpu_availability_file AX_surfxml_cpu_availability_file;
+#define A_surfxml_cpu_availability_file (surfxml_bufferstack + AX_surfxml_cpu_availability_file)
+AT_surfxml_argument_value AX_surfxml_argument_value;
+#define A_surfxml_argument_value (surfxml_bufferstack + AX_surfxml_argument_value)
+AT_surfxml_route_src AX_surfxml_route_src;
+#define A_surfxml_route_src (surfxml_bufferstack + AX_surfxml_route_src)
+AT_surfxml_route_impact_on_src AX_surfxml_route_impact_on_src;
+#define A_surfxml_route_impact_on_src (surfxml_bufferstack + AX_surfxml_route_impact_on_src)
+AT_surfxml_cpu_max_outgoing_rate AX_surfxml_cpu_max_outgoing_rate;
+#define A_surfxml_cpu_max_outgoing_rate (surfxml_bufferstack + AX_surfxml_cpu_max_outgoing_rate)
+AT_surfxml_cpu_availability AX_surfxml_cpu_availability;
+#define A_surfxml_cpu_availability (surfxml_bufferstack + AX_surfxml_cpu_availability)
+AT_surfxml_cpu_interference_recv AX_surfxml_cpu_interference_recv;
+#define A_surfxml_cpu_interference_recv (surfxml_bufferstack + AX_surfxml_cpu_interference_recv)
+AT_surfxml_network_link_name AX_surfxml_network_link_name;
+#define A_surfxml_network_link_name (surfxml_bufferstack + AX_surfxml_network_link_name)
+AT_surfxml_cpu_power AX_surfxml_cpu_power;
+#define A_surfxml_cpu_power (surfxml_bufferstack + AX_surfxml_cpu_power)
+AT_surfxml_include_file AX_surfxml_include_file;
+#define A_surfxml_include_file (surfxml_bufferstack + AX_surfxml_include_file)
+AT_surfxml_network_link_sharing_policy AX_surfxml_network_link_sharing_policy;
+#define A_surfxml_network_link_sharing_policy AX_surfxml_network_link_sharing_policy
+AT_surfxml_route_dst AX_surfxml_route_dst;
+#define A_surfxml_route_dst (surfxml_bufferstack + AX_surfxml_route_dst)
+AT_surfxml_network_link_latency AX_surfxml_network_link_latency;
+#define A_surfxml_network_link_latency (surfxml_bufferstack + AX_surfxml_network_link_latency)
+AT_surfxml_cpu_state_file AX_surfxml_cpu_state_file;
+#define A_surfxml_cpu_state_file (surfxml_bufferstack + AX_surfxml_cpu_state_file)
+AT_surfxml_network_link_state_file AX_surfxml_network_link_state_file;
+#define A_surfxml_network_link_state_file (surfxml_bufferstack + AX_surfxml_network_link_state_file)
 
 /* XML state. */
 #ifdef FLEX_DEBUG
@@ -81,61 +160,102 @@ AT_network_link_bandwidth_file A_network_link_bandwidth_file;
 
 /* Generic actions. */
 #define SKIP   /*skip*/
-#define SUCCEED        return 0
+#define SUCCEED        CLEANUP; return 0
 
 #define FAIL   return fail
 static int fail(const char*, ...);
 
+enum {flexml_max_err_msg_size = 512};
+static char flexml_err_msg[flexml_max_err_msg_size];
+const char * surfxml_parse_err_msg()
+{
+    return flexml_err_msg;
+}
+static void reset_surfxml_parse_err_msg()
+{
+    flexml_err_msg[0] = '\0';
+}
+
+/* Cleanup */
+static void cleanup(void);
+#define CLEANUP  cleanup()
+
 /* Text buffer stack handling. */
-char bufferstack[FLEXML_BUFFERSTACKSIZE];
-char* limit = bufferstack + FLEXML_BUFFERSTACKSIZE;
-typedef struct BufferLast_s {
-  struct BufferLast_s *old; char* saved; char new[1];
-} BufferLast;
-BufferLast* last = (BufferLast*)0;
-char* next = bufferstack;
-
-#define BUFFERSET(P)  (P = next)
-#define BUFFERPUTC(C) (assert(next<limit), *(next++) = (C))
+char *surfxml_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 = bnext)
+#define BUFFERPUTC(C) (ck_blimit(), surfxml_bufferstack[bnext++] = (C))
 #define BUFFERDONE    (BUFFERPUTC('\0'))
 
-#define BUFFERLITERAL(C,P) bufferliteral(C,&(P),yytext)
-static void bufferliteral(char c, char** pp, char* text)
+#define BUFFERLITERAL(C, P) surfxml_bufferliteral(C, &(P), yytext)
+
+/* after this is called, there are at least 2 slots left in the stack */
+static int ck_blimit()
+{
+     if (bnext >= blimit) {
+        blimit += FLEXML_BUFFERSTACKSIZE + 2;
+        {
+            char *temp = (char *) realloc(surfxml_bufferstack, blimit);
+            assert(temp);
+            surfxml_bufferstack = temp;
+        }
+     }
+     return 0;
+}
+
+/* after this is called, there are at least 2 slots left in the stack */
+static int ck_ilimit()
 {
-  char *s = strchr(text,c), *e = strrchr(text,c);
+     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 surfxml_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(char* p)
+static void pushbuffer(int p)
 {
-  BufferLast* l = (BufferLast*)next;
-  assert(next < limit);
-  l->old = last;
-  l->saved = p;
-  next = l->new;
-  last = l;
+    ck_ilimit();
+    indexstack[inext++] = p;
+    indexstack[inext++] = bnext;    
 }
 
-static 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. */
@@ -147,6 +267,7 @@ static char* popbuffer(void)
 %option noyywrap
 
 /* Flex user-requested options. */
+%option yylineno
 %option nounput
 
 /* XML character classes (currently restricted to ASCII). */
@@ -176,75 +297,117 @@ Literal          \'[^'']*\'|\"[^""]*\"
  * INPI                inside an XML PI <?...?>
  * VALUE1      inside a '...'-delimited literal
  * VALUE2      inside a "..."-delimited literal
- * CDATA       inside a <![CDATA[...]]> section.
+ * CDATA       inside a <![CDATA[...] ]> section.
  * ROOT_<tag>  expect root element <tag>
  * AL_<tag>    inside the attribute list for <tag>
  * IN_<tag>    inside a <tag> with element contents (ready for end tag)
  * IMPOSSIBLE  dummy to permit disabling rules; must be last
  */
 %x PROLOG DOCTYPE EPILOG INCOMMENT INPI VALUE1 VALUE2 CDATA
-%x ROOT_platform_description AL_platform_description S_platform_description S_platform_description_1 S_platform_description_2 E_platform_description
-%x ROOT_cpu AL_cpu E_cpu
-%x ROOT_network_link AL_network_link E_network_link
-%x ROOT_route AL_route S_route S_route_1 S_route_2 E_route
-%x ROOT_route_element AL_route_element E_route_element
-%x ROOT_process AL_process S_process S_process_1 S_process_2 E_process
-%x ROOT_argument AL_argument E_argument
+%x ROOT_surfxml_platform_description AL_surfxml_platform_description S_surfxml_platform_description S_surfxml_platform_description_1 S_surfxml_platform_description_2 E_surfxml_platform_description
+%x ROOT_surfxml_include AL_surfxml_include S_surfxml_include S_surfxml_include_1 S_surfxml_include_2 E_surfxml_include
+%x ROOT_surfxml_cpu AL_surfxml_cpu E_surfxml_cpu
+%x ROOT_surfxml_router AL_surfxml_router E_surfxml_router
+%x ROOT_surfxml_network_link AL_surfxml_network_link E_surfxml_network_link
+%x ROOT_surfxml_route AL_surfxml_route S_surfxml_route S_surfxml_route_1 S_surfxml_route_2 E_surfxml_route
+%x ROOT_surfxml_route_element AL_surfxml_route_element E_surfxml_route_element
+%x ROOT_surfxml_process AL_surfxml_process S_surfxml_process S_surfxml_process_1 S_surfxml_process_2 E_surfxml_process
+%x ROOT_surfxml_argument AL_surfxml_argument E_surfxml_argument
 %x IMPOSSIBLE
 
 %{
 /* State names. */
-const char* *statenames=NULL;
+const char* *surfxml_statenames=NULL;
 %}
 
 %%
 
  /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
  SET(PROLOG);
+ reset_surfxml_parse_err_msg();
+ surfxml_bufferstack = (char *) malloc(FLEXML_BUFFERSTACKSIZE);
+ assert(surfxml_bufferstack);
+ #ifdef FLEX_DEBUG
+ {
+     int i;
+     for (i = 0; i < blimit; i++) {
+         surfxml_bufferstack[i] = '\377';
+     }
+ }
+ #endif
+ surfxml_bufferstack[0] = '\0';
+ indexstack = (int *) malloc(FLEXML_INDEXSTACKSIZE * sizeof(int));
+ assert(indexstack);
+ indexstack[0] = 0;
+
   /* FleXML_init */
-  if(!statenames) statenames=calloc(IMPOSSIBLE,sizeof(char*));
-  statenames[PROLOG] = NULL;
-  statenames[DOCTYPE] = NULL;
-  statenames[EPILOG] = NULL;
-  statenames[INCOMMENT] = NULL;
-  statenames[INPI] = NULL;
-  statenames[VALUE1] = NULL;
-  statenames[VALUE2] = NULL;
-  statenames[CDATA] = NULL;
-  statenames[ROOT_platform_description] = NULL;
-  statenames[AL_platform_description] = NULL;
-  statenames[S_platform_description] = "platform_description";
-  statenames[S_platform_description_1] = "platform_description";
-  statenames[S_platform_description_2] = "platform_description";
-  statenames[E_platform_description] = "platform_description";
-  statenames[ROOT_cpu] = NULL;
-  statenames[AL_cpu] = NULL;
-  statenames[E_cpu] = "cpu";
-  statenames[ROOT_network_link] = NULL;
-  statenames[AL_network_link] = NULL;
-  statenames[E_network_link] = "network_link";
-  statenames[ROOT_route] = NULL;
-  statenames[AL_route] = NULL;
-  statenames[S_route] = "route";
-  statenames[S_route_1] = "route";
-  statenames[S_route_2] = "route";
-  statenames[E_route] = "route";
-  statenames[ROOT_route_element] = NULL;
-  statenames[AL_route_element] = NULL;
-  statenames[E_route_element] = "route_element";
-  statenames[ROOT_process] = NULL;
-  statenames[AL_process] = NULL;
-  statenames[S_process] = "process";
-  statenames[S_process_1] = "process";
-  statenames[S_process_2] = "process";
-  statenames[E_process] = "process";
-  statenames[ROOT_argument] = NULL;
-  statenames[AL_argument] = NULL;
-  statenames[E_argument] = "argument";
+  bnext = inext = 1;
+  surfxml_bufferliteral('\0', &bnext, "0.0");
+  surfxml_bufferliteral('\0', &bnext, "1.0");
+  surfxml_bufferliteral('\0', &bnext, "1.0");
+  surfxml_bufferliteral('\0', &bnext, "1.0");
+  surfxml_bufferliteral('\0', &bnext, "1.0");
+  surfxml_bufferliteral('\0', &bnext, "-1.0");
+  surfxml_bufferliteral('\0', &bnext, "0.0");
+  surfxml_bufferliteral('\0', &bnext, "0.0");
+  surfxml_bufferliteral('\0', &bnext, "0.0");
+  surfxml_bufferliteral('\0', &bnext, "0.0");
+  surfxml_bufferliteral('\0', &bnext, "0.0");
+  surfxml_bufferliteral('\0', &bnext, "-1.0");
+  surfxml_bufferliteral('\0', &bnext, "-1.0");
+  if(!surfxml_statenames) {surfxml_statenames= (const char **)calloc(IMPOSSIBLE,sizeof(char*));
+  surfxml_statenames[PROLOG] = NULL;
+  surfxml_statenames[DOCTYPE] = NULL;
+  surfxml_statenames[EPILOG] = NULL;
+  surfxml_statenames[INCOMMENT] = NULL;
+  surfxml_statenames[INPI] = NULL;
+  surfxml_statenames[VALUE1] = NULL;
+  surfxml_statenames[VALUE2] = NULL;
+  surfxml_statenames[CDATA] = NULL;
+  surfxml_statenames[ROOT_surfxml_platform_description] = NULL;
+  surfxml_statenames[AL_surfxml_platform_description] = NULL;
+  surfxml_statenames[S_surfxml_platform_description] = "platform_description";
+  surfxml_statenames[S_surfxml_platform_description_1] = "platform_description";
+  surfxml_statenames[S_surfxml_platform_description_2] = "platform_description";
+  surfxml_statenames[E_surfxml_platform_description] = "platform_description";
+  surfxml_statenames[ROOT_surfxml_include] = NULL;
+  surfxml_statenames[AL_surfxml_include] = NULL;
+  surfxml_statenames[S_surfxml_include] = "include";
+  surfxml_statenames[S_surfxml_include_1] = "include";
+  surfxml_statenames[S_surfxml_include_2] = "include";
+  surfxml_statenames[E_surfxml_include] = "include";
+  surfxml_statenames[ROOT_surfxml_cpu] = NULL;
+  surfxml_statenames[AL_surfxml_cpu] = NULL;
+  surfxml_statenames[E_surfxml_cpu] = "cpu";
+  surfxml_statenames[ROOT_surfxml_router] = NULL;
+  surfxml_statenames[AL_surfxml_router] = NULL;
+  surfxml_statenames[E_surfxml_router] = "router";
+  surfxml_statenames[ROOT_surfxml_network_link] = NULL;
+  surfxml_statenames[AL_surfxml_network_link] = NULL;
+  surfxml_statenames[E_surfxml_network_link] = "network_link";
+  surfxml_statenames[ROOT_surfxml_route] = NULL;
+  surfxml_statenames[AL_surfxml_route] = NULL;
+  surfxml_statenames[S_surfxml_route] = "route";
+  surfxml_statenames[S_surfxml_route_1] = "route";
+  surfxml_statenames[S_surfxml_route_2] = "route";
+  surfxml_statenames[E_surfxml_route] = "route";
+  surfxml_statenames[ROOT_surfxml_route_element] = NULL;
+  surfxml_statenames[AL_surfxml_route_element] = NULL;
+  surfxml_statenames[E_surfxml_route_element] = "route_element";
+  surfxml_statenames[ROOT_surfxml_process] = NULL;
+  surfxml_statenames[AL_surfxml_process] = NULL;
+  surfxml_statenames[S_surfxml_process] = "process";
+  surfxml_statenames[S_surfxml_process_1] = "process";
+  surfxml_statenames[S_surfxml_process_2] = "process";
+  surfxml_statenames[E_surfxml_process] = "process";
+  surfxml_statenames[ROOT_surfxml_argument] = NULL;
+  surfxml_statenames[AL_surfxml_argument] = NULL;
+  surfxml_statenames[E_surfxml_argument] = "argument";
+  }
 
  /* COMMENTS and PIs: handled uniformly for efficiency. */
 
-<ROOT_platform_description,AL_platform_description,S_platform_description,S_platform_description_1,S_platform_description_2,E_platform_description,ROOT_cpu,AL_cpu,E_cpu,ROOT_network_link,AL_network_link,E_network_link,ROOT_route,AL_route,S_route,S_route_1,S_route_2,E_route,ROOT_route_element,AL_route_element,E_route_element,ROOT_process,AL_process,S_process,S_process_1,S_process_2,E_process,ROOT_argument,AL_argument,E_argument,PROLOG,DOCTYPE,EPILOG>{
+<ROOT_surfxml_platform_description,AL_surfxml_platform_description,S_surfxml_platform_description,S_surfxml_platform_description_1,S_surfxml_platform_description_2,E_surfxml_platform_description,ROOT_surfxml_include,AL_surfxml_include,S_surfxml_include,S_surfxml_include_1,S_surfxml_include_2,E_surfxml_include,ROOT_surfxml_cpu,AL_surfxml_cpu,E_surfxml_cpu,ROOT_surfxml_router,AL_surfxml_router,E_surfxml_router,ROOT_surfxml_network_link,AL_surfxml_network_link,E_surfxml_network_link,ROOT_surfxml_route,AL_surfxml_route,S_surfxml_route,S_surfxml_route_1,S_surfxml_route_2,E_surfxml_route,ROOT_surfxml_route_element,AL_surfxml_route_element,E_surfxml_route_element,ROOT_surfxml_process,AL_surfxml_process,S_surfxml_process,S_surfxml_process_1,S_surfxml_process_2,E_surfxml_process,ROOT_surfxml_argument,AL_surfxml_argument,E_surfxml_argument,PROLOG,DOCTYPE,EPILOG>{
  "<!--" ENTER(INCOMMENT);
  "<?" ENTER(INPI);
 }
@@ -253,383 +416,536 @@ const char* *statenames=NULL;
  "--"          |
  .             |
  \n            SKIP;
- <<EOF>>       fail("EOF in comment.");
+ <<EOF>>       FAIL("EOF in comment.");
 }
 <INPI>{
  "?>"          LEAVE;
  .             |
  \n            SKIP;
- <<EOF>>       fail("EOF in PI (processing instruction).");
+ <<EOF>>       FAIL("EOF in PI (processing instruction).");
 }
 
  /* SPACES: skipped uniformly */
 
-<ROOT_platform_description,AL_platform_description,S_platform_description,S_platform_description_1,S_platform_description_2,E_platform_description,ROOT_cpu,AL_cpu,E_cpu,ROOT_network_link,AL_network_link,E_network_link,ROOT_route,AL_route,S_route,S_route_1,S_route_2,E_route,ROOT_route_element,AL_route_element,E_route_element,ROOT_process,AL_process,S_process,S_process_1,S_process_2,E_process,ROOT_argument,AL_argument,E_argument,PROLOG,DOCTYPE,EPILOG>{S} SKIP;
+<ROOT_surfxml_platform_description,AL_surfxml_platform_description,S_surfxml_platform_description,S_surfxml_platform_description_1,S_surfxml_platform_description_2,E_surfxml_platform_description,ROOT_surfxml_include,AL_surfxml_include,S_surfxml_include,S_surfxml_include_1,S_surfxml_include_2,E_surfxml_include,ROOT_surfxml_cpu,AL_surfxml_cpu,E_surfxml_cpu,ROOT_surfxml_router,AL_surfxml_router,E_surfxml_router,ROOT_surfxml_network_link,AL_surfxml_network_link,E_surfxml_network_link,ROOT_surfxml_route,AL_surfxml_route,S_surfxml_route,S_surfxml_route_1,S_surfxml_route_2,E_surfxml_route,ROOT_surfxml_route_element,AL_surfxml_route_element,E_surfxml_route_element,ROOT_surfxml_process,AL_surfxml_process,S_surfxml_process,S_surfxml_process_1,S_surfxml_process_2,E_surfxml_process,ROOT_surfxml_argument,AL_surfxml_argument,E_surfxml_argument,PROLOG,DOCTYPE,EPILOG>{S} SKIP;
 
  /* PROLOG: determine root element and process it. */
 
 <PROLOG>{
- "<?xml"({S}version{Eq}(\'{VersionNum}\'|\"{VersionNum}\"))?"?>" SET(DOCTYPE);
- "<?xml"[^>]*">" fail("Bad declaration %s.",yytext);
+ "<?xml"({S}version{Eq}(\'{VersionNum}\'|\"{VersionNum}\"))?({S}encoding{Eq}(\'[^']*\'|\"[^"]*\"))?"?>" SET(DOCTYPE); 
+ "<?xml"[^>]*">" FAIL("Bad declaration %s.",yytext);
 }
 
 <PROLOG,DOCTYPE>{
- "<!DOCTYPE"{S}"argument"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_argument);
- "<!DOCTYPE"{S}"route_element"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_route_element);
- "<!DOCTYPE"{S}"cpu"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_cpu);
- "<!DOCTYPE"{S}"route"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_route);
- "<!DOCTYPE"{S}"platform_description"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_platform_description);
- "<!DOCTYPE"{S}"network_link"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_network_link);
- "<!DOCTYPE"{S}"process"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_process);
- "<!"[^>-][^>]*">" fail("Bad declaration %s.",yytext);
- .             fail("Unexpected character `%c' in prolog.", yytext[0]);
- <<EOF>>       fail("EOF in prolog.");
+ "<!DOCTYPE"{S}"cpu"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_cpu);
+ "<!DOCTYPE"{S}"include"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_include);
+ "<!DOCTYPE"{S}"route"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_route);
+ "<!DOCTYPE"{S}"network_link"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_network_link);
+ "<!DOCTYPE"{S}"process"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_process);
+ "<!DOCTYPE"{S}"router"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_router);
+ "<!DOCTYPE"{S}"argument"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_argument);
+ "<!DOCTYPE"{S}"route_element"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_route_element);
+ "<!DOCTYPE"{S}"platform_description"{S}SYSTEM{S}("'surfxml.dtd'"|"\"surfxml.dtd\""){s}">" SET(ROOT_surfxml_platform_description);
+ "<!"[^>-][^>]*">" FAIL("Bad declaration %s.",yytext);
+ .             FAIL("Unexpected character `%c' in prolog.", yytext[0]);
+ <<EOF>>       FAIL("EOF in prolog.");
 }
 
  /* RULES DERIVED FROM DTD. */
 
  /* <!-- Small DTD for SURF based tools. -->  */
 
-<ROOT_platform_description>"<platform_description"{s} {
-  ENTER(AL_platform_description);
+<ROOT_surfxml_platform_description>"<platform_description"{s} {
+  AX_surfxml_platform_description_version = 1;
+  ENTER(AL_surfxml_platform_description); pushbuffer(0);
   }
 
-<AL_platform_description>{
+<AL_surfxml_platform_description>{
+ "version"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_platform_description_version);
+ "version"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_platform_description_version);
+
  ">" {
-  LEAVE; STag_platform_description();pcdata = NULL; ENTER(S_platform_description);
+  LEAVE; STag_surfxml_platform_description();surfxml_pcdata_ix = 0; ENTER(S_surfxml_platform_description);
  }
  "/>" {
-  LEAVE; STag_platform_description(); pcdata = NULL; ETag_platform_description();
+  LEAVE; STag_surfxml_platform_description(); surfxml_pcdata_ix = 0; ETag_surfxml_platform_description(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case ROOT_platform_description: SET(EPILOG); break;
+   case ROOT_surfxml_platform_description: SET(EPILOG); break;
   }
  }
- .       fail("Unexpected character `%c' in attribute list of platform_description element.", yytext[0]);
- {Name} fail("Bad attribute `%s' in `platform_description' element start tag.",yytext);
- <<EOF>> fail("EOF in attribute list of `platform_description' element.");
+ .       FAIL("Unexpected character `%c' in attribute list of platform_description element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `platform_description' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `platform_description' element.");
 }
 
-<E_platform_description,S_platform_description_2,S_platform_description>{
+<E_surfxml_platform_description,S_surfxml_platform_description_2,S_surfxml_platform_description>{
  "</platform_description"{s}">" {
   LEAVE;
-  ETag_platform_description();
+  ETag_surfxml_platform_description();
+  popbuffer(); /* attribute */
+  switch (YY_START) {
+   case ROOT_surfxml_platform_description: SET(EPILOG); break;
+  }
+ }
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</platform_description>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</platform_description>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</platform_description>' expected.");
+}
+
+<ROOT_surfxml_include,S_surfxml_platform_description_2,S_surfxml_include,S_surfxml_include_2,S_surfxml_platform_description_1,S_surfxml_include_1,S_surfxml_platform_description>"<include"{s} {
+  AX_surfxml_include_file = 0;
+  ENTER(AL_surfxml_include); pushbuffer(0);
+  }
+
+<AL_surfxml_include>{
+ "file"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_include_file);
+ "file"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_include_file);
+
+ ">" {
+  if (!AX_surfxml_include_file) FAIL("Required attribute `file' not set for `include' element.");
+  LEAVE; STag_surfxml_include();surfxml_pcdata_ix = 0; ENTER(S_surfxml_include);
+ }
+ "/>" {
+  if (!AX_surfxml_include_file) FAIL("Required attribute `file' not set for `include' element.");
+  LEAVE; STag_surfxml_include(); surfxml_pcdata_ix = 0; ETag_surfxml_include(); popbuffer(); /* attribute */
+  switch (YY_START) {
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_include: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
+  }
+ }
+ .       FAIL("Unexpected character `%c' in attribute list of include element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `include' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `include' element.");
+}
+
+<E_surfxml_include,S_surfxml_include,S_surfxml_include_2>{
+ "</include"{s}">" {
+  LEAVE;
+  ETag_surfxml_include();
+  popbuffer(); /* attribute */
   switch (YY_START) {
-   case ROOT_platform_description: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_include: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- "</"{Name}{s}">" fail("Unexpected end-tag `%s': `</platform_description>' expected.",yytext);
- .       fail("Unexpected character `%c': `</platform_description>' expected.",yytext[0]);
- <<EOF>> fail("Premature EOF: `</platform_description>' expected.");
-}
-
-<ROOT_cpu,S_platform_description_2,S_platform_description_1,S_platform_description>"<cpu"{s} {
-  A_cpu_name = NULL;
-  A_cpu_power = NULL;
-  A_cpu_availability = "1.0";
-  A_cpu_availability_file = NULL;
-  A_cpu_state = A_cpu_state_ON;
-  A_cpu_state_file = NULL;
-  ENTER(AL_cpu);
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</include>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</include>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</include>' expected.");
+}
+
+<ROOT_surfxml_cpu,S_surfxml_platform_description_2,S_surfxml_include,S_surfxml_include_2,S_surfxml_platform_description_1,S_surfxml_include_1,S_surfxml_platform_description>"<cpu"{s} {
+  AX_surfxml_cpu_name = 0;
+  AX_surfxml_cpu_power = 0;
+  AX_surfxml_cpu_availability = 5;
+  AX_surfxml_cpu_availability_file = 0;
+  AX_surfxml_cpu_state = A_surfxml_cpu_state_ON;
+  AX_surfxml_cpu_state_file = 0;
+  AX_surfxml_cpu_interference_send = 9;
+  AX_surfxml_cpu_interference_recv = 13;
+  AX_surfxml_cpu_interference_send_recv = 17;
+  AX_surfxml_cpu_max_outgoing_rate = 21;
+  ENTER(AL_surfxml_cpu); pushbuffer(0);
   }
 
-<AL_cpu>{
- "name"{Eq}\' ENTER(VALUE1); BUFFERSET(A_cpu_name);
- "name"{Eq}\" ENTER(VALUE2); BUFFERSET(A_cpu_name);
+<AL_surfxml_cpu>{
+ "name"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_name);
+ "name"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_name);
 
- "power"{Eq}\' ENTER(VALUE1); BUFFERSET(A_cpu_power);
- "power"{Eq}\" ENTER(VALUE2); BUFFERSET(A_cpu_power);
+ "power"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_power);
+ "power"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_power);
 
- "availability"{Eq}\' ENTER(VALUE1); BUFFERSET(A_cpu_availability);
- "availability"{Eq}\" ENTER(VALUE2); BUFFERSET(A_cpu_availability);
+ "availability"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_availability);
+ "availability"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_availability);
 
- "availability_file"{Eq}\' ENTER(VALUE1); BUFFERSET(A_cpu_availability_file);
- "availability_file"{Eq}\" ENTER(VALUE2); BUFFERSET(A_cpu_availability_file);
+ "availability_file"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_availability_file);
+ "availability_file"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_availability_file);
 
  "state"{Eq}"'ON'" |
- "state"{Eq}"\"ON\"" A_cpu_state = A_cpu_state_ON;
+ "state"{Eq}"\"ON\"" A_surfxml_cpu_state = A_surfxml_cpu_state_ON;
  "state"{Eq}"'OFF'" |
- "state"{Eq}"\"OFF\"" A_cpu_state = A_cpu_state_OFF;
+ "state"{Eq}"\"OFF\"" A_surfxml_cpu_state = A_surfxml_cpu_state_OFF;
+
+ "state_file"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_state_file);
+ "state_file"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_state_file);
+
+ "interference_send"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_interference_send);
+ "interference_send"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_interference_send);
+
+ "interference_recv"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_interference_recv);
+ "interference_recv"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_interference_recv);
+
+ "interference_send_recv"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_interference_send_recv);
+ "interference_send_recv"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_interference_send_recv);
 
- "state_file"{Eq}\' ENTER(VALUE1); BUFFERSET(A_cpu_state_file);
- "state_file"{Eq}\" ENTER(VALUE2); BUFFERSET(A_cpu_state_file);
+ "max_outgoing_rate"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_cpu_max_outgoing_rate);
+ "max_outgoing_rate"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_cpu_max_outgoing_rate);
 
  ">" {
-  if (!A_cpu_name) fail("Required attribute `name' not set for `cpu' element.");
-  if (!A_cpu_power) fail("Required attribute `power' not set for `cpu' element.");
-  LEAVE; STag_cpu();pcdata = NULL; ENTER(E_cpu);
+  if (!AX_surfxml_cpu_name) FAIL("Required attribute `name' not set for `cpu' element.");
+  if (!AX_surfxml_cpu_power) FAIL("Required attribute `power' not set for `cpu' element.");
+  LEAVE; STag_surfxml_cpu();surfxml_pcdata_ix = 0; ENTER(E_surfxml_cpu);
  }
  "/>" {
-  if (!A_cpu_name) fail("Required attribute `name' not set for `cpu' element.");
-  if (!A_cpu_power) fail("Required attribute `power' not set for `cpu' element.");
-  LEAVE; STag_cpu(); pcdata = NULL; ETag_cpu();
+  if (!AX_surfxml_cpu_name) FAIL("Required attribute `name' not set for `cpu' element.");
+  if (!AX_surfxml_cpu_power) FAIL("Required attribute `power' not set for `cpu' element.");
+  LEAVE; STag_surfxml_cpu(); surfxml_pcdata_ix = 0; ETag_surfxml_cpu(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_cpu: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_cpu: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- .       fail("Unexpected character `%c' in attribute list of cpu element.", yytext[0]);
- {Name} fail("Bad attribute `%s' in `cpu' element start tag.",yytext);
- <<EOF>> fail("EOF in attribute list of `cpu' element.");
+ .       FAIL("Unexpected character `%c' in attribute list of cpu element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `cpu' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `cpu' element.");
 }
 
-<E_cpu>{
+<E_surfxml_cpu>{
  "</cpu"{s}">" {
   LEAVE;
-  ETag_cpu();
+  ETag_surfxml_cpu();
+  popbuffer(); /* attribute */
+  switch (YY_START) {
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_cpu: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
+  }
+ }
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</cpu>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</cpu>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</cpu>' expected.");
+}
+
+<ROOT_surfxml_router,S_surfxml_platform_description_2,S_surfxml_include,S_surfxml_include_2,S_surfxml_platform_description_1,S_surfxml_include_1,S_surfxml_platform_description>"<router"{s} {
+  AX_surfxml_router_name = 0;
+  ENTER(AL_surfxml_router); pushbuffer(0);
+  }
+
+<AL_surfxml_router>{
+ "name"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_router_name);
+ "name"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_router_name);
+
+ ">" {
+  if (!AX_surfxml_router_name) FAIL("Required attribute `name' not set for `router' element.");
+  LEAVE; STag_surfxml_router();surfxml_pcdata_ix = 0; ENTER(E_surfxml_router);
+ }
+ "/>" {
+  if (!AX_surfxml_router_name) FAIL("Required attribute `name' not set for `router' element.");
+  LEAVE; STag_surfxml_router(); surfxml_pcdata_ix = 0; ETag_surfxml_router(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_cpu: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_router: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
"</"{Name}{s}">" fail("Unexpected end-tag `%s': `</cpu>' expected.",yytext);
.       fail("Unexpected character `%c': `</cpu>' expected.",yytext[0]);
- <<EOF>> fail("Premature EOF: `</cpu>' expected.");
-}
-
-<ROOT_network_link,S_platform_description_2,S_platform_description_1,S_platform_description>"<network_link"{s} {
-  A_network_link_name = NULL;
-  A_network_link_bandwidth = NULL;
-  A_network_link_bandwidth_file = NULL;
-  A_network_link_latency = "0.001";
-  A_network_link_latency_file = NULL;
-  A_network_link_state = A_network_link_state_ON;
-  A_network_link_state_file = NULL;
-  ENTER(AL_network_link);
.       FAIL("Unexpected character `%c' in attribute list of router element.", yytext[0]);
{Name} FAIL("Bad attribute `%s' in `router' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `router' element.");
+}
+
+<E_surfxml_router>{
+ "</router"{s}">" {
+  LEAVE;
+  ETag_surfxml_router();
+  popbuffer(); /* attribute */
+  switch (YY_START) {
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_router: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
+ }
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</router>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</router>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</router>' expected.");
+}
 
-<AL_network_link>{
- "name"{Eq}\' ENTER(VALUE1); BUFFERSET(A_network_link_name);
- "name"{Eq}\" ENTER(VALUE2); BUFFERSET(A_network_link_name);
+<ROOT_surfxml_network_link,S_surfxml_platform_description_2,S_surfxml_include,S_surfxml_include_2,S_surfxml_platform_description_1,S_surfxml_include_1,S_surfxml_platform_description>"<network_link"{s} {
+  AX_surfxml_network_link_name = 0;
+  AX_surfxml_network_link_bandwidth = 0;
+  AX_surfxml_network_link_bandwidth_file = 0;
+  AX_surfxml_network_link_latency = 26;
+  AX_surfxml_network_link_latency_file = 0;
+  AX_surfxml_network_link_state = A_surfxml_network_link_state_ON;
+  AX_surfxml_network_link_state_file = 0;
+  AX_surfxml_network_link_sharing_policy = A_surfxml_network_link_sharing_policy_SHARED;
+  ENTER(AL_surfxml_network_link); pushbuffer(0);
+  }
 
- "bandwidth"{Eq}\' ENTER(VALUE1); BUFFERSET(A_network_link_bandwidth);
- "bandwidth"{Eq}\" ENTER(VALUE2); BUFFERSET(A_network_link_bandwidth);
+<AL_surfxml_network_link>{
+ "name"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_network_link_name);
+ "name"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_network_link_name);
 
- "bandwidth_file"{Eq}\' ENTER(VALUE1); BUFFERSET(A_network_link_bandwidth_file);
- "bandwidth_file"{Eq}\" ENTER(VALUE2); BUFFERSET(A_network_link_bandwidth_file);
+ "bandwidth"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_network_link_bandwidth);
+ "bandwidth"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_network_link_bandwidth);
 
- "latency"{Eq}\' ENTER(VALUE1); BUFFERSET(A_network_link_latency);
- "latency"{Eq}\" ENTER(VALUE2); BUFFERSET(A_network_link_latency);
+ "bandwidth_file"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_network_link_bandwidth_file);
+ "bandwidth_file"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_network_link_bandwidth_file);
 
- "latency_file"{Eq}\' ENTER(VALUE1); BUFFERSET(A_network_link_latency_file);
- "latency_file"{Eq}\" ENTER(VALUE2); BUFFERSET(A_network_link_latency_file);
+ "latency"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_network_link_latency);
+ "latency"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_network_link_latency);
+
+ "latency_file"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_network_link_latency_file);
+ "latency_file"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_network_link_latency_file);
 
  "state"{Eq}"'ON'" |
- "state"{Eq}"\"ON\"" A_network_link_state = A_network_link_state_ON;
+ "state"{Eq}"\"ON\"" A_surfxml_network_link_state = A_surfxml_network_link_state_ON;
  "state"{Eq}"'OFF'" |
- "state"{Eq}"\"OFF\"" A_network_link_state = A_network_link_state_OFF;
+ "state"{Eq}"\"OFF\"" A_surfxml_network_link_state = A_surfxml_network_link_state_OFF;
+
+ "state_file"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_network_link_state_file);
+ "state_file"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_network_link_state_file);
 
- "state_file"{Eq}\' ENTER(VALUE1); BUFFERSET(A_network_link_state_file);
- "state_file"{Eq}\" ENTER(VALUE2); BUFFERSET(A_network_link_state_file);
+ "sharing_policy"{Eq}"'SHARED'" |
+ "sharing_policy"{Eq}"\"SHARED\"" A_surfxml_network_link_sharing_policy = A_surfxml_network_link_sharing_policy_SHARED;
+ "sharing_policy"{Eq}"'FATPIPE'" |
+ "sharing_policy"{Eq}"\"FATPIPE\"" A_surfxml_network_link_sharing_policy = A_surfxml_network_link_sharing_policy_FATPIPE;
 
  ">" {
-  if (!A_network_link_name) fail("Required attribute `name' not set for `network_link' element.");
-  if (!A_network_link_bandwidth) fail("Required attribute `bandwidth' not set for `network_link' element.");
-  LEAVE; STag_network_link();pcdata = NULL; ENTER(E_network_link);
+  if (!AX_surfxml_network_link_name) FAIL("Required attribute `name' not set for `network_link' element.");
+  if (!AX_surfxml_network_link_bandwidth) FAIL("Required attribute `bandwidth' not set for `network_link' element.");
+  LEAVE; STag_surfxml_network_link();surfxml_pcdata_ix = 0; ENTER(E_surfxml_network_link);
  }
  "/>" {
-  if (!A_network_link_name) fail("Required attribute `name' not set for `network_link' element.");
-  if (!A_network_link_bandwidth) fail("Required attribute `bandwidth' not set for `network_link' element.");
-  LEAVE; STag_network_link(); pcdata = NULL; ETag_network_link();
+  if (!AX_surfxml_network_link_name) FAIL("Required attribute `name' not set for `network_link' element.");
+  if (!AX_surfxml_network_link_bandwidth) FAIL("Required attribute `bandwidth' not set for `network_link' element.");
+  LEAVE; STag_surfxml_network_link(); surfxml_pcdata_ix = 0; ETag_surfxml_network_link(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_network_link: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_network_link: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- .       fail("Unexpected character `%c' in attribute list of network_link element.", yytext[0]);
- {Name} fail("Bad attribute `%s' in `network_link' element start tag.",yytext);
- <<EOF>> fail("EOF in attribute list of `network_link' element.");
+ .       FAIL("Unexpected character `%c' in attribute list of network_link element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `network_link' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `network_link' element.");
 }
 
-<E_network_link>{
+<E_surfxml_network_link>{
  "</network_link"{s}">" {
   LEAVE;
-  ETag_network_link();
+  ETag_surfxml_network_link();
+  popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_network_link: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_network_link: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- "</"{Name}{s}">" fail("Unexpected end-tag `%s': `</network_link>' expected.",yytext);
- .       fail("Unexpected character `%c': `</network_link>' expected.",yytext[0]);
- <<EOF>> fail("Premature EOF: `</network_link>' expected.");
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</network_link>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</network_link>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</network_link>' expected.");
 }
 
-<ROOT_route,S_platform_description_2,S_platform_description_1,S_platform_description>"<route"{s} {
-  A_route_src = NULL;
-  A_route_dst = NULL;
-  ENTER(AL_route);
+<ROOT_surfxml_route,S_surfxml_platform_description_2,S_surfxml_include,S_surfxml_include_2,S_surfxml_platform_description_1,S_surfxml_include_1,S_surfxml_platform_description>"<route"{s} {
+  AX_surfxml_route_src = 0;
+  AX_surfxml_route_dst = 0;
+  AX_surfxml_route_impact_on_src = 30;
+  AX_surfxml_route_impact_on_dst = 34;
+  AX_surfxml_route_impact_on_src_with_other_recv = 38;
+  AX_surfxml_route_impact_on_dst_with_other_send = 42;
+  ENTER(AL_surfxml_route); pushbuffer(0);
   }
 
-<AL_route>{
- "src"{Eq}\' ENTER(VALUE1); BUFFERSET(A_route_src);
- "src"{Eq}\" ENTER(VALUE2); BUFFERSET(A_route_src);
+<AL_surfxml_route>{
+ "src"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_route_src);
+ "src"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_route_src);
+
+ "dst"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_route_dst);
+ "dst"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_route_dst);
+
+ "impact_on_src"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_route_impact_on_src);
+ "impact_on_src"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_route_impact_on_src);
+
+ "impact_on_dst"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_route_impact_on_dst);
+ "impact_on_dst"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_route_impact_on_dst);
+
+ "impact_on_src_with_other_recv"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_route_impact_on_src_with_other_recv);
+ "impact_on_src_with_other_recv"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_route_impact_on_src_with_other_recv);
 
- "dst"{Eq}\' ENTER(VALUE1); BUFFERSET(A_route_dst);
- "dst"{Eq}\" ENTER(VALUE2); BUFFERSET(A_route_dst);
+ "impact_on_dst_with_other_send"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_route_impact_on_dst_with_other_send);
+ "impact_on_dst_with_other_send"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_route_impact_on_dst_with_other_send);
 
  ">" {
-  if (!A_route_src) fail("Required attribute `src' not set for `route' element.");
-  if (!A_route_dst) fail("Required attribute `dst' not set for `route' element.");
-  LEAVE; STag_route();pcdata = NULL; ENTER(S_route);
+  if (!AX_surfxml_route_src) FAIL("Required attribute `src' not set for `route' element.");
+  if (!AX_surfxml_route_dst) FAIL("Required attribute `dst' not set for `route' element.");
+  LEAVE; STag_surfxml_route();surfxml_pcdata_ix = 0; ENTER(S_surfxml_route);
  }
  "/>" {
-  if (!A_route_src) fail("Required attribute `src' not set for `route' element.");
-  if (!A_route_dst) fail("Required attribute `dst' not set for `route' element.");
-  LEAVE; STag_route(); pcdata = NULL; ETag_route();
+  if (!AX_surfxml_route_src) FAIL("Required attribute `src' not set for `route' element.");
+  if (!AX_surfxml_route_dst) FAIL("Required attribute `dst' not set for `route' element.");
+  LEAVE; STag_surfxml_route(); surfxml_pcdata_ix = 0; ETag_surfxml_route(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_route: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_route: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- .       fail("Unexpected character `%c' in attribute list of route element.", yytext[0]);
- {Name} fail("Bad attribute `%s' in `route' element start tag.",yytext);
- <<EOF>> fail("EOF in attribute list of `route' element.");
+ .       FAIL("Unexpected character `%c' in attribute list of route element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `route' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `route' element.");
 }
 
-<S_route,S_route_2,E_route>{
+<S_surfxml_route,S_surfxml_route_2,E_surfxml_route>{
  "</route"{s}">" {
   LEAVE;
-  ETag_route();
+  ETag_surfxml_route();
+  popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_route: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_route: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- "</"{Name}{s}">" fail("Unexpected end-tag `%s': `</route>' expected.",yytext);
- .       fail("Unexpected character `%c': `</route>' expected.",yytext[0]);
- <<EOF>> fail("Premature EOF: `</route>' expected.");
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</route>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</route>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</route>' expected.");
 }
 
-<ROOT_route_element,S_route_1,S_route,S_route_2>"<route_element"{s} {
-  A_route_element_name = NULL;
-  ENTER(AL_route_element);
+<ROOT_surfxml_route_element,S_surfxml_route_1,S_surfxml_route,S_surfxml_route_2>"<route_element"{s} {
+  AX_surfxml_route_element_name = 0;
+  ENTER(AL_surfxml_route_element); pushbuffer(0);
   }
 
-<AL_route_element>{
- "name"{Eq}\' ENTER(VALUE1); BUFFERSET(A_route_element_name);
- "name"{Eq}\" ENTER(VALUE2); BUFFERSET(A_route_element_name);
+<AL_surfxml_route_element>{
+ "name"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_route_element_name);
+ "name"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_route_element_name);
 
  ">" {
-  if (!A_route_element_name) fail("Required attribute `name' not set for `route_element' element.");
-  LEAVE; STag_route_element();pcdata = NULL; ENTER(E_route_element);
+  if (!AX_surfxml_route_element_name) FAIL("Required attribute `name' not set for `route_element' element.");
+  LEAVE; STag_surfxml_route_element();surfxml_pcdata_ix = 0; ENTER(E_surfxml_route_element);
  }
  "/>" {
-  if (!A_route_element_name) fail("Required attribute `name' not set for `route_element' element.");
-  LEAVE; STag_route_element(); pcdata = NULL; ETag_route_element();
+  if (!AX_surfxml_route_element_name) FAIL("Required attribute `name' not set for `route_element' element.");
+  LEAVE; STag_surfxml_route_element(); surfxml_pcdata_ix = 0; ETag_surfxml_route_element(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_route_1: case S_route: case S_route_2: SET(S_route_2); break;
-   case ROOT_route_element: SET(EPILOG); break;
+   case S_surfxml_route_1: case S_surfxml_route: case S_surfxml_route_2: SET(S_surfxml_route_2); break;
+   case ROOT_surfxml_route_element: SET(EPILOG); break;
   }
  }
- .       fail("Unexpected character `%c' in attribute list of route_element element.", yytext[0]);
- {Name} fail("Bad attribute `%s' in `route_element' element start tag.",yytext);
- <<EOF>> fail("EOF in attribute list of `route_element' element.");
+ .       FAIL("Unexpected character `%c' in attribute list of route_element element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `route_element' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `route_element' element.");
 }
 
-<E_route_element>{
+<E_surfxml_route_element>{
  "</route_element"{s}">" {
   LEAVE;
-  ETag_route_element();
+  ETag_surfxml_route_element();
+  popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_route_1: case S_route: case S_route_2: SET(S_route_2); break;
-   case ROOT_route_element: SET(EPILOG); break;
+   case S_surfxml_route_1: case S_surfxml_route: case S_surfxml_route_2: SET(S_surfxml_route_2); break;
+   case ROOT_surfxml_route_element: SET(EPILOG); break;
   }
  }
- "</"{Name}{s}">" fail("Unexpected end-tag `%s': `</route_element>' expected.",yytext);
- .       fail("Unexpected character `%c': `</route_element>' expected.",yytext[0]);
- <<EOF>> fail("Premature EOF: `</route_element>' expected.");
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</route_element>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</route_element>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</route_element>' expected.");
 }
 
-<ROOT_process,S_platform_description_2,S_platform_description_1,S_platform_description>"<process"{s} {
-  A_process_host = NULL;
-  A_process_function = NULL;
-  ENTER(AL_process);
+<ROOT_surfxml_process,S_surfxml_platform_description_2,S_surfxml_include,S_surfxml_include_2,S_surfxml_platform_description_1,S_surfxml_include_1,S_surfxml_platform_description>"<process"{s} {
+  AX_surfxml_process_host = 0;
+  AX_surfxml_process_function = 0;
+  AX_surfxml_process_start_time = 46;
+  AX_surfxml_process_kill_time = 51;
+  ENTER(AL_surfxml_process); pushbuffer(0);
   }
 
-<AL_process>{
- "host"{Eq}\' ENTER(VALUE1); BUFFERSET(A_process_host);
- "host"{Eq}\" ENTER(VALUE2); BUFFERSET(A_process_host);
+<AL_surfxml_process>{
+ "host"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_process_host);
+ "host"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_process_host);
 
- "function"{Eq}\' ENTER(VALUE1); BUFFERSET(A_process_function);
- "function"{Eq}\" ENTER(VALUE2); BUFFERSET(A_process_function);
+ "function"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_process_function);
+ "function"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_process_function);
+
+ "start_time"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_process_start_time);
+ "start_time"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_process_start_time);
+
+ "kill_time"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_process_kill_time);
+ "kill_time"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_process_kill_time);
 
  ">" {
-  if (!A_process_host) fail("Required attribute `host' not set for `process' element.");
-  if (!A_process_function) fail("Required attribute `function' not set for `process' element.");
-  LEAVE; STag_process();pcdata = NULL; ENTER(S_process);
+  if (!AX_surfxml_process_host) FAIL("Required attribute `host' not set for `process' element.");
+  if (!AX_surfxml_process_function) FAIL("Required attribute `function' not set for `process' element.");
+  LEAVE; STag_surfxml_process();surfxml_pcdata_ix = 0; ENTER(S_surfxml_process);
  }
  "/>" {
-  if (!A_process_host) fail("Required attribute `host' not set for `process' element.");
-  if (!A_process_function) fail("Required attribute `function' not set for `process' element.");
-  LEAVE; STag_process(); pcdata = NULL; ETag_process();
+  if (!AX_surfxml_process_host) FAIL("Required attribute `host' not set for `process' element.");
+  if (!AX_surfxml_process_function) FAIL("Required attribute `function' not set for `process' element.");
+  LEAVE; STag_surfxml_process(); surfxml_pcdata_ix = 0; ETag_surfxml_process(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_process: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_process: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- .       fail("Unexpected character `%c' in attribute list of process element.", yytext[0]);
- {Name} fail("Bad attribute `%s' in `process' element start tag.",yytext);
- <<EOF>> fail("EOF in attribute list of `process' element.");
+ .       FAIL("Unexpected character `%c' in attribute list of process element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `process' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `process' element.");
 }
 
-<S_process,E_process,S_process_2>{
+<S_surfxml_process,E_surfxml_process,S_surfxml_process_2>{
  "</process"{s}">" {
   LEAVE;
-  ETag_process();
+  ETag_surfxml_process();
+  popbuffer(); /* attribute */
   switch (YY_START) {
-   case S_platform_description_2: case S_platform_description_1: case S_platform_description: SET(S_platform_description_2); break;
-   case ROOT_process: SET(EPILOG); break;
+   case S_surfxml_platform_description_2: case S_surfxml_platform_description_1: case S_surfxml_platform_description: SET(S_surfxml_platform_description_2); break;
+   case ROOT_surfxml_process: SET(EPILOG); break;
+   case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
- "</"{Name}{s}">" fail("Unexpected end-tag `%s': `</process>' expected.",yytext);
- .       fail("Unexpected character `%c': `</process>' expected.",yytext[0]);
- <<EOF>> fail("Premature EOF: `</process>' expected.");
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</process>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</process>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</process>' expected.");
 }
 
-<ROOT_argument,S_process_1,S_process,S_process_2>"<argument"{s} {
-  A_argument_value = NULL;
-  ENTER(AL_argument);
+<ROOT_surfxml_argument,S_surfxml_process_1,S_surfxml_process,S_surfxml_process_2>"<argument"{s} {
+  AX_surfxml_argument_value = 0;
+  ENTER(AL_surfxml_argument); pushbuffer(0);
   }
 
-<AL_argument>{
- "value"{Eq}\' ENTER(VALUE1); BUFFERSET(A_argument_value);
- "value"{Eq}\" ENTER(VALUE2); BUFFERSET(A_argument_value);
+<AL_surfxml_argument>{
+ "value"{Eq}\' ENTER(VALUE1); BUFFERSET(AX_surfxml_argument_value);
+ "value"{Eq}\" ENTER(VALUE2); BUFFERSET(AX_surfxml_argument_value);
 
  ">" {
-  if (!A_argument_value) fail("Required attribute `value' not set for `argument' element.");
-  LEAVE; STag_argument();pcdata = NULL; ENTER(E_argument);
+  if (!AX_surfxml_argument_value) FAIL("Required attribute `value' not set for `argument' element.");
+  LEAVE; STag_surfxml_argument();surfxml_pcdata_ix = 0; ENTER(E_surfxml_argument);
  }
  "/>" {
-  if (!A_argument_value) fail("Required attribute `value' not set for `argument' element.");
-  LEAVE; STag_argument(); pcdata = NULL; ETag_argument();
+  if (!AX_surfxml_argument_value) FAIL("Required attribute `value' not set for `argument' element.");
+  LEAVE; STag_surfxml_argument(); surfxml_pcdata_ix = 0; ETag_surfxml_argument(); popbuffer(); /* attribute */
   switch (YY_START) {
-   case ROOT_argument: SET(EPILOG); break;
-   case S_process_1: case S_process: case S_process_2: SET(S_process_2); break;
+   case S_surfxml_process_1: case S_surfxml_process: case S_surfxml_process_2: SET(S_surfxml_process_2); break;
+   case ROOT_surfxml_argument: SET(EPILOG); break;
   }
  }
- .       fail("Unexpected character `%c' in attribute list of argument element.", yytext[0]);
- {Name} fail("Bad attribute `%s' in `argument' element start tag.",yytext);
- <<EOF>> fail("EOF in attribute list of `argument' element.");
+ .       FAIL("Unexpected character `%c' in attribute list of argument element.", yytext[0]);
+ {Name} FAIL("Bad attribute `%s' in `argument' element start tag.",yytext);
+ <<EOF>> FAIL("EOF in attribute list of `argument' element.");
 }
 
-<E_argument>{
+<E_surfxml_argument>{
  "</argument"{s}">" {
   LEAVE;
-  ETag_argument();
+  ETag_surfxml_argument();
+  popbuffer(); /* attribute */
   switch (YY_START) {
-   case ROOT_argument: SET(EPILOG); break;
-   case S_process_1: case S_process: case S_process_2: SET(S_process_2); break;
+   case S_surfxml_process_1: case S_surfxml_process: case S_surfxml_process_2: SET(S_surfxml_process_2); break;
+   case ROOT_surfxml_argument: SET(EPILOG); break;
   }
  }
- "</"{Name}{s}">" fail("Unexpected end-tag `%s': `</argument>' expected.",yytext);
- .       fail("Unexpected character `%c': `</argument>' expected.",yytext[0]);
- <<EOF>> fail("Premature EOF: `</argument>' expected.");
+ "</"{Name}{s}">" FAIL("Unexpected end-tag `%s': `</argument>' expected.",yytext);
+ .       FAIL("Unexpected character `%c': `</argument>' expected.",yytext[0]);
+ <<EOF>> FAIL("Premature EOF: `</argument>' expected.");
 }
 
  /* EPILOG: after the root element. */
 
 <EPILOG>{
- .             fail("Unexpected character `%c' after document.", yytext[0]);
+ . {SET(PROLOG); yyless(0); CLEANUP; return -1;}
  <<EOF>>       SUCCEED;
 }
 
@@ -657,41 +973,42 @@ const char* *statenames=NULL;
 
 <IMPOSSIBLE>{
  "<![CDATA["   ENTER(CDATA);
- "]""]>"               fail("Unexpected `]""]>' in character data.");
+ "]""]>"               FAIL("Unexpected `]""]>' in character data.");
 }
 
 <VALUE1>{
  \'            BUFFERDONE; LEAVE;
- <<EOF>>       fail("EOF in literal (\"'\" expected).");
+ <<EOF>>       FAIL("EOF in literal (\"'\" expected).");
 }
 
 <VALUE2>{
  \"            BUFFERDONE; LEAVE;
- <<EOF>>       fail("EOF in literal (`\"' expected).");
+ <<EOF>>       FAIL("EOF in literal (`\"' expected).");
 }
 
 <IMPOSSIBLE,VALUE1,VALUE2>{
  [^<&]         BUFFERPUTC(yytext[0]);
- [<&]          fail("Spurious `%c' in character data.",yytext[0]);
+ [<&]          FAIL("Spurious `%c' in character data.",yytext[0]);
 }
 
 <CDATA>{
  "]""]>"               LEAVE;
- "]""]"                BUFFERPUTC(yytext[0]); BUFFERPUTC(yytext[1]);
+ /* "]""]"             BUFFERPUTC(yytext[0]); BUFFERPUTC(yytext[1]); */
  .             BUFFERPUTC(yytext[0]);
- <<EOF>>       fail("EOF in CDATA section.");
+ <<EOF>>       FAIL("EOF in CDATA section.");
 }
 
  /* Impossible rules to avoid warnings from flex(1). */
-
-<INITIAL,IMPOSSIBLE>{
- .|[\n] fail("The Impossible Happened: INITIAL or IMPOSSIBLE state entered?");
+ /* Ideally, this should be replaced by code in flexml.pl that
+    generates just the states not covered by other rules. */
+<*>{
+ .|[\n] FAIL("Syntax error on character `%c'.", yytext[0]);
 }
 
 %%
 
 /* Element context stack lookup. */
-int element_context(int i)
+int surfxml_element_context(int i)
 {
   return (0<i && i<yy_start_stack_depth
          ? yy_start_stack[yy_start_stack_ptr - i]
@@ -703,19 +1020,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/", statenames[yy_start_stack[i] ]);
-  fprintf(stderr,"%s\n", statenames[YY_START]);
+  if (surfxml_statenames) {
+      for (i=1; i<yy_start_stack_ptr; i++) {
+          fprintf(stderr, "%s/", surfxml_statenames[yy_start_stack[i] ]);
+      }
+      fprintf(stderr,"%s\n", surfxml_statenames[YY_START]);
+  }
   va_end(ap);
 }
 
+void print_surfxml_bufferstack()
+{
+    int i;
+    fputs("Buffer: ", stderr);
+    for (i = 0; i < blimit; i++) {
+       if ( surfxml_bufferstack[i] == '\377' ) break;
+         putc(surfxml_bufferstack[i], stderr);
+    }
+    putc('\n', stderr);
+}
+
 static void debug_enter(int state, const char* statename) {
   yy_push_state(state);
-  if (yy_flex_debug) print_yy_stack("--ENTER(%s) : ",statename);
+  if (yy_flex_debug) {
+       print_yy_stack("--ENTER(%s) : ",statename);
+       print_surfxml_bufferstack();
+  }
 }
 
 static void debug_leave(void) {
-  if (yy_flex_debug) print_yy_stack("--LEAVE : ");
+    if (yy_flex_debug) {
+        print_yy_stack("--LEAVE : ");
+       print_surfxml_bufferstack();
+    }
   yy_pop_state();
 }
 
@@ -726,16 +1063,44 @@ static void debug_set(int state, const char* statename) {
 #endif
 
 
+static void cleanup(void)
+{
+    if (surfxml_statenames) {
+        free(surfxml_statenames);
+       surfxml_statenames = NULL;
+    }
+    free(surfxml_bufferstack);
+    surfxml_bufferstack = NULL;
+
+    free(indexstack);
+    indexstack = NULL;
+}
+
+
 static int fail(const char* fmt, ...)
 {
-  va_list ap; va_start(ap, fmt);
+    int chars_left, used;
+    va_list ap; va_start(ap, fmt);
 #ifdef FLEXML_yylineno
-  fprintf(stderr, "Invalid XML (XML input line %d, state %d): ", yylineno, YY_START);
+    used = sprintf(flexml_err_msg,
+                  "Invalid XML (XML input line %d, state %d): ",
+                  yylineno, YY_START);
 #else
-  fprintf(stderr, "Invalid XML (state %d): ",YY_START);
+    used = sprintf(flexml_err_msg,
+                  "Invalid XML (state %d): ",
+                  YY_START);
 #endif
-  vfprintf(stderr, fmt, ap);
-  fprintf(stderr, "\n");
-  va_end(ap);
-  return 1;
+    chars_left = flexml_max_err_msg_size - used - 1;
+    vsnprintf(flexml_err_msg + used, chars_left, fmt, ap);
+    va_end(ap);
+
+#ifndef FLEXML_quiet_parser
+    /* print directly to sdterr */
+    fprintf(stderr, "%s\n", flexml_err_msg);
+    flexml_err_msg[0] = '\0';
+#endif
+
+    cleanup();
+
+    return 1;
 }