Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Keep tabs in generated files.
authorArnaud Giersch <arnaud.giersch@iut-bm.univ-fcomte.fr>
Wed, 20 Jun 2012 10:05:04 +0000 (12:05 +0200)
committerArnaud Giersch <arnaud.giersch@iut-bm.univ-fcomte.fr>
Wed, 20 Jun 2012 12:09:15 +0000 (14:09 +0200)
src/simdag/dax_dtd.c
src/surf/simgrid_dtd.c
src/xbt/automaton/automaton_parse.yy.c
src/xbt/automaton/y.tab.c
src/xbt/datadesc/ddt_parse.yy.c
src/xbt/graphxml.c

index 709780b..f0eae81 100644 (file)
@@ -111,15 +111,15 @@ typedef unsigned int flex_uint32_t;
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
-#else  /* ! __cplusplus */
+#else  /* ! __cplusplus */
 
 /* C99 requires __STDC__ to be defined as 1. */
 #if defined (__STDC__)
 
 #define YY_USE_CONST
 
-#endif  /* defined (__STDC__) */
-#endif  /* ! __cplusplus */
+#endif /* defined (__STDC__) */
+#endif /* ! __cplusplus */
 
 #ifdef YY_USE_CONST
 #define yyconst const
@@ -205,17 +205,17 @@ extern FILE *dax_in, *dax_out;
     
 /* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
-  do \
-    { \
-    /* Undo effects of setting up dax_text. */ \
+       do \
+               { \
+               /* Undo effects of setting up dax_text. */ \
         int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
-    *yy_cp = (yy_hold_char); \
-    YY_RESTORE_YY_MORE_OFFSET \
-    (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-    YY_DO_BEFORE_ACTION; /* set up dax_text again */ \
-    } \
-  while ( 0 )
+               *yy_cp = (yy_hold_char); \
+               YY_RESTORE_YY_MORE_OFFSET \
+               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+               YY_DO_BEFORE_ACTION; /* set up dax_text again */ \
+               } \
+       while ( 0 )
 
 #define unput(c) yyunput( c, (yytext_ptr)  )
 
@@ -227,66 +227,66 @@ typedef size_t yy_size_t;
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
-  {
-  FILE *yy_input_file;
-
-  char *yy_ch_buf;    /* input buffer */
-  char *yy_buf_pos;    /* current position in input buffer */
-
-  /* Size of input buffer in bytes, not including room for EOB
-   * characters.
-   */
-  yy_size_t yy_buf_size;
-
-  /* Number of characters read into yy_ch_buf, not including EOB
-   * characters.
-   */
-  int yy_n_chars;
-
-  /* Whether we "own" the buffer - i.e., we know we created it,
-   * and can realloc() it to grow it, and should free() it to
-   * delete it.
-   */
-  int yy_is_our_buffer;
-
-  /* Whether this is an "interactive" input source; if so, and
-   * if we're using stdio for input, then we want to use getc()
-   * instead of fread(), to make sure we stop fetching input after
-   * each newline.
-   */
-  int yy_is_interactive;
-
-  /* Whether we're considered to be at the beginning of a line.
-   * If so, '^' rules will be active on the next match, otherwise
-   * not.
-   */
-  int yy_at_bol;
+       {
+       FILE *yy_input_file;
+
+       char *yy_ch_buf;                /* input buffer */
+       char *yy_buf_pos;               /* current position in input buffer */
+
+       /* Size of input buffer in bytes, not including room for EOB
+        * characters.
+        */
+       yy_size_t yy_buf_size;
+
+       /* Number of characters read into yy_ch_buf, not including EOB
+        * characters.
+        */
+       int yy_n_chars;
+
+       /* Whether we "own" the buffer - i.e., we know we created it,
+        * and can realloc() it to grow it, and should free() it to
+        * delete it.
+        */
+       int yy_is_our_buffer;
+
+       /* Whether this is an "interactive" input source; if so, and
+        * if we're using stdio for input, then we want to use getc()
+        * instead of fread(), to make sure we stop fetching input after
+        * each newline.
+        */
+       int yy_is_interactive;
+
+       /* Whether we're considered to be at the beginning of a line.
+        * If so, '^' rules will be active on the next match, otherwise
+        * not.
+        */
+       int yy_at_bol;
 
     int yy_bs_lineno; /**< The line count. */
     int yy_bs_column; /**< The column count. */
     
-  /* Whether to try to fill the input buffer when we reach the
-   * end of it.
-   */
-  int yy_fill_buffer;
+       /* Whether to try to fill the input buffer when we reach the
+        * end of it.
+        */
+       int yy_fill_buffer;
 
-  int yy_buffer_status;
+       int yy_buffer_status;
 
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
-  /* When an EOF's been seen but there's still some text to process
-   * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-   * shouldn't try reading from the input source any more.  We might
-   * still have a bunch of tokens to match, though, because of
-   * possible backing-up.
-   *
-   * When we actually see the EOF, we change the status to "new"
-   * (via dax_restart()), so that the user can continue scanning by
-   * just pointing dax_in at a new input file.
-   */
+       /* When an EOF's been seen but there's still some text to process
+        * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+        * shouldn't try reading from the input source any more.  We might
+        * still have a bunch of tokens to match, though, because of
+        * possible backing-up.
+        *
+        * When we actually see the EOF, we change the status to "new"
+        * (via dax_restart()), so that the user can continue scanning by
+        * just pointing dax_in at a new input file.
+        */
 #define YY_BUFFER_EOF_PENDING 2
 
-  };
+       };
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
 /* Stack of input buffers. */
@@ -311,13 +311,13 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* yy_hold_char holds the character lost when dax_text is formed. */
 static char yy_hold_char;
-static int yy_n_chars;    /* number of characters read into yy_ch_buf */
+static int yy_n_chars;         /* number of characters read into yy_ch_buf */
 int dax_leng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 0;    /* whether we need to initialize */
-static int yy_start = 0;  /* start state number */
+static int yy_init = 0;                /* whether we need to initialize */
+static int yy_start = 0;       /* start state number */
 
 /* Flag which is used to allow dax_wrap()'s to do buffer switches
  * instead of setting up a fresh dax_in.  A bit of a hack ...
@@ -349,24 +349,24 @@ void dax_free (void *  );
 #define yy_new_buffer dax__create_buffer
 
 #define yy_set_interactive(is_interactive) \
-  { \
-  if ( ! YY_CURRENT_BUFFER ){ \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){ \
         dax_ensure_buffer_stack (); \
-    YY_CURRENT_BUFFER_LVALUE =    \
+               YY_CURRENT_BUFFER_LVALUE =    \
             dax__create_buffer(dax_in,YY_BUF_SIZE ); \
-  } \
-  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-  }
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+       }
 
 #define yy_set_bol(at_bol) \
-  { \
-  if ( ! YY_CURRENT_BUFFER ){\
+       { \
+       if ( ! YY_CURRENT_BUFFER ){\
         dax_ensure_buffer_stack (); \
-    YY_CURRENT_BUFFER_LVALUE =    \
+               YY_CURRENT_BUFFER_LVALUE =    \
             dax__create_buffer(dax_in,YY_BUF_SIZE ); \
-  } \
-  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-  }
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+       }
 
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
@@ -397,21 +397,21 @@ static void yy_fatal_error (yyconst char msg[]  );
  * corresponding action - sets up dax_text.
  */
 #define YY_DO_BEFORE_ACTION \
-  (yytext_ptr) = yy_bp; \
-  dax_leng = (size_t) (yy_cp - yy_bp); \
-  (yy_hold_char) = *yy_cp; \
-  *yy_cp = '\0'; \
-  (yy_c_buf_p) = yy_cp;
+       (yytext_ptr) = yy_bp; \
+       dax_leng = (size_t) (yy_cp - yy_bp); \
+       (yy_hold_char) = *yy_cp; \
+       *yy_cp = '\0'; \
+       (yy_c_buf_p) = yy_cp;
 
 #define YY_NUM_RULES 140
 #define YY_END_OF_BUFFER 141
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
-  {
-  flex_int32_t yy_verify;
-  flex_int32_t yy_nxt;
-  };
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
 static yyconst flex_int16_t yy_accept[775] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
@@ -1418,23 +1418,23 @@ short int dax__adag_fileCount_isset;
 
 /* XML state. */
 #ifdef FLEX_DEBUG
-# define ENTER(state)  debug_enter(state,#state)
-# define LEAVE    debug_leave()
-# define SET(state)  debug_set(state,#state)
+# define ENTER(state)  debug_enter(state,#state)
+# define LEAVE         debug_leave()
+# define SET(state)    debug_set(state,#state)
   static void debug_enter(int, const char*);
   static void debug_leave(void);
   static void debug_set(int, const char*);
 #else
-# define ENTER(state)  (yy_push_state(state))
-# define LEAVE    (yy_pop_state())
-# define SET(state)  BEGIN(state)
+# define ENTER(state)  (yy_push_state(state))
+# define LEAVE         (yy_pop_state())
+# define SET(state)    BEGIN(state)
 #endif
 
 /* Generic actions. */
-#define SKIP  /*skip*/
+#define SKIP   /*skip*/
 #define SUCCEED        CLEANUP; return 0
 
-#define FAIL  return fail
+#define FAIL   return fail
 static int fail(const char*, ...);
 
 enum {flexml_max_err_msg_size = 512};
@@ -1471,12 +1471,12 @@ static int inext = 1;
 static int ck_blimit()
 {
      if (bnext >= blimit) {
-   blimit += FLEXML_BUFFERSTACKSIZE + 2;
-   {
-       char *temp = (char *) realloc(dax__bufferstack, blimit);
-       assert(temp);
-       dax__bufferstack = temp;
-   }
+        blimit += FLEXML_BUFFERSTACKSIZE + 2;
+        {
+            char *temp = (char *) realloc(dax__bufferstack, blimit);
+            assert(temp);
+            dax__bufferstack = temp;
+        }
      }
      return 0;
 }
@@ -1485,12 +1485,12 @@ static int ck_blimit()
 static int ck_ilimit()
 {
      if (inext >= ilimit) {
-   ilimit += FLEXML_INDEXSTACKSIZE + 2;
-   {
-       int *temp = (int *) realloc(indexstack, ilimit);
-       assert(temp);
-       indexstack = temp;
-   }
+        ilimit += FLEXML_INDEXSTACKSIZE + 2;
+        {
+            int *temp = (int *) realloc(indexstack, ilimit);
+            assert(temp);
+            indexstack = temp;
+        }
      }
      return 0;
 }
@@ -1536,18 +1536,18 @@ static int popbuffer(void)
 /* Miscellaneous. */
 /* Parser states (flex `exclusive start conditions'):
  *
- * PROLOG  the XML prolog of the document before <?xml...>
- * DOCTYPE  the XML prolog of the document after <?xml...>
- * EPILOG  after the root element
- * INCOMMENT  inside an XML comment <!--....-->
- * INPI    inside an XML PI <?...?>
- * VALUE1  inside a '...'-delimited literal
- * VALUE2  inside a "..."-delimited literal
- * 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
+ * PROLOG      the XML prolog of the document before <?xml...>
+ * DOCTYPE     the XML prolog of the document after <?xml...>
+ * EPILOG      after the root element
+ * INCOMMENT   inside an XML comment <!--....-->
+ * INPI                inside an XML PI <?...?>
+ * VALUE1      inside a '...'-delimited literal
+ * VALUE2      inside a "..."-delimited literal
+ * 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
  */
 
 /* State names. */
@@ -1698,33 +1698,33 @@ static int input (void );
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-    { \
-    int c = '*'; \
-    size_t n; \
-    for ( n = 0; n < max_size && \
-           (c = getc( dax_in )) != EOF && c != '\n'; ++n ) \
-      buf[n] = (char) c; \
-    if ( c == '\n' ) \
-      buf[n++] = (char) c; \
-    if ( c == EOF && ferror( dax_in ) ) \
-      YY_FATAL_ERROR( "input in flex scanner failed" ); \
-    result = n; \
-    } \
-  else \
-    { \
-    errno=0; \
-    while ( (result = fread(buf, 1, max_size, dax_in))==0 && ferror(dax_in)) \
-      { \
-      if( errno != EINTR) \
-        { \
-        YY_FATAL_ERROR( "input in flex scanner failed" ); \
-        break; \
-        } \
-      errno=0; \
-      clearerr(dax_in); \
-      } \
-    }\
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+               { \
+               int c = '*'; \
+               size_t n; \
+               for ( n = 0; n < max_size && \
+                            (c = getc( dax_in )) != EOF && c != '\n'; ++n ) \
+                       buf[n] = (char) c; \
+               if ( c == '\n' ) \
+                       buf[n++] = (char) c; \
+               if ( c == EOF && ferror( dax_in ) ) \
+                       YY_FATAL_ERROR( "input in flex scanner failed" ); \
+               result = n; \
+               } \
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, max_size, dax_in))==0 && ferror(dax_in)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(dax_in); \
+                       } \
+               }\
 \
 
 #endif
@@ -1773,15 +1773,15 @@ extern int dax_lex (void);
 #endif
 
 #define YY_RULE_SETUP \
-  YY_USER_ACTION
+       YY_USER_ACTION
 
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {
-  register yy_state_type yy_current_state;
-  register char *yy_cp, *yy_bp;
-  register int yy_act;
+       register yy_state_type yy_current_state;
+       register char *yy_cp, *yy_bp;
+       register int yy_act;
     
  /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
  SET(PROLOG);
@@ -1845,172 +1845,172 @@ YY_DECL
 
  /* COMMENTS and PIs: handled uniformly for efficiency. */
 
-  if ( !(yy_init) )
-    {
-    (yy_init) = 1;
+       if ( !(yy_init) )
+               {
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
-    YY_USER_INIT;
+               YY_USER_INIT;
 #endif
 
-    if ( ! (yy_start) )
-      (yy_start) = 1;  /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
 
-    if ( ! dax_in )
-      dax_in = stdin;
+               if ( ! dax_in )
+                       dax_in = stdin;
 
-    if ( ! dax_out )
-      dax_out = stdout;
+               if ( ! dax_out )
+                       dax_out = stdout;
 
-    if ( ! YY_CURRENT_BUFFER ) {
-      dax_ensure_buffer_stack ();
-      YY_CURRENT_BUFFER_LVALUE =
-        dax__create_buffer(dax_in,YY_BUF_SIZE );
-    }
+               if ( ! YY_CURRENT_BUFFER ) {
+                       dax_ensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               dax__create_buffer(dax_in,YY_BUF_SIZE );
+               }
 
-    dax__load_buffer_state( );
-    }
+               dax__load_buffer_state( );
+               }
 
-  while ( 1 )    /* loops until end-of-file is reached */
-    {
-    yy_cp = (yy_c_buf_p);
+       while ( 1 )             /* loops until end-of-file is reached */
+               {
+               yy_cp = (yy_c_buf_p);
 
-    /* Support of dax_text. */
-    *yy_cp = (yy_hold_char);
+               /* Support of dax_text. */
+               *yy_cp = (yy_hold_char);
 
-    /* yy_bp points to the position in yy_ch_buf of the start of
-     * the current run.
-     */
-    yy_bp = yy_cp;
+               /* yy_bp points to the position in yy_ch_buf of the start of
+                * the current run.
+                */
+               yy_bp = yy_cp;
 
-    yy_current_state = (yy_start);
+               yy_current_state = (yy_start);
 yy_match:
-    do
-      {
-      register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-      if ( yy_accept[yy_current_state] )
-        {
-        (yy_last_accepting_state) = yy_current_state;
-        (yy_last_accepting_cpos) = yy_cp;
-        }
-      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-        {
-        yy_current_state = (int) yy_def[yy_current_state];
-        if ( yy_current_state >= 775 )
-          yy_c = yy_meta[(unsigned int) yy_c];
-        }
-      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-      ++yy_cp;
-      }
-    while ( yy_base[yy_current_state] != 2164 );
+               do
+                       {
+                       register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+                       if ( yy_accept[yy_current_state] )
+                               {
+                               (yy_last_accepting_state) = yy_current_state;
+                               (yy_last_accepting_cpos) = yy_cp;
+                               }
+                       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                               {
+                               yy_current_state = (int) yy_def[yy_current_state];
+                               if ( yy_current_state >= 775 )
+                                       yy_c = yy_meta[(unsigned int) yy_c];
+                               }
+                       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                       ++yy_cp;
+                       }
+               while ( yy_base[yy_current_state] != 2164 );
 
 yy_find_action:
-    yy_act = yy_accept[yy_current_state];
-    if ( yy_act == 0 )
-      { /* have to back up */
-      yy_cp = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      yy_act = yy_accept[yy_current_state];
-      }
-
-    YY_DO_BEFORE_ACTION;
-
-    if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
-      {
-      int yyl;
-      for ( yyl = 0; yyl < dax_leng; ++yyl )
-        if ( dax_text[yyl] == '\n' )
-             
+               yy_act = yy_accept[yy_current_state];
+               if ( yy_act == 0 )
+                       { /* have to back up */
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
+                       yy_act = yy_accept[yy_current_state];
+                       }
+
+               YY_DO_BEFORE_ACTION;
+
+               if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
+                       {
+                       int yyl;
+                       for ( yyl = 0; yyl < dax_leng; ++yyl )
+                               if ( dax_text[yyl] == '\n' )
+                                          
     dax_lineno++;
 ;
-      }
+                       }
 
-do_action:  /* This label is used only to access EOF actions. */
+do_action:     /* This label is used only to access EOF actions. */
 
-    switch ( yy_act )
-  { /* beginning of action switch */
-      case 0: /* must back up */
-      /* undo the effects of YY_DO_BEFORE_ACTION */
-      *yy_cp = (yy_hold_char);
-      yy_cp = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      goto yy_find_action;
+               switch ( yy_act )
+       { /* beginning of action switch */
+                       case 0: /* must back up */
+                       /* undo the effects of YY_DO_BEFORE_ACTION */
+                       *yy_cp = (yy_hold_char);
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
+                       goto yy_find_action;
 
 case 1:
 YY_RULE_SETUP
 ENTER(INCOMMENT);
-  YY_BREAK
+       YY_BREAK
 case 2:
 YY_RULE_SETUP
 ENTER(INPI);
-  YY_BREAK
+       YY_BREAK
 
 case 3:
 YY_RULE_SETUP
 LEAVE;
-  YY_BREAK
+       YY_BREAK
 case 4:
 case 5:
 case 6:
 /* rule 6 can match eol */
 YY_RULE_SETUP
 SKIP;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(INCOMMENT):
 FAIL("EOF in comment.");
-  YY_BREAK
+       YY_BREAK
 
 case 7:
 YY_RULE_SETUP
 LEAVE;
-  YY_BREAK
+       YY_BREAK
 case 8:
 case 9:
 /* rule 9 can match eol */
 YY_RULE_SETUP
 SKIP;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(INPI):
 FAIL("EOF in PI (processing instruction).");
-  YY_BREAK
+       YY_BREAK
 
 /* SPACES: skipped uniformly */
 case 10:
 /* rule 10 can match eol */
 YY_RULE_SETUP
 SKIP;
-  YY_BREAK
+       YY_BREAK
 /* PROLOG: determine root element and process it. */
 
 case 11:
 /* rule 11 can match eol */
 YY_RULE_SETUP
 SET(ROOT_dax__adag); 
-  YY_BREAK
+       YY_BREAK
 case 12:
 /* rule 12 can match eol */
 YY_RULE_SETUP
 FAIL("Bad declaration %s.",dax_text);
-  YY_BREAK
+       YY_BREAK
 
 case 13:
 /* rule 13 can match eol */
 YY_RULE_SETUP
 SET(ROOT_dax__adag);
-  YY_BREAK
+       YY_BREAK
 case 14:
 /* rule 14 can match eol */
 YY_RULE_SETUP
 FAIL("Bad declaration %s.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case 15:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in prolog.", dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(PROLOG):
 case YY_STATE_EOF(DOCTYPE):
 FAIL("EOF in prolog.");
-  YY_BREAK
+       YY_BREAK
 
 /* RULES DERIVED FROM DTD. */
 /* <!-- Small DTD for DAX files. -->  */
@@ -2018,7 +2018,7 @@ case 16:
 /* rule 16 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <adag> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 17:
 /* rule 17 can match eol */
 YY_RULE_SETUP
@@ -2045,114 +2045,114 @@ YY_RULE_SETUP
   dax__adag_childCount_isset = 0;
   ENTER(AL_dax__adag); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 18:
 /* rule 18 can match eol */
 YY_RULE_SETUP
 if (dax__adag_xmlns_isset != 0) {FAIL("Multiple definition of attribute xmlns in <dax__adag>");} dax__adag_xmlns_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns);
-  YY_BREAK
+       YY_BREAK
 case 19:
 /* rule 19 can match eol */
 YY_RULE_SETUP
 if (dax__adag_xmlns_isset != 0) {FAIL("Multiple definition of attribute xmlns in <dax__adag>");}  dax__adag_xmlns_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns);
-  YY_BREAK
+       YY_BREAK
 case 20:
 /* rule 20 can match eol */
 YY_RULE_SETUP
 if (dax__adag_xmlns_c_xsi_isset != 0) {FAIL("Multiple definition of attribute xmlns:xsi in <dax__adag>");} dax__adag_xmlns_c_xsi_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xmlns_c_xsi);
-  YY_BREAK
+       YY_BREAK
 case 21:
 /* rule 21 can match eol */
 YY_RULE_SETUP
 if (dax__adag_xmlns_c_xsi_isset != 0) {FAIL("Multiple definition of attribute xmlns:xsi in <dax__adag>");}  dax__adag_xmlns_c_xsi_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xmlns_c_xsi);
-  YY_BREAK
+       YY_BREAK
 case 22:
 /* rule 22 can match eol */
 YY_RULE_SETUP
 if (dax__adag_xsi_c_schemaLocation_isset != 0) {FAIL("Multiple definition of attribute xsi:schemaLocation in <dax__adag>");} dax__adag_xsi_c_schemaLocation_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation);
-  YY_BREAK
+       YY_BREAK
 case 23:
 /* rule 23 can match eol */
 YY_RULE_SETUP
 if (dax__adag_xsi_c_schemaLocation_isset != 0) {FAIL("Multiple definition of attribute xsi:schemaLocation in <dax__adag>");}  dax__adag_xsi_c_schemaLocation_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_xsi_c_schemaLocation);
-  YY_BREAK
+       YY_BREAK
 case 24:
 /* rule 24 can match eol */
 YY_RULE_SETUP
 if (dax__adag_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__adag>");} dax__adag_version_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_version);
-  YY_BREAK
+       YY_BREAK
 case 25:
 /* rule 25 can match eol */
 YY_RULE_SETUP
 if (dax__adag_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__adag>");}  dax__adag_version_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_version);
-  YY_BREAK
+       YY_BREAK
 case 26:
 /* rule 26 can match eol */
 YY_RULE_SETUP
 if (dax__adag_count_isset != 0) {FAIL("Multiple definition of attribute count in <dax__adag>");} dax__adag_count_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_count);
-  YY_BREAK
+       YY_BREAK
 case 27:
 /* rule 27 can match eol */
 YY_RULE_SETUP
 if (dax__adag_count_isset != 0) {FAIL("Multiple definition of attribute count in <dax__adag>");}  dax__adag_count_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_count);
-  YY_BREAK
+       YY_BREAK
 case 28:
 /* rule 28 can match eol */
 YY_RULE_SETUP
 if (dax__adag_index_isset != 0) {FAIL("Multiple definition of attribute index in <dax__adag>");} dax__adag_index_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_index);
-  YY_BREAK
+       YY_BREAK
 case 29:
 /* rule 29 can match eol */
 YY_RULE_SETUP
 if (dax__adag_index_isset != 0) {FAIL("Multiple definition of attribute index in <dax__adag>");}  dax__adag_index_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_index);
-  YY_BREAK
+       YY_BREAK
 case 30:
 /* rule 30 can match eol */
 YY_RULE_SETUP
 if (dax__adag_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__adag>");} dax__adag_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_name);
-  YY_BREAK
+       YY_BREAK
 case 31:
 /* rule 31 can match eol */
 YY_RULE_SETUP
 if (dax__adag_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__adag>");}  dax__adag_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_name);
-  YY_BREAK
+       YY_BREAK
 case 32:
 /* rule 32 can match eol */
 YY_RULE_SETUP
 if (dax__adag_jobCount_isset != 0) {FAIL("Multiple definition of attribute jobCount in <dax__adag>");} dax__adag_jobCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_jobCount);
-  YY_BREAK
+       YY_BREAK
 case 33:
 /* rule 33 can match eol */
 YY_RULE_SETUP
 if (dax__adag_jobCount_isset != 0) {FAIL("Multiple definition of attribute jobCount in <dax__adag>");}  dax__adag_jobCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_jobCount);
-  YY_BREAK
+       YY_BREAK
 case 34:
 /* rule 34 can match eol */
 YY_RULE_SETUP
 if (dax__adag_fileCount_isset != 0) {FAIL("Multiple definition of attribute fileCount in <dax__adag>");} dax__adag_fileCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_fileCount);
-  YY_BREAK
+       YY_BREAK
 case 35:
 /* rule 35 can match eol */
 YY_RULE_SETUP
 if (dax__adag_fileCount_isset != 0) {FAIL("Multiple definition of attribute fileCount in <dax__adag>");}  dax__adag_fileCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_fileCount);
-  YY_BREAK
+       YY_BREAK
 case 36:
 /* rule 36 can match eol */
 YY_RULE_SETUP
 if (dax__adag_childCount_isset != 0) {FAIL("Multiple definition of attribute childCount in <dax__adag>");} dax__adag_childCount_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__adag_childCount);
-  YY_BREAK
+       YY_BREAK
 case 37:
 /* rule 37 can match eol */
 YY_RULE_SETUP
 if (dax__adag_childCount_isset != 0) {FAIL("Multiple definition of attribute childCount in <dax__adag>");}  dax__adag_childCount_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__adag_childCount);
-  YY_BREAK
+       YY_BREAK
 case 38:
 YY_RULE_SETUP
 {
   LEAVE; STag_dax__adag();dax__pcdata_ix = 0; ENTER(S_dax__adag);
  }
-  YY_BREAK
+       YY_BREAK
 case 39:
 YY_RULE_SETUP
 {
@@ -2161,18 +2161,18 @@ YY_RULE_SETUP
    case ROOT_dax__adag: SET(EPILOG); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 40:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of adag element.", dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 41:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `adag' element start tag.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_dax__adag):
 FAIL("EOF in attribute list of `adag' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 42:
 /* rule 42 can match eol */
@@ -2185,29 +2185,29 @@ YY_RULE_SETUP
    case ROOT_dax__adag: SET(EPILOG); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 43:
 /* rule 43 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</adag>' expected.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case 44:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</adag>' expected.",dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_dax__adag_1):
 case YY_STATE_EOF(S_dax__adag_5):
 case YY_STATE_EOF(E_dax__adag):
 case YY_STATE_EOF(S_dax__adag_3):
 case YY_STATE_EOF(S_dax__adag):
 FAIL("Premature EOF: `</adag>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 45:
 /* rule 45 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <job> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 46:
 /* rule 46 can match eol */
 YY_RULE_SETUP
@@ -2226,68 +2226,68 @@ YY_RULE_SETUP
   dax__job_level_isset = 0;
   ENTER(AL_dax__job); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 47:
 /* rule 47 can match eol */
 YY_RULE_SETUP
 if (dax__job_id_isset != 0) {FAIL("Multiple definition of attribute id in <dax__job>");} dax__job_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_id);
-  YY_BREAK
+       YY_BREAK
 case 48:
 /* rule 48 can match eol */
 YY_RULE_SETUP
 if (dax__job_id_isset != 0) {FAIL("Multiple definition of attribute id in <dax__job>");}  dax__job_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_id);
-  YY_BREAK
+       YY_BREAK
 case 49:
 /* rule 49 can match eol */
 YY_RULE_SETUP
 if (dax__job_namespace_isset != 0) {FAIL("Multiple definition of attribute namespace in <dax__job>");} dax__job_namespace_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_namespace);
-  YY_BREAK
+       YY_BREAK
 case 50:
 /* rule 50 can match eol */
 YY_RULE_SETUP
 if (dax__job_namespace_isset != 0) {FAIL("Multiple definition of attribute namespace in <dax__job>");}  dax__job_namespace_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_namespace);
-  YY_BREAK
+       YY_BREAK
 case 51:
 /* rule 51 can match eol */
 YY_RULE_SETUP
 if (dax__job_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__job>");} dax__job_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_name);
-  YY_BREAK
+       YY_BREAK
 case 52:
 /* rule 52 can match eol */
 YY_RULE_SETUP
 if (dax__job_name_isset != 0) {FAIL("Multiple definition of attribute name in <dax__job>");}  dax__job_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_name);
-  YY_BREAK
+       YY_BREAK
 case 53:
 /* rule 53 can match eol */
 YY_RULE_SETUP
 if (dax__job_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__job>");} dax__job_version_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_version);
-  YY_BREAK
+       YY_BREAK
 case 54:
 /* rule 54 can match eol */
 YY_RULE_SETUP
 if (dax__job_version_isset != 0) {FAIL("Multiple definition of attribute version in <dax__job>");}  dax__job_version_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_version);
-  YY_BREAK
+       YY_BREAK
 case 55:
 /* rule 55 can match eol */
 YY_RULE_SETUP
 if (dax__job_runtime_isset != 0) {FAIL("Multiple definition of attribute runtime in <dax__job>");} dax__job_runtime_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_runtime);
-  YY_BREAK
+       YY_BREAK
 case 56:
 /* rule 56 can match eol */
 YY_RULE_SETUP
 if (dax__job_runtime_isset != 0) {FAIL("Multiple definition of attribute runtime in <dax__job>");}  dax__job_runtime_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_runtime);
-  YY_BREAK
+       YY_BREAK
 case 57:
 /* rule 57 can match eol */
 YY_RULE_SETUP
 if (dax__job_level_isset != 0) {FAIL("Multiple definition of attribute level in <dax__job>");} dax__job_level_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__job_level);
-  YY_BREAK
+       YY_BREAK
 case 58:
 /* rule 58 can match eol */
 YY_RULE_SETUP
 if (dax__job_level_isset != 0) {FAIL("Multiple definition of attribute level in <dax__job>");}  dax__job_level_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__job_level);
-  YY_BREAK
+       YY_BREAK
 case 59:
 YY_RULE_SETUP
 {
@@ -2296,7 +2296,7 @@ YY_RULE_SETUP
   if (!AX_dax__job_runtime) FAIL("Required attribute `runtime' not set for `job' element.");
   LEAVE; STag_dax__job();dax__pcdata_ix = 0; ENTER(S_dax__job);
  }
-  YY_BREAK
+       YY_BREAK
 case 60:
 YY_RULE_SETUP
 {
@@ -2308,18 +2308,18 @@ YY_RULE_SETUP
    case S_dax__adag_2: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 61:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of job element.", dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 62:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `job' element start tag.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_dax__job):
 FAIL("EOF in attribute list of `job' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 63:
 /* rule 63 can match eol */
@@ -2332,21 +2332,21 @@ YY_RULE_SETUP
    case S_dax__adag_2: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 64:
 /* rule 64 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</job>' expected.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case 65:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</job>' expected.",dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_dax__job):
 case YY_STATE_EOF(E_dax__job):
 case YY_STATE_EOF(S_dax__job_2):
 FAIL("Premature EOF: `</job>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 /* <!-- ignored -->
   * <!-- ignored -->  */
@@ -2354,7 +2354,7 @@ case 66:
 /* rule 66 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <uses> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 67:
 /* rule 67 can match eol */
 YY_RULE_SETUP
@@ -2375,94 +2375,94 @@ YY_RULE_SETUP
   dax__uses_size_isset = 0;
   ENTER(AL_dax__uses); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 68:
 /* rule 68 can match eol */
 YY_RULE_SETUP
 if (dax__uses_file_isset != 0) {FAIL("Multiple definition of attribute file in <dax__uses>");} dax__uses_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_file);
-  YY_BREAK
+       YY_BREAK
 case 69:
 /* rule 69 can match eol */
 YY_RULE_SETUP
 if (dax__uses_file_isset != 0) {FAIL("Multiple definition of attribute file in <dax__uses>");}  dax__uses_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_file);
-  YY_BREAK
+       YY_BREAK
 case 70:
 /* rule 70 can match eol */
 case 71:
 /* rule 71 can match eol */
 YY_RULE_SETUP
 A_dax__uses_link = A_dax__uses_link_input;
-  YY_BREAK
+       YY_BREAK
 case 72:
 /* rule 72 can match eol */
 case 73:
 /* rule 73 can match eol */
 YY_RULE_SETUP
 A_dax__uses_link = A_dax__uses_link_output;
-  YY_BREAK
+       YY_BREAK
 case 74:
 /* rule 74 can match eol */
 case 75:
 /* rule 75 can match eol */
 YY_RULE_SETUP
 A_dax__uses_register = A_dax__uses_register_false;
-  YY_BREAK
+       YY_BREAK
 case 76:
 /* rule 76 can match eol */
 case 77:
 /* rule 77 can match eol */
 YY_RULE_SETUP
 A_dax__uses_register = A_dax__uses_register_true;
-  YY_BREAK
+       YY_BREAK
 case 78:
 /* rule 78 can match eol */
 case 79:
 /* rule 79 can match eol */
 YY_RULE_SETUP
 A_dax__uses_transfer = A_dax__uses_transfer_false;
-  YY_BREAK
+       YY_BREAK
 case 80:
 /* rule 80 can match eol */
 case 81:
 /* rule 81 can match eol */
 YY_RULE_SETUP
 A_dax__uses_transfer = A_dax__uses_transfer_true;
-  YY_BREAK
+       YY_BREAK
 case 82:
 /* rule 82 can match eol */
 case 83:
 /* rule 83 can match eol */
 YY_RULE_SETUP
 A_dax__uses_optional = A_dax__uses_optional_false;
-  YY_BREAK
+       YY_BREAK
 case 84:
 /* rule 84 can match eol */
 case 85:
 /* rule 85 can match eol */
 YY_RULE_SETUP
 A_dax__uses_optional = A_dax__uses_optional_true;
-  YY_BREAK
+       YY_BREAK
 case 86:
 /* rule 86 can match eol */
 YY_RULE_SETUP
 if (dax__uses_type_isset != 0) {FAIL("Multiple definition of attribute type in <dax__uses>");} dax__uses_type_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_type);
-  YY_BREAK
+       YY_BREAK
 case 87:
 /* rule 87 can match eol */
 YY_RULE_SETUP
 if (dax__uses_type_isset != 0) {FAIL("Multiple definition of attribute type in <dax__uses>");}  dax__uses_type_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_type);
-  YY_BREAK
+       YY_BREAK
 case 88:
 /* rule 88 can match eol */
 YY_RULE_SETUP
 if (dax__uses_size_isset != 0) {FAIL("Multiple definition of attribute size in <dax__uses>");} dax__uses_size_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__uses_size);
-  YY_BREAK
+       YY_BREAK
 case 89:
 /* rule 89 can match eol */
 YY_RULE_SETUP
 if (dax__uses_size_isset != 0) {FAIL("Multiple definition of attribute size in <dax__uses>");}  dax__uses_size_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__uses_size);
-  YY_BREAK
+       YY_BREAK
 case 90:
 YY_RULE_SETUP
 {
@@ -2470,7 +2470,7 @@ YY_RULE_SETUP
   if (!AX_dax__uses_size) FAIL("Required attribute `size' not set for `uses' element.");
   LEAVE; STag_dax__uses();dax__pcdata_ix = 0; ENTER(E_dax__uses);
  }
-  YY_BREAK
+       YY_BREAK
 case 91:
 YY_RULE_SETUP
 {
@@ -2481,18 +2481,18 @@ YY_RULE_SETUP
    case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 92:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of uses element.", dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 93:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `uses' element start tag.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_dax__uses):
 FAIL("EOF in attribute list of `uses' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 94:
 /* rule 94 can match eol */
@@ -2505,25 +2505,25 @@ YY_RULE_SETUP
    case S_dax__job: case S_dax__job_2: case S_dax__job_1: SET(S_dax__job_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 95:
 /* rule 95 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</uses>' expected.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case 96:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</uses>' expected.",dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_dax__uses):
 FAIL("Premature EOF: `</uses>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 97:
 /* rule 97 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <child> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 98:
 /* rule 98 can match eol */
 YY_RULE_SETUP
@@ -2532,25 +2532,25 @@ YY_RULE_SETUP
   dax__child_ref_isset = 0;
   ENTER(AL_dax__child); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 99:
 /* rule 99 can match eol */
 YY_RULE_SETUP
 if (dax__child_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__child>");} dax__child_ref_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__child_ref);
-  YY_BREAK
+       YY_BREAK
 case 100:
 /* rule 100 can match eol */
 YY_RULE_SETUP
 if (dax__child_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__child>");}  dax__child_ref_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__child_ref);
-  YY_BREAK
+       YY_BREAK
 case 101:
 YY_RULE_SETUP
 {
   if (!AX_dax__child_ref) FAIL("Required attribute `ref' not set for `child' element.");
   LEAVE; STag_dax__child();dax__pcdata_ix = 0; ENTER(S_dax__child);
  }
-  YY_BREAK
+       YY_BREAK
 case 102:
 YY_RULE_SETUP
 {
@@ -2560,18 +2560,18 @@ YY_RULE_SETUP
    case S_dax__adag_1: case S_dax__adag_4: case S_dax__adag_5: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_5); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 103:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of child element.", dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 104:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `child' element start tag.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_dax__child):
 FAIL("EOF in attribute list of `child' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 105:
 /* rule 105 can match eol */
@@ -2584,27 +2584,27 @@ YY_RULE_SETUP
    case S_dax__adag_1: case S_dax__adag_4: case S_dax__adag_5: case S_dax__adag_3: case S_dax__adag: SET(S_dax__adag_5); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 106:
 /* rule 106 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</child>' expected.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case 107:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</child>' expected.",dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_dax__child_2):
 case YY_STATE_EOF(E_dax__child):
 case YY_STATE_EOF(S_dax__child):
 FAIL("Premature EOF: `</child>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 108:
 /* rule 108 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <parent> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 109:
 /* rule 109 can match eol */
 YY_RULE_SETUP
@@ -2613,25 +2613,25 @@ YY_RULE_SETUP
   dax__parent_ref_isset = 0;
   ENTER(AL_dax__parent); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 110:
 /* rule 110 can match eol */
 YY_RULE_SETUP
 if (dax__parent_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__parent>");} dax__parent_ref_isset = 1; ENTER(VALUE1); BUFFERSET(AX_dax__parent_ref);
-  YY_BREAK
+       YY_BREAK
 case 111:
 /* rule 111 can match eol */
 YY_RULE_SETUP
 if (dax__parent_ref_isset != 0) {FAIL("Multiple definition of attribute ref in <dax__parent>");}  dax__parent_ref_isset = 1; ENTER(VALUE2); BUFFERSET(AX_dax__parent_ref);
-  YY_BREAK
+       YY_BREAK
 case 112:
 YY_RULE_SETUP
 {
   if (!AX_dax__parent_ref) FAIL("Required attribute `ref' not set for `parent' element.");
   LEAVE; STag_dax__parent();dax__pcdata_ix = 0; ENTER(E_dax__parent);
  }
-  YY_BREAK
+       YY_BREAK
 case 113:
 YY_RULE_SETUP
 {
@@ -2641,18 +2641,18 @@ YY_RULE_SETUP
    case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 114:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of parent element.", dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 115:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `parent' element start tag.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_dax__parent):
 FAIL("EOF in attribute list of `parent' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 116:
 /* rule 116 can match eol */
@@ -2665,29 +2665,29 @@ YY_RULE_SETUP
    case S_dax__child_2: case S_dax__child: case S_dax__child_1: SET(S_dax__child_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 117:
 /* rule 117 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</parent>' expected.",dax_text);
-  YY_BREAK
+       YY_BREAK
 case 118:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</parent>' expected.",dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_dax__parent):
 FAIL("Premature EOF: `</parent>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 /* EPILOG: after the root element. */
 
 case 119:
 YY_RULE_SETUP
 {SET(PROLOG); yyless(0); CLEANUP; return -1;}
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(EPILOG):
 SUCCEED;
-  YY_BREAK
+       YY_BREAK
 
 /* CHARACTER DATA. */
 
@@ -2695,32 +2695,32 @@ SUCCEED;
 case 120:
 YY_RULE_SETUP
 BUFFERPUTC('&');
-  YY_BREAK
+       YY_BREAK
 case 121:
 YY_RULE_SETUP
 BUFFERPUTC('<');
-  YY_BREAK
+       YY_BREAK
 case 122:
 YY_RULE_SETUP
 BUFFERPUTC('>');
-  YY_BREAK
+       YY_BREAK
 case 123:
 YY_RULE_SETUP
 BUFFERPUTC('\'');
-  YY_BREAK
+       YY_BREAK
 case 124:
 YY_RULE_SETUP
 BUFFERPUTC('"');
-  YY_BREAK
+       YY_BREAK
 /* Character entities. */
 case 125:
 YY_RULE_SETUP
 BUFFERPUTC((unsigned char)atoi(dax_text+2));
-  YY_BREAK
+       YY_BREAK
 case 126:
 YY_RULE_SETUP
 BUFFERPUTC((unsigned char)strtol(dax_text+3,NULL,16));
-  YY_BREAK
+       YY_BREAK
 
 case 127:
 /* rule 127 can match eol */
@@ -2732,55 +2732,55 @@ case 130:
 /* rule 130 can match eol */
 YY_RULE_SETUP
 BUFFERPUTC('\n');
-  YY_BREAK
+       YY_BREAK
 
 case 131:
 YY_RULE_SETUP
 ENTER(CDATA);
-  YY_BREAK
+       YY_BREAK
 case 132:
 YY_RULE_SETUP
 FAIL("Unexpected `]""]>' in character data.");
-  YY_BREAK
+       YY_BREAK
 
 case 133:
 YY_RULE_SETUP
 BUFFERDONE; LEAVE;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(VALUE1):
 FAIL("EOF in literal (\"'\" expected).");
-  YY_BREAK
+       YY_BREAK
 
 case 134:
 YY_RULE_SETUP
 BUFFERDONE; LEAVE;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(VALUE2):
 FAIL("EOF in literal (`\"' expected).");
-  YY_BREAK
+       YY_BREAK
 
 case 135:
 /* rule 135 can match eol */
 YY_RULE_SETUP
 BUFFERPUTC(dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 136:
 YY_RULE_SETUP
 FAIL("Spurious `%c' in character data.",dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 
 case 137:
 YY_RULE_SETUP
 LEAVE;
-  YY_BREAK
-/* "]""]"    BUFFERPUTC(dax_text[0]); BUFFERPUTC(dax_text[1]); */
+       YY_BREAK
+/* "]""]"              BUFFERPUTC(dax_text[0]); BUFFERPUTC(dax_text[1]); */
 case 138:
 YY_RULE_SETUP
 BUFFERPUTC(dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(CDATA):
 FAIL("EOF in CDATA section.");
-  YY_BREAK
+       YY_BREAK
 
 /* Impossible rules to avoid warnings from flex(1). */
 /* Ideally, this should be replaced by code in flexml.pl that
@@ -2790,12 +2790,12 @@ case 139:
 /* rule 139 can match eol */
 YY_RULE_SETUP
 FAIL("Syntax error on character `%c'.", dax_text[0]);
-  YY_BREAK
+       YY_BREAK
 
 case 140:
 YY_RULE_SETUP
 ECHO;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(ROOT_dax__adag):
 case YY_STATE_EOF(S_dax__adag_2):
@@ -2803,331 +2803,331 @@ case YY_STATE_EOF(S_dax__adag_4):
 case YY_STATE_EOF(S_dax__job_1):
 case YY_STATE_EOF(S_dax__child_1):
 case YY_STATE_EOF(IMPOSSIBLE):
-  yyterminate();
-
-  case YY_END_OF_BUFFER:
-    {
-    /* Amount of text matched not including the EOB char. */
-    int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
-
-    /* Undo the effects of YY_DO_BEFORE_ACTION. */
-    *yy_cp = (yy_hold_char);
-    YY_RESTORE_YY_MORE_OFFSET
-
-    if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-      {
-      /* We're scanning a new file or input source.  It's
-       * possible that this happened because the user
-       * just pointed dax_in at a new source and called
-       * dax_lex().  If so, then we have to assure
-       * consistency between YY_CURRENT_BUFFER and our
-       * globals.  Here is the right place to do so, because
-       * this is the first action (other than possibly a
-       * back-up) that will match for the new input source.
-       */
-      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-      YY_CURRENT_BUFFER_LVALUE->yy_input_file = dax_in;
-      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-      }
-
-    /* Note that here we test for yy_c_buf_p "<=" to the position
-     * of the first EOB in the buffer, since yy_c_buf_p will
-     * already have been incremented past the NUL character
-     * (since all states make transitions on EOB to the
-     * end-of-buffer state).  Contrast this with the test
-     * in input().
-     */
-    if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-      { /* This was really a NUL. */
-      yy_state_type yy_next_state;
-
-      (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-
-      yy_current_state = yy_get_previous_state(  );
-
-      /* Okay, we're now positioned to make the NUL
-       * transition.  We couldn't have
-       * yy_get_previous_state() go ahead and do it
-       * for us because it doesn't know how to deal
-       * with the possibility of jamming (and we don't
-       * want to build jamming into it because then it
-       * will run more slowly).
-       */
-
-      yy_next_state = yy_try_NUL_trans( yy_current_state );
-
-      yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-
-      if ( yy_next_state )
-        {
-        /* Consume the NUL. */
-        yy_cp = ++(yy_c_buf_p);
-        yy_current_state = yy_next_state;
-        goto yy_match;
-        }
-
-      else
-        {
-        yy_cp = (yy_c_buf_p);
-        goto yy_find_action;
-        }
-      }
-
-    else switch ( yy_get_next_buffer(  ) )
-      {
-      case EOB_ACT_END_OF_FILE:
-        {
-        (yy_did_buffer_switch_on_eof) = 0;
-
-        if ( dax_wrap( ) )
-          {
-          /* Note: because we've taken care in
-           * yy_get_next_buffer() to have set up
-           * dax_text, we can now set up
-           * yy_c_buf_p so that if some total
-           * hoser (like flex itself) wants to
-           * call the scanner after we return the
-           * YY_NULL, it'll still work - another
-           * YY_NULL will get returned.
-           */
-          (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
-
-          yy_act = YY_STATE_EOF(YY_START);
-          goto do_action;
-          }
-
-        else
-          {
-          if ( ! (yy_did_buffer_switch_on_eof) )
-            YY_NEW_FILE;
-          }
-        break;
-        }
-
-      case EOB_ACT_CONTINUE_SCAN:
-        (yy_c_buf_p) =
-          (yytext_ptr) + yy_amount_of_matched_text;
-
-        yy_current_state = yy_get_previous_state(  );
-
-        yy_cp = (yy_c_buf_p);
-        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-        goto yy_match;
-
-      case EOB_ACT_LAST_MATCH:
-        (yy_c_buf_p) =
-        &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
-
-        yy_current_state = yy_get_previous_state(  );
-
-        yy_cp = (yy_c_buf_p);
-        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-        goto yy_find_action;
-      }
-    break;
-    }
-
-  default:
-    YY_FATAL_ERROR(
-      "fatal flex scanner internal error--no action found" );
-  } /* end of action switch */
-    } /* end of scanning one token */
+       yyterminate();
+
+       case YY_END_OF_BUFFER:
+               {
+               /* Amount of text matched not including the EOB char. */
+               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+               /* Undo the effects of YY_DO_BEFORE_ACTION. */
+               *yy_cp = (yy_hold_char);
+               YY_RESTORE_YY_MORE_OFFSET
+
+               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+                       {
+                       /* We're scanning a new file or input source.  It's
+                        * possible that this happened because the user
+                        * just pointed dax_in at a new source and called
+                        * dax_lex().  If so, then we have to assure
+                        * consistency between YY_CURRENT_BUFFER and our
+                        * globals.  Here is the right place to do so, because
+                        * this is the first action (other than possibly a
+                        * back-up) that will match for the new input source.
+                        */
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+                       YY_CURRENT_BUFFER_LVALUE->yy_input_file = dax_in;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+                       }
+
+               /* Note that here we test for yy_c_buf_p "<=" to the position
+                * of the first EOB in the buffer, since yy_c_buf_p will
+                * already have been incremented past the NUL character
+                * (since all states make transitions on EOB to the
+                * end-of-buffer state).  Contrast this with the test
+                * in input().
+                */
+               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+                       { /* This was really a NUL. */
+                       yy_state_type yy_next_state;
+
+                       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+                       yy_current_state = yy_get_previous_state(  );
+
+                       /* Okay, we're now positioned to make the NUL
+                        * transition.  We couldn't have
+                        * yy_get_previous_state() go ahead and do it
+                        * for us because it doesn't know how to deal
+                        * with the possibility of jamming (and we don't
+                        * want to build jamming into it because then it
+                        * will run more slowly).
+                        */
+
+                       yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+                       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+                       if ( yy_next_state )
+                               {
+                               /* Consume the NUL. */
+                               yy_cp = ++(yy_c_buf_p);
+                               yy_current_state = yy_next_state;
+                               goto yy_match;
+                               }
+
+                       else
+                               {
+                               yy_cp = (yy_c_buf_p);
+                               goto yy_find_action;
+                               }
+                       }
+
+               else switch ( yy_get_next_buffer(  ) )
+                       {
+                       case EOB_ACT_END_OF_FILE:
+                               {
+                               (yy_did_buffer_switch_on_eof) = 0;
+
+                               if ( dax_wrap( ) )
+                                       {
+                                       /* Note: because we've taken care in
+                                        * yy_get_next_buffer() to have set up
+                                        * dax_text, we can now set up
+                                        * yy_c_buf_p so that if some total
+                                        * hoser (like flex itself) wants to
+                                        * call the scanner after we return the
+                                        * YY_NULL, it'll still work - another
+                                        * YY_NULL will get returned.
+                                        */
+                                       (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+                                       yy_act = YY_STATE_EOF(YY_START);
+                                       goto do_action;
+                                       }
+
+                               else
+                                       {
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
+                                       }
+                               break;
+                               }
+
+                       case EOB_ACT_CONTINUE_SCAN:
+                               (yy_c_buf_p) =
+                                       (yytext_ptr) + yy_amount_of_matched_text;
+
+                               yy_current_state = yy_get_previous_state(  );
+
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_match;
+
+                       case EOB_ACT_LAST_MATCH:
+                               (yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+                               yy_current_state = yy_get_previous_state(  );
+
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_find_action;
+                       }
+               break;
+               }
+
+       default:
+               YY_FATAL_ERROR(
+                       "fatal flex scanner internal error--no action found" );
+       } /* end of action switch */
+               } /* end of scanning one token */
 } /* end of dax_lex */
 
 /* yy_get_next_buffer - try to read in a new buffer
  *
  * Returns a code representing an action:
- *  EOB_ACT_LAST_MATCH -
- *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *  EOB_ACT_END_OF_FILE - end of file
+ *     EOB_ACT_LAST_MATCH -
+ *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *     EOB_ACT_END_OF_FILE - end of file
  */
 static int yy_get_next_buffer (void)
 {
-      register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-  register char *source = (yytext_ptr);
-  register int number_to_move, i;
-  int ret_val;
-
-  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
-    YY_FATAL_ERROR(
-    "fatal flex scanner internal error--end of buffer missed" );
-
-  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-    { /* Don't try to fill the buffer, so this is an EOF. */
-    if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
-      {
-      /* We matched a single character, the EOB, so
-       * treat this as a final EOF.
-       */
-      return EOB_ACT_END_OF_FILE;
-      }
-
-    else
-      {
-      /* We matched some text prior to the EOB, first
-       * process it.
-       */
-      return EOB_ACT_LAST_MATCH;
-      }
-    }
-
-  /* Try to read more data. */
-
-  /* First move last chars to start of buffer. */
-  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
-
-  for ( i = 0; i < number_to_move; ++i )
-    *(dest++) = *(source++);
-
-  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-    /* don't do the read, it's not guaranteed to return an EOF,
-     * just force an EOF
-     */
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
-
-  else
-    {
-      int num_to_read =
-      YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-    while ( num_to_read <= 0 )
-      { /* Not enough room in the buffer - grow it. */
-
-      /* just a shorter name for the current buffer */
-      YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-
-      int yy_c_buf_p_offset =
-        (int) ((yy_c_buf_p) - b->yy_ch_buf);
-
-      if ( b->yy_is_our_buffer )
-        {
-        int new_size = b->yy_buf_size * 2;
-
-        if ( new_size <= 0 )
-          b->yy_buf_size += b->yy_buf_size / 8;
-        else
-          b->yy_buf_size *= 2;
-
-        b->yy_ch_buf = (char *)
-          /* Include room in for 2 EOB chars. */
-          dax_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
-        }
-      else
-        /* Can't grow it, we don't own it. */
-        b->yy_ch_buf = 0;
-
-      if ( ! b->yy_ch_buf )
-        YY_FATAL_ERROR(
-        "fatal error - scanner input buffer overflow" );
-
-      (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-            number_to_move - 1;
-
-      }
-
-    if ( num_to_read > YY_READ_BUF_SIZE )
-      num_to_read = YY_READ_BUF_SIZE;
-
-    /* Read in more data. */
-    YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-      (yy_n_chars), (size_t) num_to_read );
-
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-    }
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = (yytext_ptr);
+       register int number_to_move, i;
+       int ret_val;
+
+       if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+               YY_FATAL_ERROR(
+               "fatal flex scanner internal error--end of buffer missed" );
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+               { /* Don't try to fill the buffer, so this is an EOF. */
+               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+                       {
+                       /* We matched a single character, the EOB, so
+                        * treat this as a final EOF.
+                        */
+                       return EOB_ACT_END_OF_FILE;
+                       }
+
+               else
+                       {
+                       /* We matched some text prior to the EOB, first
+                        * process it.
+                        */
+                       return EOB_ACT_LAST_MATCH;
+                       }
+               }
+
+       /* Try to read more data. */
+
+       /* First move last chars to start of buffer. */
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
+
+       for ( i = 0; i < number_to_move; ++i )
+               *(dest++) = *(source++);
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+               /* don't do the read, it's not guaranteed to return an EOF,
+                * just force an EOF
+                */
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+       else
+               {
+                       int num_to_read =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+               while ( num_to_read <= 0 )
+                       { /* Not enough room in the buffer - grow it. */
+
+                       /* just a shorter name for the current buffer */
+                       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
+
+                       int yy_c_buf_p_offset =
+                               (int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+                       if ( b->yy_is_our_buffer )
+                               {
+                               int new_size = b->yy_buf_size * 2;
+
+                               if ( new_size <= 0 )
+                                       b->yy_buf_size += b->yy_buf_size / 8;
+                               else
+                                       b->yy_buf_size *= 2;
+
+                               b->yy_ch_buf = (char *)
+                                       /* Include room in for 2 EOB chars. */
+                                       dax_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
+                               }
+                       else
+                               /* Can't grow it, we don't own it. */
+                               b->yy_ch_buf = 0;
+
+                       if ( ! b->yy_ch_buf )
+                               YY_FATAL_ERROR(
+                               "fatal error - scanner input buffer overflow" );
+
+                       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+                                               number_to_move - 1;
+
+                       }
+
+               if ( num_to_read > YY_READ_BUF_SIZE )
+                       num_to_read = YY_READ_BUF_SIZE;
+
+               /* Read in more data. */
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       (yy_n_chars), (size_t) num_to_read );
+
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       if ( (yy_n_chars) == 0 )
+               {
+               if ( number_to_move == YY_MORE_ADJ )
+                       {
+                       ret_val = EOB_ACT_END_OF_FILE;
+                       dax_restart(dax_in  );
+                       }
+
+               else
+                       {
+                       ret_val = EOB_ACT_LAST_MATCH;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+                               YY_BUFFER_EOF_PENDING;
+                       }
+               }
+
+       else
+               ret_val = EOB_ACT_CONTINUE_SCAN;
+
+       if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+               /* Extend the array by 50%, plus the number we really need. */
+               yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) dax_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
+               if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+                       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+       }
+
+       (yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+       (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
-  if ( (yy_n_chars) == 0 )
-    {
-    if ( number_to_move == YY_MORE_ADJ )
-      {
-      ret_val = EOB_ACT_END_OF_FILE;
-      dax_restart(dax_in  );
-      }
-
-    else
-      {
-      ret_val = EOB_ACT_LAST_MATCH;
-      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-        YY_BUFFER_EOF_PENDING;
-      }
-    }
-
-  else
-    ret_val = EOB_ACT_CONTINUE_SCAN;
-
-  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-    /* Extend the array by 50%, plus the number we really need. */
-    yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) dax_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
-    if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-      YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-  }
-
-  (yy_n_chars) += number_to_move;
-  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
-  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
-
-  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-  return ret_val;
+       return ret_val;
 }
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
     static yy_state_type yy_get_previous_state (void)
 {
-  register yy_state_type yy_current_state;
-  register char *yy_cp;
+       register yy_state_type yy_current_state;
+       register char *yy_cp;
     
-  yy_current_state = (yy_start);
-
-  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
-    {
-    register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-    if ( yy_accept[yy_current_state] )
-      {
-      (yy_last_accepting_state) = yy_current_state;
-      (yy_last_accepting_cpos) = yy_cp;
-      }
-    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-      {
-      yy_current_state = (int) yy_def[yy_current_state];
-      if ( yy_current_state >= 775 )
-        yy_c = yy_meta[(unsigned int) yy_c];
-      }
-    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-    }
-
-  return yy_current_state;
+       yy_current_state = (yy_start);
+
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+               {
+               register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+               if ( yy_accept[yy_current_state] )
+                       {
+                       (yy_last_accepting_state) = yy_current_state;
+                       (yy_last_accepting_cpos) = yy_cp;
+                       }
+               while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                       {
+                       yy_current_state = (int) yy_def[yy_current_state];
+                       if ( yy_current_state >= 775 )
+                               yy_c = yy_meta[(unsigned int) yy_c];
+                       }
+               yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+               }
+
+       return yy_current_state;
 }
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
- *  next_state = yy_try_NUL_trans( current_state );
+ *     next_state = yy_try_NUL_trans( current_state );
  */
     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
 {
-  register int yy_is_jam;
-      register char *yy_cp = (yy_c_buf_p);
-
-  register YY_CHAR yy_c = 1;
-  if ( yy_accept[yy_current_state] )
-    {
-    (yy_last_accepting_state) = yy_current_state;
-    (yy_last_accepting_cpos) = yy_cp;
-    }
-  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-    {
-    yy_current_state = (int) yy_def[yy_current_state];
-    if ( yy_current_state >= 775 )
-      yy_c = yy_meta[(unsigned int) yy_c];
-    }
-  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-  yy_is_jam = (yy_current_state == 774);
-
-  return yy_is_jam ? 0 : yy_current_state;
+       register int yy_is_jam;
+       register char *yy_cp = (yy_c_buf_p);
+
+       register YY_CHAR yy_c = 1;
+       if ( yy_accept[yy_current_state] )
+               {
+               (yy_last_accepting_state) = yy_current_state;
+               (yy_last_accepting_cpos) = yy_cp;
+               }
+       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+               {
+               yy_current_state = (int) yy_def[yy_current_state];
+               if ( yy_current_state >= 775 )
+                       yy_c = yy_meta[(unsigned int) yy_c];
+               }
+       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+       yy_is_jam = (yy_current_state == 774);
+
+       return yy_is_jam ? 0 : yy_current_state;
 }
 
 #ifndef YY_NO_INPUT
@@ -3138,76 +3138,76 @@ static int yy_get_next_buffer (void)
 #endif
 
 {
-  int c;
+       int c;
     
-  *(yy_c_buf_p) = (yy_hold_char);
-
-  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
-    {
-    /* yy_c_buf_p now points to the character we want to return.
-     * If this occurs *before* the EOB characters, then it's a
-     * valid NUL; if not, then we've hit the end of the buffer.
-     */
-    if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-      /* This was really a NUL. */
-      *(yy_c_buf_p) = '\0';
-
-    else
-      { /* need more input */
-      int offset = (yy_c_buf_p) - (yytext_ptr);
-      ++(yy_c_buf_p);
-
-      switch ( yy_get_next_buffer(  ) )
-        {
-        case EOB_ACT_LAST_MATCH:
-          /* This happens because yy_g_n_b()
-           * sees that we've accumulated a
-           * token and flags that we need to
-           * try matching the token before
-           * proceeding.  But for input(),
-           * there's no matching to consider.
-           * So convert the EOB_ACT_LAST_MATCH
-           * to EOB_ACT_END_OF_FILE.
-           */
-
-          /* Reset buffer status. */
-          dax_restart(dax_in );
-
-          /*FALLTHROUGH*/
-
-        case EOB_ACT_END_OF_FILE:
-          {
-          if ( dax_wrap( ) )
-            return EOF;
-
-          if ( ! (yy_did_buffer_switch_on_eof) )
-            YY_NEW_FILE;
+       *(yy_c_buf_p) = (yy_hold_char);
+
+       if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+               {
+               /* yy_c_buf_p now points to the character we want to return.
+                * If this occurs *before* the EOB characters, then it's a
+                * valid NUL; if not, then we've hit the end of the buffer.
+                */
+               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+                       /* This was really a NUL. */
+                       *(yy_c_buf_p) = '\0';
+
+               else
+                       { /* need more input */
+                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       ++(yy_c_buf_p);
+
+                       switch ( yy_get_next_buffer(  ) )
+                               {
+                               case EOB_ACT_LAST_MATCH:
+                                       /* This happens because yy_g_n_b()
+                                        * sees that we've accumulated a
+                                        * token and flags that we need to
+                                        * try matching the token before
+                                        * proceeding.  But for input(),
+                                        * there's no matching to consider.
+                                        * So convert the EOB_ACT_LAST_MATCH
+                                        * to EOB_ACT_END_OF_FILE.
+                                        */
+
+                                       /* Reset buffer status. */
+                                       dax_restart(dax_in );
+
+                                       /*FALLTHROUGH*/
+
+                               case EOB_ACT_END_OF_FILE:
+                                       {
+                                       if ( dax_wrap( ) )
+                                               return EOF;
+
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
 #ifdef __cplusplus
-          return yyinput();
+                                       return yyinput();
 #else
-          return input();
+                                       return input();
 #endif
-          }
+                                       }
 
-        case EOB_ACT_CONTINUE_SCAN:
-          (yy_c_buf_p) = (yytext_ptr) + offset;
-          break;
-        }
-      }
-    }
+                               case EOB_ACT_CONTINUE_SCAN:
+                                       (yy_c_buf_p) = (yytext_ptr) + offset;
+                                       break;
+                               }
+                       }
+               }
 
-  c = *(unsigned char *) (yy_c_buf_p);  /* cast for 8-bit char's */
-  *(yy_c_buf_p) = '\0';  /* preserve dax_text */
-  (yy_hold_char) = *++(yy_c_buf_p);
+       c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
+       *(yy_c_buf_p) = '\0';   /* preserve dax_text */
+       (yy_hold_char) = *++(yy_c_buf_p);
 
-  if ( c == '\n' )
-       
+       if ( c == '\n' )
+                  
     dax_lineno++;
 ;
 
-  return c;
+       return c;
 }
-#endif  /* ifndef YY_NO_INPUT */
+#endif /* ifndef YY_NO_INPUT */
 
 /** Immediately switch to a different input stream.
  * @param input_file A readable stream.
@@ -3217,14 +3217,14 @@ static int yy_get_next_buffer (void)
     void dax_restart  (FILE * input_file )
 {
     
-  if ( ! YY_CURRENT_BUFFER ){
+       if ( ! YY_CURRENT_BUFFER ){
         dax_ensure_buffer_stack ();
-    YY_CURRENT_BUFFER_LVALUE =
+               YY_CURRENT_BUFFER_LVALUE =
             dax__create_buffer(dax_in,YY_BUF_SIZE );
-  }
+       }
 
-  dax__init_buffer(YY_CURRENT_BUFFER,input_file );
-  dax__load_buffer_state( );
+       dax__init_buffer(YY_CURRENT_BUFFER,input_file );
+       dax__load_buffer_state( );
 }
 
 /** Switch to a different input buffer.
@@ -3234,40 +3234,40 @@ static int yy_get_next_buffer (void)
     void dax__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
 {
     
-  /* TODO. We should be able to replace this entire function body
-   * with
-   *    dax_pop_buffer_state();
-   *    dax_push_buffer_state(new_buffer);
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              dax_pop_buffer_state();
+        *              dax_push_buffer_state(new_buffer);
      */
-  dax_ensure_buffer_stack ();
-  if ( YY_CURRENT_BUFFER == new_buffer )
-    return;
-
-  if ( YY_CURRENT_BUFFER )
-    {
-    /* Flush out information for old buffer. */
-    *(yy_c_buf_p) = (yy_hold_char);
-    YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-    }
-
-  YY_CURRENT_BUFFER_LVALUE = new_buffer;
-  dax__load_buffer_state( );
-
-  /* We don't actually know whether we did this switch during
-   * EOF (dax_wrap()) processing, but the only time this flag
-   * is looked at is after dax_wrap() is called, so it's safe
-   * to go ahead and always set it.
-   */
-  (yy_did_buffer_switch_on_eof) = 1;
+       dax_ensure_buffer_stack ();
+       if ( YY_CURRENT_BUFFER == new_buffer )
+               return;
+
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       dax__load_buffer_state( );
+
+       /* We don't actually know whether we did this switch during
+        * EOF (dax_wrap()) processing, but the only time this flag
+        * is looked at is after dax_wrap() is called, so it's safe
+        * to go ahead and always set it.
+        */
+       (yy_did_buffer_switch_on_eof) = 1;
 }
 
 static void dax__load_buffer_state  (void)
 {
-      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-  dax_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-  (yy_hold_char) = *(yy_c_buf_p);
+       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+       (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+       dax_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);
 }
 
 /** Allocate and initialize an input buffer state.
@@ -3278,26 +3278,26 @@ static void dax__load_buffer_state  (void)
  */
     YY_BUFFER_STATE dax__create_buffer  (FILE * file, int  size )
 {
-  YY_BUFFER_STATE b;
+       YY_BUFFER_STATE b;
     
-  b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
-  if ( ! b )
-    YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
+       b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
 
-  b->yy_buf_size = size;
+       b->yy_buf_size = size;
 
-  /* yy_ch_buf has to be 2 characters longer than the size given because
-   * we need to put in 2 end-of-buffer characters.
-   */
-  b->yy_ch_buf = (char *) dax_alloc(b->yy_buf_size + 2  );
-  if ( ! b->yy_ch_buf )
-    YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
+       /* yy_ch_buf has to be 2 characters longer than the size given because
+        * we need to put in 2 end-of-buffer characters.
+        */
+       b->yy_ch_buf = (char *) dax_alloc(b->yy_buf_size + 2  );
+       if ( ! b->yy_ch_buf )
+               YY_FATAL_ERROR( "out of dynamic memory in dax__create_buffer()" );
 
-  b->yy_is_our_buffer = 1;
+       b->yy_is_our_buffer = 1;
 
-  dax__init_buffer(b,file );
+       dax__init_buffer(b,file );
 
-  return b;
+       return b;
 }
 
 /** Destroy the buffer.
@@ -3307,16 +3307,16 @@ static void dax__load_buffer_state  (void)
     void dax__delete_buffer (YY_BUFFER_STATE  b )
 {
     
-  if ( ! b )
-    return;
+       if ( ! b )
+               return;
 
-  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-    YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+       if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
-  if ( b->yy_is_our_buffer )
-    dax_free((void *) b->yy_ch_buf  );
+       if ( b->yy_is_our_buffer )
+               dax_free((void *) b->yy_ch_buf  );
 
-  dax_free((void *) b  );
+       dax_free((void *) b  );
 }
 
 #ifndef __cplusplus
@@ -3330,12 +3330,12 @@ extern int isatty (int );
     static void dax__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 
 {
-  int oerrno = errno;
+       int oerrno = errno;
     
-  dax__flush_buffer(b );
+       dax__flush_buffer(b );
 
-  b->yy_input_file = file;
-  b->yy_fill_buffer = 1;
+       b->yy_input_file = file;
+       b->yy_fill_buffer = 1;
 
     /* If b is the current buffer, then dax__init_buffer was _probably_
      * called from dax_restart() or through yy_get_next_buffer.
@@ -3348,7 +3348,7 @@ extern int isatty (int );
 
         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
     
-  errno = oerrno;
+       errno = oerrno;
 }
 
 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
@@ -3357,25 +3357,25 @@ extern int isatty (int );
  */
     void dax__flush_buffer (YY_BUFFER_STATE  b )
 {
-      if ( ! b )
-    return;
+       if ( ! b )
+               return;
 
-  b->yy_n_chars = 0;
+       b->yy_n_chars = 0;
 
-  /* We always need two end-of-buffer characters.  The first causes
-   * a transition to the end-of-buffer state.  The second causes
-   * a jam in that state.
-   */
-  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+       /* We always need two end-of-buffer characters.  The first causes
+        * a transition to the end-of-buffer state.  The second causes
+        * a jam in that state.
+        */
+       b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+       b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 
-  b->yy_buf_pos = &b->yy_ch_buf[0];
+       b->yy_buf_pos = &b->yy_ch_buf[0];
 
-  b->yy_at_bol = 1;
-  b->yy_buffer_status = YY_BUFFER_NEW;
+       b->yy_at_bol = 1;
+       b->yy_buffer_status = YY_BUFFER_NEW;
 
-  if ( b == YY_CURRENT_BUFFER )
-    dax__load_buffer_state( );
+       if ( b == YY_CURRENT_BUFFER )
+               dax__load_buffer_state( );
 }
 
 /** Pushes the new state onto the stack. The new state becomes
@@ -3386,28 +3386,28 @@ extern int isatty (int );
  */
 void dax_push_buffer_state (YY_BUFFER_STATE new_buffer )
 {
-      if (new_buffer == NULL)
-    return;
+       if (new_buffer == NULL)
+               return;
 
-  dax_ensure_buffer_stack();
+       dax_ensure_buffer_stack();
 
-  /* This block is copied from dax__switch_to_buffer. */
-  if ( YY_CURRENT_BUFFER )
-    {
-    /* Flush out information for old buffer. */
-    *(yy_c_buf_p) = (yy_hold_char);
-    YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-    }
+       /* This block is copied from dax__switch_to_buffer. */
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
 
-  /* Only push if top exists. Otherwise, replace top. */
-  if (YY_CURRENT_BUFFER)
-    (yy_buffer_stack_top)++;
-  YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       /* Only push if top exists. Otherwise, replace top. */
+       if (YY_CURRENT_BUFFER)
+               (yy_buffer_stack_top)++;
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
-  /* copied from dax__switch_to_buffer. */
-  dax__load_buffer_state( );
-  (yy_did_buffer_switch_on_eof) = 1;
+       /* copied from dax__switch_to_buffer. */
+       dax__load_buffer_state( );
+       (yy_did_buffer_switch_on_eof) = 1;
 }
 
 /** Removes and deletes the top of the stack, if present.
@@ -3416,18 +3416,18 @@ void dax_push_buffer_state (YY_BUFFER_STATE new_buffer )
  */
 void dax_pop_buffer_state (void)
 {
-      if (!YY_CURRENT_BUFFER)
-    return;
+       if (!YY_CURRENT_BUFFER)
+               return;
 
-  dax__delete_buffer(YY_CURRENT_BUFFER );
-  YY_CURRENT_BUFFER_LVALUE = NULL;
-  if ((yy_buffer_stack_top) > 0)
-    --(yy_buffer_stack_top);
+       dax__delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
 
-  if (YY_CURRENT_BUFFER) {
-    dax__load_buffer_state( );
-    (yy_did_buffer_switch_on_eof) = 1;
-  }
+       if (YY_CURRENT_BUFFER) {
+               dax__load_buffer_state( );
+               (yy_did_buffer_switch_on_eof) = 1;
+       }
 }
 
 /* Allocates the stack if it does not exist.
@@ -3435,45 +3435,45 @@ void dax_pop_buffer_state (void)
  */
 static void dax_ensure_buffer_stack (void)
 {
-  int num_to_alloc;
+       int num_to_alloc;
     
-  if (!(yy_buffer_stack)) {
+       if (!(yy_buffer_stack)) {
 
-    /* First allocation is just for 2 elements, since we don't know if this
-     * scanner will even need a stack. We use 2 instead of 1 to avoid an
-     * immediate realloc on the next call.
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate realloc on the next call.
          */
-    num_to_alloc = 1;
-    (yy_buffer_stack) = (struct yy_buffer_state**)dax_alloc
-                (num_to_alloc * sizeof(struct yy_buffer_state*)
-                );
-    if ( ! (yy_buffer_stack) )
-      YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
-                  
-    memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-        
-    (yy_buffer_stack_max) = num_to_alloc;
-    (yy_buffer_stack_top) = 0;
-    return;
-  }
-
-  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
-
-    /* Increase the buffer to prepare for a possible push. */
-    int grow_size = 8 /* arbitrary grow size */;
-
-    num_to_alloc = (yy_buffer_stack_max) + grow_size;
-    (yy_buffer_stack) = (struct yy_buffer_state**)dax_realloc
-                ((yy_buffer_stack),
-                num_to_alloc * sizeof(struct yy_buffer_state*)
-                );
-    if ( ! (yy_buffer_stack) )
-      YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
-
-    /* zero only the new slots.*/
-    memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
-    (yy_buffer_stack_max) = num_to_alloc;
-  }
+               num_to_alloc = 1;
+               (yy_buffer_stack) = (struct yy_buffer_state**)dax_alloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
+                                                                 
+               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               (yy_buffer_stack_max) = num_to_alloc;
+               (yy_buffer_stack_top) = 0;
+               return;
+       }
+
+       if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)dax_realloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in dax_ensure_buffer_stack()" );
+
+               /* zero only the new slots.*/
+               memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+               (yy_buffer_stack_max) = num_to_alloc;
+       }
 }
 
 /** Setup the input buffer state to scan directly from a user-specified character buffer.
@@ -3484,31 +3484,31 @@ static void dax_ensure_buffer_stack (void)
  */
 YY_BUFFER_STATE dax__scan_buffer  (char * base, yy_size_t  size )
 {
-  YY_BUFFER_STATE b;
+       YY_BUFFER_STATE b;
     
-  if ( size < 2 ||
-       base[size-2] != YY_END_OF_BUFFER_CHAR ||
-       base[size-1] != YY_END_OF_BUFFER_CHAR )
-    /* They forgot to leave room for the EOB's. */
-    return 0;
-
-  b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
-  if ( ! b )
-    YY_FATAL_ERROR( "out of dynamic memory in dax__scan_buffer()" );
-
-  b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
-  b->yy_buf_pos = b->yy_ch_buf = base;
-  b->yy_is_our_buffer = 0;
-  b->yy_input_file = 0;
-  b->yy_n_chars = b->yy_buf_size;
-  b->yy_is_interactive = 0;
-  b->yy_at_bol = 1;
-  b->yy_fill_buffer = 0;
-  b->yy_buffer_status = YY_BUFFER_NEW;
-
-  dax__switch_to_buffer(b  );
-
-  return b;
+       if ( size < 2 ||
+            base[size-2] != YY_END_OF_BUFFER_CHAR ||
+            base[size-1] != YY_END_OF_BUFFER_CHAR )
+               /* They forgot to leave room for the EOB's. */
+               return 0;
+
+       b = (YY_BUFFER_STATE) dax_alloc(sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in dax__scan_buffer()" );
+
+       b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
+       b->yy_buf_pos = b->yy_ch_buf = base;
+       b->yy_is_our_buffer = 0;
+       b->yy_input_file = 0;
+       b->yy_n_chars = b->yy_buf_size;
+       b->yy_is_interactive = 0;
+       b->yy_at_bol = 1;
+       b->yy_fill_buffer = 0;
+       b->yy_buffer_status = YY_BUFFER_NEW;
+
+       dax__switch_to_buffer(b  );
+
+       return b;
 }
 
 /** Setup the input buffer state to scan a string. The next call to dax_lex() will
@@ -3522,7 +3522,7 @@ YY_BUFFER_STATE dax__scan_buffer  (char * base, yy_size_t  size )
 YY_BUFFER_STATE dax__scan_string (yyconst char * yystr )
 {
     
-  return dax__scan_bytes(yystr,strlen(yystr) );
+       return dax__scan_bytes(yystr,strlen(yystr) );
 }
 
 /** Setup the input buffer state to scan the given bytes. The next call to dax_lex() will
@@ -3534,64 +3534,64 @@ YY_BUFFER_STATE dax__scan_string (yyconst char * yystr )
  */
 YY_BUFFER_STATE dax__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 {
-  YY_BUFFER_STATE b;
-  char *buf;
-  yy_size_t n;
-  int i;
+       YY_BUFFER_STATE b;
+       char *buf;
+       yy_size_t n;
+       int i;
     
-  /* Get memory for full buffer, including space for trailing EOB's. */
-  n = _yybytes_len + 2;
-  buf = (char *) dax_alloc(n  );
-  if ( ! buf )
-    YY_FATAL_ERROR( "out of dynamic memory in dax__scan_bytes()" );
+       /* Get memory for full buffer, including space for trailing EOB's. */
+       n = _yybytes_len + 2;
+       buf = (char *) dax_alloc(n  );
+       if ( ! buf )
+               YY_FATAL_ERROR( "out of dynamic memory in dax__scan_bytes()" );
 
-  for ( i = 0; i < _yybytes_len; ++i )
-    buf[i] = yybytes[i];
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
 
-  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-  b = dax__scan_buffer(buf,n );
-  if ( ! b )
-    YY_FATAL_ERROR( "bad buffer in dax__scan_bytes()" );
+       b = dax__scan_buffer(buf,n );
+       if ( ! b )
+               YY_FATAL_ERROR( "bad buffer in dax__scan_bytes()" );
 
-  /* It's okay to grow etc. this buffer, and we should throw it
-   * away when we're done.
-   */
-  b->yy_is_our_buffer = 1;
+       /* It's okay to grow etc. this buffer, and we should throw it
+        * away when we're done.
+        */
+       b->yy_is_our_buffer = 1;
 
-  return b;
+       return b;
 }
 
     static void yy_push_state (int  new_state )
 {
-      if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
-    {
-    yy_size_t new_size;
+       if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
+               {
+               yy_size_t new_size;
 
-    (yy_start_stack_depth) += YY_START_STACK_INCR;
-    new_size = (yy_start_stack_depth) * sizeof( int );
+               (yy_start_stack_depth) += YY_START_STACK_INCR;
+               new_size = (yy_start_stack_depth) * sizeof( int );
 
-    if ( ! (yy_start_stack) )
-      (yy_start_stack) = (int *) dax_alloc(new_size  );
+               if ( ! (yy_start_stack) )
+                       (yy_start_stack) = (int *) dax_alloc(new_size  );
 
-    else
-      (yy_start_stack) = (int *) dax_realloc((void *) (yy_start_stack),new_size  );
+               else
+                       (yy_start_stack) = (int *) dax_realloc((void *) (yy_start_stack),new_size  );
 
-    if ( ! (yy_start_stack) )
-      YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
-    }
+               if ( ! (yy_start_stack) )
+                       YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
+               }
 
-  (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
+       (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
 
-  BEGIN(new_state);
+       BEGIN(new_state);
 }
 
     static void yy_pop_state  (void)
 {
-      if ( --(yy_start_stack_ptr) < 0 )
-    YY_FATAL_ERROR( "start-condition stack underflow" );
+       if ( --(yy_start_stack_ptr) < 0 )
+               YY_FATAL_ERROR( "start-condition stack underflow" );
 
-  BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
+       BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
 }
 
 #ifndef YY_EXIT_FAILURE
@@ -3600,26 +3600,26 @@ YY_BUFFER_STATE dax__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 
 static void yy_fatal_error (yyconst char* msg )
 {
-      (void) fprintf( stderr, "%s\n", msg );
-  exit( YY_EXIT_FAILURE );
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
 }
 
 /* Redefine yyless() so it works in section 3 code. */
 
 #undef yyless
 #define yyless(n) \
-  do \
-    { \
-    /* Undo effects of setting up dax_text. */ \
+       do \
+               { \
+               /* Undo effects of setting up dax_text. */ \
         int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
-    dax_text[dax_leng] = (yy_hold_char); \
-    (yy_c_buf_p) = dax_text + yyless_macro_arg; \
-    (yy_hold_char) = *(yy_c_buf_p); \
-    *(yy_c_buf_p) = '\0'; \
-    dax_leng = yyless_macro_arg; \
-    } \
-  while ( 0 )
+               dax_text[dax_leng] = (yy_hold_char); \
+               (yy_c_buf_p) = dax_text + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               dax_leng = yyless_macro_arg; \
+               } \
+       while ( 0 )
 
 /* Accessor  methods (get/set functions) to struct members. */
 
@@ -3741,15 +3741,15 @@ int dax_lex_destroy  (void)
 {
     
     /* Pop the buffer stack, destroying each element. */
-  while(YY_CURRENT_BUFFER){
-    dax__delete_buffer(YY_CURRENT_BUFFER  );
-    YY_CURRENT_BUFFER_LVALUE = NULL;
-    dax_pop_buffer_state();
-  }
+       while(YY_CURRENT_BUFFER){
+               dax__delete_buffer(YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               dax_pop_buffer_state();
+       }
 
-  /* Destroy the stack itself. */
-  dax_free((yy_buffer_stack) );
-  (yy_buffer_stack) = NULL;
+       /* Destroy the stack itself. */
+       dax_free((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;
 
     /* Destroy the start condition stack. */
         dax_free((yy_start_stack)  );
@@ -3769,43 +3769,43 @@ int dax_lex_destroy  (void)
 #ifndef yytext_ptr
 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 {
-  register int i;
-  for ( i = 0; i < n; ++i )
-    s1[i] = s2[i];
+       register int i;
+       for ( i = 0; i < n; ++i )
+               s1[i] = s2[i];
 }
 #endif
 
 #ifdef YY_NEED_STRLEN
 static int yy_flex_strlen (yyconst char * s )
 {
-  register int n;
-  for ( n = 0; s[n]; ++n )
-    ;
+       register int n;
+       for ( n = 0; s[n]; ++n )
+               ;
 
-  return n;
+       return n;
 }
 #endif
 
 void *dax_alloc (yy_size_t  size )
 {
-  return (void *) malloc( size );
+       return (void *) malloc( size );
 }
 
 void *dax_realloc  (void * ptr, yy_size_t  size )
 {
-  /* The cast to (char *) in the following accommodates both
-   * implementations that use char* generic pointers, and those
-   * that use void* generic pointers.  It works with the latter
-   * because both ANSI C and C++ allow castless assignment from
-   * any pointer type to void*, and deal with argument conversions
-   * as though doing an assignment.
-   */
-  return (void *) realloc( (char *) ptr, size );
+       /* The cast to (char *) in the following accommodates both
+        * implementations that use char* generic pointers, and those
+        * that use void* generic pointers.  It works with the latter
+        * because both ANSI C and C++ allow castless assignment from
+        * any pointer type to void*, and deal with argument conversions
+        * as though doing an assignment.
+        */
+       return (void *) realloc( (char *) ptr, size );
 }
 
 void dax_free (void * ptr )
 {
-  free( (char *) ptr );  /* see dax_realloc() for (char *) cast */
+       free( (char *) ptr );   /* see dax_realloc() for (char *) cast */
 }
 
 #define YYTABLES_NAME "yytables"
@@ -3814,8 +3814,8 @@ void dax_free (void * ptr )
 int dax__element_context(int i)
 {
   return (0<i && i<yy_start_stack_depth
-    ? yy_start_stack[yy_start_stack_ptr - i]
-    : 0);
+         ? yy_start_stack[yy_start_stack_ptr - i]
+         : 0);
 }
 
 #ifdef FLEX_DEBUG
@@ -3854,7 +3854,7 @@ static void debug_enter(int state, const char* statename) {
 static void debug_leave(void) {
     if (dax__flex_debug) {
         print_yy_stack("--LEAVE : ");
-  print_dax__bufferstack();
+       print_dax__bufferstack();
     }
   yy_pop_state();
 }
@@ -3869,7 +3869,7 @@ static void cleanup(void)
 {
     if (dax__statenames) {
         free(dax__statenames);
-  dax__statenames = NULL;
+       dax__statenames = NULL;
     }
     free(dax__bufferstack);
     dax__bufferstack = NULL;
@@ -3884,12 +3884,12 @@ static int fail(const char* fmt, ...)
     va_list ap; va_start(ap, fmt);
 #ifdef FLEXML_yylineno
     used = sprintf(flexml_err_msg,
-       "Invalid XML (XML input line %d, state %d): ",
-       dax_lineno, YY_START);
+                  "Invalid XML (XML input line %d, state %d): ",
+                  dax_lineno, YY_START);
 #else
     used = sprintf(flexml_err_msg,
-       "Invalid XML (state %d): ",
-       YY_START);
+                  "Invalid XML (state %d): ",
+                  YY_START);
 #endif
     chars_left = flexml_max_err_msg_size - used - 1;
     vsnprintf(flexml_err_msg + used, chars_left, fmt, ap);
index f49848d..f42a72f 100644 (file)
@@ -111,15 +111,15 @@ typedef unsigned int flex_uint32_t;
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
-#else  /* ! __cplusplus */
+#else  /* ! __cplusplus */
 
 /* C99 requires __STDC__ to be defined as 1. */
 #if defined (__STDC__)
 
 #define YY_USE_CONST
 
-#endif  /* defined (__STDC__) */
-#endif  /* ! __cplusplus */
+#endif /* defined (__STDC__) */
+#endif /* ! __cplusplus */
 
 #ifdef YY_USE_CONST
 #define yyconst const
@@ -205,17 +205,17 @@ extern FILE *surf_parse_in, *surf_parse_out;
     
 /* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
-  do \
-    { \
-    /* Undo effects of setting up surf_parse_text. */ \
+       do \
+               { \
+               /* Undo effects of setting up surf_parse_text. */ \
         int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
-    *yy_cp = (yy_hold_char); \
-    YY_RESTORE_YY_MORE_OFFSET \
-    (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-    YY_DO_BEFORE_ACTION; /* set up surf_parse_text again */ \
-    } \
-  while ( 0 )
+               *yy_cp = (yy_hold_char); \
+               YY_RESTORE_YY_MORE_OFFSET \
+               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+               YY_DO_BEFORE_ACTION; /* set up surf_parse_text again */ \
+               } \
+       while ( 0 )
 
 #define unput(c) yyunput( c, (yytext_ptr)  )
 
@@ -227,66 +227,66 @@ typedef size_t yy_size_t;
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
-  {
-  FILE *yy_input_file;
-
-  char *yy_ch_buf;    /* input buffer */
-  char *yy_buf_pos;    /* current position in input buffer */
-
-  /* Size of input buffer in bytes, not including room for EOB
-   * characters.
-   */
-  yy_size_t yy_buf_size;
-
-  /* Number of characters read into yy_ch_buf, not including EOB
-   * characters.
-   */
-  int yy_n_chars;
-
-  /* Whether we "own" the buffer - i.e., we know we created it,
-   * and can realloc() it to grow it, and should free() it to
-   * delete it.
-   */
-  int yy_is_our_buffer;
-
-  /* Whether this is an "interactive" input source; if so, and
-   * if we're using stdio for input, then we want to use getc()
-   * instead of fread(), to make sure we stop fetching input after
-   * each newline.
-   */
-  int yy_is_interactive;
-
-  /* Whether we're considered to be at the beginning of a line.
-   * If so, '^' rules will be active on the next match, otherwise
-   * not.
-   */
-  int yy_at_bol;
+       {
+       FILE *yy_input_file;
+
+       char *yy_ch_buf;                /* input buffer */
+       char *yy_buf_pos;               /* current position in input buffer */
+
+       /* Size of input buffer in bytes, not including room for EOB
+        * characters.
+        */
+       yy_size_t yy_buf_size;
+
+       /* Number of characters read into yy_ch_buf, not including EOB
+        * characters.
+        */
+       int yy_n_chars;
+
+       /* Whether we "own" the buffer - i.e., we know we created it,
+        * and can realloc() it to grow it, and should free() it to
+        * delete it.
+        */
+       int yy_is_our_buffer;
+
+       /* Whether this is an "interactive" input source; if so, and
+        * if we're using stdio for input, then we want to use getc()
+        * instead of fread(), to make sure we stop fetching input after
+        * each newline.
+        */
+       int yy_is_interactive;
+
+       /* Whether we're considered to be at the beginning of a line.
+        * If so, '^' rules will be active on the next match, otherwise
+        * not.
+        */
+       int yy_at_bol;
 
     int yy_bs_lineno; /**< The line count. */
     int yy_bs_column; /**< The column count. */
     
-  /* Whether to try to fill the input buffer when we reach the
-   * end of it.
-   */
-  int yy_fill_buffer;
+       /* Whether to try to fill the input buffer when we reach the
+        * end of it.
+        */
+       int yy_fill_buffer;
 
-  int yy_buffer_status;
+       int yy_buffer_status;
 
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
-  /* When an EOF's been seen but there's still some text to process
-   * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-   * shouldn't try reading from the input source any more.  We might
-   * still have a bunch of tokens to match, though, because of
-   * possible backing-up.
-   *
-   * When we actually see the EOF, we change the status to "new"
-   * (via surf_parse_restart()), so that the user can continue scanning by
-   * just pointing surf_parse_in at a new input file.
-   */
+       /* When an EOF's been seen but there's still some text to process
+        * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+        * shouldn't try reading from the input source any more.  We might
+        * still have a bunch of tokens to match, though, because of
+        * possible backing-up.
+        *
+        * When we actually see the EOF, we change the status to "new"
+        * (via surf_parse_restart()), so that the user can continue scanning by
+        * just pointing surf_parse_in at a new input file.
+        */
 #define YY_BUFFER_EOF_PENDING 2
 
-  };
+       };
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
 /* Stack of input buffers. */
@@ -311,13 +311,13 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* yy_hold_char holds the character lost when surf_parse_text is formed. */
 static char yy_hold_char;
-static int yy_n_chars;    /* number of characters read into yy_ch_buf */
+static int yy_n_chars;         /* number of characters read into yy_ch_buf */
 int surf_parse_leng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 0;    /* whether we need to initialize */
-static int yy_start = 0;  /* start state number */
+static int yy_init = 0;                /* whether we need to initialize */
+static int yy_start = 0;       /* start state number */
 
 /* Flag which is used to allow surf_parse_wrap()'s to do buffer switches
  * instead of setting up a fresh surf_parse_in.  A bit of a hack ...
@@ -349,24 +349,24 @@ void surf_parse_free (void *  );
 #define yy_new_buffer surf_parse__create_buffer
 
 #define yy_set_interactive(is_interactive) \
-  { \
-  if ( ! YY_CURRENT_BUFFER ){ \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){ \
         surf_parse_ensure_buffer_stack (); \
-    YY_CURRENT_BUFFER_LVALUE =    \
+               YY_CURRENT_BUFFER_LVALUE =    \
             surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE ); \
-  } \
-  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-  }
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+       }
 
 #define yy_set_bol(at_bol) \
-  { \
-  if ( ! YY_CURRENT_BUFFER ){\
+       { \
+       if ( ! YY_CURRENT_BUFFER ){\
         surf_parse_ensure_buffer_stack (); \
-    YY_CURRENT_BUFFER_LVALUE =    \
+               YY_CURRENT_BUFFER_LVALUE =    \
             surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE ); \
-  } \
-  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-  }
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+       }
 
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
@@ -397,21 +397,21 @@ static void yy_fatal_error (yyconst char msg[]  );
  * corresponding action - sets up surf_parse_text.
  */
 #define YY_DO_BEFORE_ACTION \
-  (yytext_ptr) = yy_bp; \
-  surf_parse_leng = (size_t) (yy_cp - yy_bp); \
-  (yy_hold_char) = *yy_cp; \
-  *yy_cp = '\0'; \
-  (yy_c_buf_p) = yy_cp;
+       (yytext_ptr) = yy_bp; \
+       surf_parse_leng = (size_t) (yy_cp - yy_bp); \
+       (yy_hold_char) = *yy_cp; \
+       *yy_cp = '\0'; \
+       (yy_c_buf_p) = yy_cp;
 
 #define YY_NUM_RULES 476
 #define YY_END_OF_BUFFER 477
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
-  {
-  flex_int32_t yy_verify;
-  flex_int32_t yy_nxt;
-  };
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
 static yyconst flex_int16_t yy_accept[2809] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
@@ -4157,23 +4157,23 @@ short int surfxml_platform_version_isset;
 
 /* XML state. */
 #ifdef FLEX_DEBUG
-# define ENTER(state)  debug_enter(state,#state)
-# define LEAVE    debug_leave()
-# define SET(state)  debug_set(state,#state)
+# define ENTER(state)  debug_enter(state,#state)
+# define LEAVE         debug_leave()
+# define SET(state)    debug_set(state,#state)
   static void debug_enter(int, const char*);
   static void debug_leave(void);
   static void debug_set(int, const char*);
 #else
-# define ENTER(state)  (yy_push_state(state))
-# define LEAVE    (yy_pop_state())
-# define SET(state)  BEGIN(state)
+# define ENTER(state)  (yy_push_state(state))
+# define LEAVE         (yy_pop_state())
+# define SET(state)    BEGIN(state)
 #endif
 
 /* Generic actions. */
-#define SKIP  /*skip*/
+#define SKIP   /*skip*/
 #define SUCCEED        CLEANUP; return 0
 
-#define FAIL  return fail
+#define FAIL   return fail
 static int fail(const char*, ...);
 
 enum {flexml_max_err_msg_size = 512};
@@ -4210,12 +4210,12 @@ static int inext = 1;
 static int ck_blimit()
 {
      if (bnext >= blimit) {
-   blimit += FLEXML_BUFFERSTACKSIZE + 2;
-   {
-       char *temp = (char *) realloc(surfxml_bufferstack, blimit);
-       assert(temp);
-       surfxml_bufferstack = temp;
-   }
+        blimit += FLEXML_BUFFERSTACKSIZE + 2;
+        {
+            char *temp = (char *) realloc(surfxml_bufferstack, blimit);
+            assert(temp);
+            surfxml_bufferstack = temp;
+        }
      }
      return 0;
 }
@@ -4224,12 +4224,12 @@ static int ck_blimit()
 static int ck_ilimit()
 {
      if (inext >= ilimit) {
-   ilimit += FLEXML_INDEXSTACKSIZE + 2;
-   {
-       int *temp = (int *) realloc(indexstack, ilimit);
-       assert(temp);
-       indexstack = temp;
-   }
+        ilimit += FLEXML_INDEXSTACKSIZE + 2;
+        {
+            int *temp = (int *) realloc(indexstack, ilimit);
+            assert(temp);
+            indexstack = temp;
+        }
      }
      return 0;
 }
@@ -4275,18 +4275,18 @@ static int popbuffer(void)
 /* Miscellaneous. */
 /* Parser states (flex `exclusive start conditions'):
  *
- * PROLOG  the XML prolog of the document before <?xml...>
- * DOCTYPE  the XML prolog of the document after <?xml...>
- * EPILOG  after the root element
- * INCOMMENT  inside an XML comment <!--....-->
- * INPI    inside an XML PI <?...?>
- * VALUE1  inside a '...'-delimited literal
- * VALUE2  inside a "..."-delimited literal
- * 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
+ * PROLOG      the XML prolog of the document before <?xml...>
+ * DOCTYPE     the XML prolog of the document after <?xml...>
+ * EPILOG      after the root element
+ * INCOMMENT   inside an XML comment <!--....-->
+ * INPI                inside an XML PI <?...?>
+ * VALUE1      inside a '...'-delimited literal
+ * VALUE2      inside a "..."-delimited literal
+ * 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
  */
 
 /* State names. */
@@ -4522,33 +4522,33 @@ static int input (void );
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-    { \
-    int c = '*'; \
-    size_t n; \
-    for ( n = 0; n < max_size && \
-           (c = getc( surf_parse_in )) != EOF && c != '\n'; ++n ) \
-      buf[n] = (char) c; \
-    if ( c == '\n' ) \
-      buf[n++] = (char) c; \
-    if ( c == EOF && ferror( surf_parse_in ) ) \
-      YY_FATAL_ERROR( "input in flex scanner failed" ); \
-    result = n; \
-    } \
-  else \
-    { \
-    errno=0; \
-    while ( (result = fread(buf, 1, max_size, surf_parse_in))==0 && ferror(surf_parse_in)) \
-      { \
-      if( errno != EINTR) \
-        { \
-        YY_FATAL_ERROR( "input in flex scanner failed" ); \
-        break; \
-        } \
-      errno=0; \
-      clearerr(surf_parse_in); \
-      } \
-    }\
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+               { \
+               int c = '*'; \
+               size_t n; \
+               for ( n = 0; n < max_size && \
+                            (c = getc( surf_parse_in )) != EOF && c != '\n'; ++n ) \
+                       buf[n] = (char) c; \
+               if ( c == '\n' ) \
+                       buf[n++] = (char) c; \
+               if ( c == EOF && ferror( surf_parse_in ) ) \
+                       YY_FATAL_ERROR( "input in flex scanner failed" ); \
+               result = n; \
+               } \
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, max_size, surf_parse_in))==0 && ferror(surf_parse_in)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(surf_parse_in); \
+                       } \
+               }\
 \
 
 #endif
@@ -4597,15 +4597,15 @@ extern int surf_parse_lex (void);
 #endif
 
 #define YY_RULE_SETUP \
-  YY_USER_ACTION
+       YY_USER_ACTION
 
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {
-  register yy_state_type yy_current_state;
-  register char *yy_cp, *yy_bp;
-  register int yy_act;
+       register yy_state_type yy_current_state;
+       register char *yy_cp, *yy_bp;
+       register int yy_act;
     
  /* Bypass Flex's default INITIAL state and begin by parsing the XML prolog. */
  SET(PROLOG);
@@ -4756,172 +4756,172 @@ YY_DECL
 
  /* COMMENTS and PIs: handled uniformly for efficiency. */
 
-  if ( !(yy_init) )
-    {
-    (yy_init) = 1;
+       if ( !(yy_init) )
+               {
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
-    YY_USER_INIT;
+               YY_USER_INIT;
 #endif
 
-    if ( ! (yy_start) )
-      (yy_start) = 1;  /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
 
-    if ( ! surf_parse_in )
-      surf_parse_in = stdin;
+               if ( ! surf_parse_in )
+                       surf_parse_in = stdin;
 
-    if ( ! surf_parse_out )
-      surf_parse_out = stdout;
+               if ( ! surf_parse_out )
+                       surf_parse_out = stdout;
 
-    if ( ! YY_CURRENT_BUFFER ) {
-      surf_parse_ensure_buffer_stack ();
-      YY_CURRENT_BUFFER_LVALUE =
-        surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE );
-    }
+               if ( ! YY_CURRENT_BUFFER ) {
+                       surf_parse_ensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE );
+               }
 
-    surf_parse__load_buffer_state( );
-    }
+               surf_parse__load_buffer_state( );
+               }
 
-  while ( 1 )    /* loops until end-of-file is reached */
-    {
-    yy_cp = (yy_c_buf_p);
+       while ( 1 )             /* loops until end-of-file is reached */
+               {
+               yy_cp = (yy_c_buf_p);
 
-    /* Support of surf_parse_text. */
-    *yy_cp = (yy_hold_char);
+               /* Support of surf_parse_text. */
+               *yy_cp = (yy_hold_char);
 
-    /* yy_bp points to the position in yy_ch_buf of the start of
-     * the current run.
-     */
-    yy_bp = yy_cp;
+               /* yy_bp points to the position in yy_ch_buf of the start of
+                * the current run.
+                */
+               yy_bp = yy_cp;
 
-    yy_current_state = (yy_start);
+               yy_current_state = (yy_start);
 yy_match:
-    do
-      {
-      register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-      if ( yy_accept[yy_current_state] )
-        {
-        (yy_last_accepting_state) = yy_current_state;
-        (yy_last_accepting_cpos) = yy_cp;
-        }
-      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-        {
-        yy_current_state = (int) yy_def[yy_current_state];
-        if ( yy_current_state >= 2809 )
-          yy_c = yy_meta[(unsigned int) yy_c];
-        }
-      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-      ++yy_cp;
-      }
-    while ( yy_base[yy_current_state] != 10175 );
+               do
+                       {
+                       register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+                       if ( yy_accept[yy_current_state] )
+                               {
+                               (yy_last_accepting_state) = yy_current_state;
+                               (yy_last_accepting_cpos) = yy_cp;
+                               }
+                       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                               {
+                               yy_current_state = (int) yy_def[yy_current_state];
+                               if ( yy_current_state >= 2809 )
+                                       yy_c = yy_meta[(unsigned int) yy_c];
+                               }
+                       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                       ++yy_cp;
+                       }
+               while ( yy_base[yy_current_state] != 10175 );
 
 yy_find_action:
-    yy_act = yy_accept[yy_current_state];
-    if ( yy_act == 0 )
-      { /* have to back up */
-      yy_cp = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      yy_act = yy_accept[yy_current_state];
-      }
-
-    YY_DO_BEFORE_ACTION;
-
-    if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
-      {
-      int yyl;
-      for ( yyl = 0; yyl < surf_parse_leng; ++yyl )
-        if ( surf_parse_text[yyl] == '\n' )
-             
+               yy_act = yy_accept[yy_current_state];
+               if ( yy_act == 0 )
+                       { /* have to back up */
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
+                       yy_act = yy_accept[yy_current_state];
+                       }
+
+               YY_DO_BEFORE_ACTION;
+
+               if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
+                       {
+                       int yyl;
+                       for ( yyl = 0; yyl < surf_parse_leng; ++yyl )
+                               if ( surf_parse_text[yyl] == '\n' )
+                                          
     surf_parse_lineno++;
 ;
-      }
+                       }
 
-do_action:  /* This label is used only to access EOF actions. */
+do_action:     /* This label is used only to access EOF actions. */
 
-    switch ( yy_act )
-  { /* beginning of action switch */
-      case 0: /* must back up */
-      /* undo the effects of YY_DO_BEFORE_ACTION */
-      *yy_cp = (yy_hold_char);
-      yy_cp = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      goto yy_find_action;
+               switch ( yy_act )
+       { /* beginning of action switch */
+                       case 0: /* must back up */
+                       /* undo the effects of YY_DO_BEFORE_ACTION */
+                       *yy_cp = (yy_hold_char);
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
+                       goto yy_find_action;
 
 case 1:
 YY_RULE_SETUP
 ENTER(INCOMMENT);
-  YY_BREAK
+       YY_BREAK
 case 2:
 YY_RULE_SETUP
 ENTER(INPI);
-  YY_BREAK
+       YY_BREAK
 
 case 3:
 YY_RULE_SETUP
 LEAVE;
-  YY_BREAK
+       YY_BREAK
 case 4:
 case 5:
 case 6:
 /* rule 6 can match eol */
 YY_RULE_SETUP
 SKIP;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(INCOMMENT):
 FAIL("EOF in comment.");
-  YY_BREAK
+       YY_BREAK
 
 case 7:
 YY_RULE_SETUP
 LEAVE;
-  YY_BREAK
+       YY_BREAK
 case 8:
 case 9:
 /* rule 9 can match eol */
 YY_RULE_SETUP
 SKIP;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(INPI):
 FAIL("EOF in PI (processing instruction).");
-  YY_BREAK
+       YY_BREAK
 
 /* SPACES: skipped uniformly */
 case 10:
 /* rule 10 can match eol */
 YY_RULE_SETUP
 SKIP;
-  YY_BREAK
+       YY_BREAK
 /* PROLOG: determine root element and process it. */
 
 case 11:
 /* rule 11 can match eol */
 YY_RULE_SETUP
 SET(DOCTYPE); 
-  YY_BREAK
+       YY_BREAK
 case 12:
 /* rule 12 can match eol */
 YY_RULE_SETUP
 FAIL("Bad declaration %s.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 
 case 13:
 /* rule 13 can match eol */
 YY_RULE_SETUP
 SET(ROOT_surfxml_platform);
-  YY_BREAK
+       YY_BREAK
 case 14:
 /* rule 14 can match eol */
 YY_RULE_SETUP
 FAIL("Bad declaration %s.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 15:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in prolog.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(PROLOG):
 case YY_STATE_EOF(DOCTYPE):
 FAIL("EOF in prolog.");
-  YY_BREAK
+       YY_BREAK
 
 /* RULES DERIVED FROM DTD. */
 /* <!-- Small DTD for SURF based tools. -->  */
@@ -4929,7 +4929,7 @@ case 16:
 /* rule 16 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <platform> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 17:
 /* rule 17 can match eol */
 YY_RULE_SETUP
@@ -4938,24 +4938,24 @@ YY_RULE_SETUP
   surfxml_platform_version_isset = 0;
   ENTER(AL_surfxml_platform); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 18:
 /* rule 18 can match eol */
 YY_RULE_SETUP
 if (surfxml_platform_version_isset != 0) {FAIL("Multiple definition of attribute version in <surfxml_platform>");} surfxml_platform_version_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_platform_version);
-  YY_BREAK
+       YY_BREAK
 case 19:
 /* rule 19 can match eol */
 YY_RULE_SETUP
 if (surfxml_platform_version_isset != 0) {FAIL("Multiple definition of attribute version in <surfxml_platform>");}  surfxml_platform_version_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_platform_version);
-  YY_BREAK
+       YY_BREAK
 case 20:
 YY_RULE_SETUP
 {
   LEAVE; STag_surfxml_platform();surfxml_pcdata_ix = 0; ENTER(S_surfxml_platform);
  }
-  YY_BREAK
+       YY_BREAK
 case 21:
 YY_RULE_SETUP
 {
@@ -4964,18 +4964,18 @@ YY_RULE_SETUP
    case ROOT_surfxml_platform: SET(EPILOG); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 22:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of platform element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 23:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `platform' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_platform):
 FAIL("EOF in attribute list of `platform' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 24:
 /* rule 24 can match eol */
@@ -4988,16 +4988,16 @@ YY_RULE_SETUP
    case ROOT_surfxml_platform: SET(EPILOG); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 25:
 /* rule 25 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</platform>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 26:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</platform>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_platform_8):
 case YY_STATE_EOF(S_surfxml_platform_1):
 case YY_STATE_EOF(S_surfxml_platform_3):
@@ -5006,13 +5006,13 @@ case YY_STATE_EOF(S_surfxml_platform_4):
 case YY_STATE_EOF(S_surfxml_platform_6):
 case YY_STATE_EOF(E_surfxml_platform):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</platform>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 27:
 /* rule 27 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <include> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 28:
 /* rule 28 can match eol */
 YY_RULE_SETUP
@@ -5021,25 +5021,25 @@ YY_RULE_SETUP
   surfxml_include_file_isset = 0;
   ENTER(AL_surfxml_include); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 29:
 /* rule 29 can match eol */
 YY_RULE_SETUP
 if (surfxml_include_file_isset != 0) {FAIL("Multiple definition of attribute file in <surfxml_include>");} surfxml_include_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_include_file);
-  YY_BREAK
+       YY_BREAK
 case 30:
 /* rule 30 can match eol */
 YY_RULE_SETUP
 if (surfxml_include_file_isset != 0) {FAIL("Multiple definition of attribute file in <surfxml_include>");}  surfxml_include_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_include_file);
-  YY_BREAK
+       YY_BREAK
 case 31:
 YY_RULE_SETUP
 {
   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);
  }
-  YY_BREAK
+       YY_BREAK
 case 32:
 YY_RULE_SETUP
 {
@@ -5052,18 +5052,18 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 33:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of include element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 34:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `include' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_include):
 FAIL("EOF in attribute list of `include' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 35:
 /* rule 35 can match eol */
@@ -5079,27 +5079,27 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 36:
 /* rule 36 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</include>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 37:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</include>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_include):
 case YY_STATE_EOF(S_surfxml_include):
 case YY_STATE_EOF(S_surfxml_include_2):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</include>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 38:
 /* rule 38 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <trace> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 39:
 /* rule 39 can match eol */
 YY_RULE_SETUP
@@ -5112,38 +5112,38 @@ YY_RULE_SETUP
   surfxml_trace_periodicity_isset = 0;
   ENTER(AL_surfxml_trace); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 40:
 /* rule 40 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_trace>");} surfxml_trace_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_trace_id);
-  YY_BREAK
+       YY_BREAK
 case 41:
 /* rule 41 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_trace>");}  surfxml_trace_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_trace_id);
-  YY_BREAK
+       YY_BREAK
 case 42:
 /* rule 42 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_file_isset != 0) {FAIL("Multiple definition of attribute file in <surfxml_trace>");} surfxml_trace_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_trace_file);
-  YY_BREAK
+       YY_BREAK
 case 43:
 /* rule 43 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_file_isset != 0) {FAIL("Multiple definition of attribute file in <surfxml_trace>");}  surfxml_trace_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_trace_file);
-  YY_BREAK
+       YY_BREAK
 case 44:
 /* rule 44 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_periodicity_isset != 0) {FAIL("Multiple definition of attribute periodicity in <surfxml_trace>");} surfxml_trace_periodicity_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_trace_periodicity);
-  YY_BREAK
+       YY_BREAK
 case 45:
 /* rule 45 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_periodicity_isset != 0) {FAIL("Multiple definition of attribute periodicity in <surfxml_trace>");}  surfxml_trace_periodicity_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_trace_periodicity);
-  YY_BREAK
+       YY_BREAK
 case 46:
 YY_RULE_SETUP
 {
@@ -5151,7 +5151,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_trace_periodicity) FAIL("Required attribute `periodicity' not set for `trace' element.");
   LEAVE; STag_surfxml_trace();pushbuffer(surfxml_pcdata_ix); BUFFERSET(surfxml_pcdata_ix);; ENTER(IN_trace);
  }
-  YY_BREAK
+       YY_BREAK
 case 47:
 YY_RULE_SETUP
 {
@@ -5168,18 +5168,18 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 48:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of trace element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 49:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `trace' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_trace):
 FAIL("EOF in attribute list of `trace' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 50:
 /* rule 50 can match eol */
@@ -5200,21 +5200,21 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 51:
 /* rule 51 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</trace>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(IN_trace):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</trace>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 52:
 /* rule 52 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <random> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 53:
 /* rule 53 can match eol */
 YY_RULE_SETUP
@@ -5237,106 +5237,106 @@ YY_RULE_SETUP
   surfxml_random_generator_isset = 0;
   ENTER(AL_surfxml_random); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 54:
 /* rule 54 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_random>");} surfxml_random_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_random_id);
-  YY_BREAK
+       YY_BREAK
 case 55:
 /* rule 55 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_random>");}  surfxml_random_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_random_id);
-  YY_BREAK
+       YY_BREAK
 case 56:
 /* rule 56 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_min_isset != 0) {FAIL("Multiple definition of attribute min in <surfxml_random>");} surfxml_random_min_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_random_min);
-  YY_BREAK
+       YY_BREAK
 case 57:
 /* rule 57 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_min_isset != 0) {FAIL("Multiple definition of attribute min in <surfxml_random>");}  surfxml_random_min_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_random_min);
-  YY_BREAK
+       YY_BREAK
 case 58:
 /* rule 58 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_max_isset != 0) {FAIL("Multiple definition of attribute max in <surfxml_random>");} surfxml_random_max_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_random_max);
-  YY_BREAK
+       YY_BREAK
 case 59:
 /* rule 59 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_max_isset != 0) {FAIL("Multiple definition of attribute max in <surfxml_random>");}  surfxml_random_max_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_random_max);
-  YY_BREAK
+       YY_BREAK
 case 60:
 /* rule 60 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_mean_isset != 0) {FAIL("Multiple definition of attribute mean in <surfxml_random>");} surfxml_random_mean_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_random_mean);
-  YY_BREAK
+       YY_BREAK
 case 61:
 /* rule 61 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_mean_isset != 0) {FAIL("Multiple definition of attribute mean in <surfxml_random>");}  surfxml_random_mean_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_random_mean);
-  YY_BREAK
+       YY_BREAK
 case 62:
 /* rule 62 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_std_deviation_isset != 0) {FAIL("Multiple definition of attribute std_deviation in <surfxml_random>");} surfxml_random_std_deviation_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_random_std_deviation);
-  YY_BREAK
+       YY_BREAK
 case 63:
 /* rule 63 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_std_deviation_isset != 0) {FAIL("Multiple definition of attribute std_deviation in <surfxml_random>");}  surfxml_random_std_deviation_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_random_std_deviation);
-  YY_BREAK
+       YY_BREAK
 case 64:
 /* rule 64 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_seed_isset != 0) {FAIL("Multiple definition of attribute seed in <surfxml_random>");} surfxml_random_seed_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_random_seed);
-  YY_BREAK
+       YY_BREAK
 case 65:
 /* rule 65 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_seed_isset != 0) {FAIL("Multiple definition of attribute seed in <surfxml_random>");}  surfxml_random_seed_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_random_seed);
-  YY_BREAK
+       YY_BREAK
 case 66:
 /* rule 66 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_radical_isset != 0) {FAIL("Multiple definition of attribute radical in <surfxml_random>");} surfxml_random_radical_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_random_radical);
-  YY_BREAK
+       YY_BREAK
 case 67:
 /* rule 67 can match eol */
 YY_RULE_SETUP
 if (surfxml_random_radical_isset != 0) {FAIL("Multiple definition of attribute radical in <surfxml_random>");}  surfxml_random_radical_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_random_radical);
-  YY_BREAK
+       YY_BREAK
 case 68:
 /* rule 68 can match eol */
 case 69:
 /* rule 69 can match eol */
 YY_RULE_SETUP
 A_surfxml_random_generator = A_surfxml_random_generator_DRAND48;
-  YY_BREAK
+       YY_BREAK
 case 70:
 /* rule 70 can match eol */
 case 71:
 /* rule 71 can match eol */
 YY_RULE_SETUP
 A_surfxml_random_generator = A_surfxml_random_generator_RAND;
-  YY_BREAK
+       YY_BREAK
 case 72:
 /* rule 72 can match eol */
 case 73:
 /* rule 73 can match eol */
 YY_RULE_SETUP
 A_surfxml_random_generator = A_surfxml_random_generator_RNGSTREAM;
-  YY_BREAK
+       YY_BREAK
 case 74:
 /* rule 74 can match eol */
 case 75:
 /* rule 75 can match eol */
 YY_RULE_SETUP
 A_surfxml_random_generator = A_surfxml_random_generator_NONE;
-  YY_BREAK
+       YY_BREAK
 case 76:
 YY_RULE_SETUP
 {
@@ -5347,7 +5347,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_random_std_deviation) FAIL("Required attribute `std_deviation' not set for `random' element.");
   LEAVE; STag_surfxml_random();surfxml_pcdata_ix = 0; ENTER(S_surfxml_random);
  }
-  YY_BREAK
+       YY_BREAK
 case 77:
 YY_RULE_SETUP
 {
@@ -5361,18 +5361,18 @@ YY_RULE_SETUP
    case S_surfxml_platform_2: case S_surfxml_platform: case S_surfxml_platform_3: SET(S_surfxml_platform_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 78:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of random element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 79:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `random' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_random):
 FAIL("EOF in attribute list of `random' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 80:
 /* rule 80 can match eol */
@@ -5385,27 +5385,27 @@ YY_RULE_SETUP
    case S_surfxml_platform_2: case S_surfxml_platform: case S_surfxml_platform_3: SET(S_surfxml_platform_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 81:
 /* rule 81 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</random>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 82:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</random>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_random):
 case YY_STATE_EOF(S_surfxml_random_2):
 case YY_STATE_EOF(E_surfxml_random):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</random>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 83:
 /* rule 83 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <trace_connect> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 84:
 /* rule 84 can match eol */
 YY_RULE_SETUP
@@ -5418,7 +5418,7 @@ YY_RULE_SETUP
   surfxml_trace_connect_element_isset = 0;
   ENTER(AL_surfxml_trace_connect); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 85:
 /* rule 85 can match eol */
@@ -5426,55 +5426,55 @@ case 86:
 /* rule 86 can match eol */
 YY_RULE_SETUP
 A_surfxml_trace_connect_kind = A_surfxml_trace_connect_kind_HOST_AVAIL;
-  YY_BREAK
+       YY_BREAK
 case 87:
 /* rule 87 can match eol */
 case 88:
 /* rule 88 can match eol */
 YY_RULE_SETUP
 A_surfxml_trace_connect_kind = A_surfxml_trace_connect_kind_POWER;
-  YY_BREAK
+       YY_BREAK
 case 89:
 /* rule 89 can match eol */
 case 90:
 /* rule 90 can match eol */
 YY_RULE_SETUP
 A_surfxml_trace_connect_kind = A_surfxml_trace_connect_kind_LINK_AVAIL;
-  YY_BREAK
+       YY_BREAK
 case 91:
 /* rule 91 can match eol */
 case 92:
 /* rule 92 can match eol */
 YY_RULE_SETUP
 A_surfxml_trace_connect_kind = A_surfxml_trace_connect_kind_BANDWIDTH;
-  YY_BREAK
+       YY_BREAK
 case 93:
 /* rule 93 can match eol */
 case 94:
 /* rule 94 can match eol */
 YY_RULE_SETUP
 A_surfxml_trace_connect_kind = A_surfxml_trace_connect_kind_LATENCY;
-  YY_BREAK
+       YY_BREAK
 case 95:
 /* rule 95 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_connect_trace_isset != 0) {FAIL("Multiple definition of attribute trace in <surfxml_trace_connect>");} surfxml_trace_connect_trace_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_trace_connect_trace);
-  YY_BREAK
+       YY_BREAK
 case 96:
 /* rule 96 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_connect_trace_isset != 0) {FAIL("Multiple definition of attribute trace in <surfxml_trace_connect>");}  surfxml_trace_connect_trace_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_trace_connect_trace);
-  YY_BREAK
+       YY_BREAK
 case 97:
 /* rule 97 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_connect_element_isset != 0) {FAIL("Multiple definition of attribute element in <surfxml_trace_connect>");} surfxml_trace_connect_element_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_trace_connect_element);
-  YY_BREAK
+       YY_BREAK
 case 98:
 /* rule 98 can match eol */
 YY_RULE_SETUP
 if (surfxml_trace_connect_element_isset != 0) {FAIL("Multiple definition of attribute element in <surfxml_trace_connect>");}  surfxml_trace_connect_element_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_trace_connect_element);
-  YY_BREAK
+       YY_BREAK
 case 99:
 YY_RULE_SETUP
 {
@@ -5482,7 +5482,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_trace_connect_element) FAIL("Required attribute `element' not set for `trace_connect' element.");
   LEAVE; STag_surfxml_trace_connect();surfxml_pcdata_ix = 0; ENTER(E_surfxml_trace_connect);
  }
-  YY_BREAK
+       YY_BREAK
 case 100:
 YY_RULE_SETUP
 {
@@ -5499,18 +5499,18 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 101:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of trace_connect element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 102:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `trace_connect' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_trace_connect):
 FAIL("EOF in attribute list of `trace_connect' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 103:
 /* rule 103 can match eol */
@@ -5529,25 +5529,25 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 104:
 /* rule 104 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</trace_connect>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 105:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</trace_connect>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_trace_connect):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</trace_connect>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 106:
 /* rule 106 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <AS> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 107:
 /* rule 107 can match eol */
 YY_RULE_SETUP
@@ -5558,28 +5558,28 @@ YY_RULE_SETUP
   surfxml_AS_routing_isset = 0;
   ENTER(AL_surfxml_AS); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 108:
 /* rule 108 can match eol */
 YY_RULE_SETUP
 if (surfxml_AS_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_AS>");} surfxml_AS_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_AS_id);
-  YY_BREAK
+       YY_BREAK
 case 109:
 /* rule 109 can match eol */
 YY_RULE_SETUP
 if (surfxml_AS_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_AS>");}  surfxml_AS_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_AS_id);
-  YY_BREAK
+       YY_BREAK
 case 110:
 /* rule 110 can match eol */
 YY_RULE_SETUP
 if (surfxml_AS_routing_isset != 0) {FAIL("Multiple definition of attribute routing in <surfxml_AS>");} surfxml_AS_routing_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_AS_routing);
-  YY_BREAK
+       YY_BREAK
 case 111:
 /* rule 111 can match eol */
 YY_RULE_SETUP
 if (surfxml_AS_routing_isset != 0) {FAIL("Multiple definition of attribute routing in <surfxml_AS>");}  surfxml_AS_routing_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_AS_routing);
-  YY_BREAK
+       YY_BREAK
 case 112:
 YY_RULE_SETUP
 {
@@ -5587,7 +5587,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_AS_routing) FAIL("Required attribute `routing' not set for `AS' element.");
   LEAVE; STag_surfxml_AS();surfxml_pcdata_ix = 0; ENTER(S_surfxml_AS);
  }
-  YY_BREAK
+       YY_BREAK
 case 113:
 YY_RULE_SETUP
 {
@@ -5600,18 +5600,18 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 114:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of AS element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 115:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `AS' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_AS):
 FAIL("EOF in attribute list of `AS' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 116:
 /* rule 116 can match eol */
@@ -5626,16 +5626,16 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 117:
 /* rule 117 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</AS>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 118:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</AS>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_AS_9):
 case YY_STATE_EOF(S_surfxml_AS_1):
 case YY_STATE_EOF(S_surfxml_AS_11):
@@ -5647,13 +5647,13 @@ case YY_STATE_EOF(S_surfxml_AS_8):
 case YY_STATE_EOF(S_surfxml_AS):
 case YY_STATE_EOF(S_surfxml_AS_4):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</AS>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 119:
 /* rule 119 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <storage_type> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 120:
 /* rule 120 can match eol */
 YY_RULE_SETUP
@@ -5668,48 +5668,48 @@ YY_RULE_SETUP
   surfxml_storage_type_content_isset = 0;
   ENTER(AL_surfxml_storage_type); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 121:
 /* rule 121 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_storage_type>");} surfxml_storage_type_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_storage_type_id);
-  YY_BREAK
+       YY_BREAK
 case 122:
 /* rule 122 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_storage_type>");}  surfxml_storage_type_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_storage_type_id);
-  YY_BREAK
+       YY_BREAK
 case 123:
 /* rule 123 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_model_isset != 0) {FAIL("Multiple definition of attribute model in <surfxml_storage_type>");} surfxml_storage_type_model_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_storage_type_model);
-  YY_BREAK
+       YY_BREAK
 case 124:
 /* rule 124 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_model_isset != 0) {FAIL("Multiple definition of attribute model in <surfxml_storage_type>");}  surfxml_storage_type_model_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_storage_type_model);
-  YY_BREAK
+       YY_BREAK
 case 125:
 /* rule 125 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_size_isset != 0) {FAIL("Multiple definition of attribute size in <surfxml_storage_type>");} surfxml_storage_type_size_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_storage_type_size);
-  YY_BREAK
+       YY_BREAK
 case 126:
 /* rule 126 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_size_isset != 0) {FAIL("Multiple definition of attribute size in <surfxml_storage_type>");}  surfxml_storage_type_size_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_storage_type_size);
-  YY_BREAK
+       YY_BREAK
 case 127:
 /* rule 127 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_content_isset != 0) {FAIL("Multiple definition of attribute content in <surfxml_storage_type>");} surfxml_storage_type_content_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_storage_type_content);
-  YY_BREAK
+       YY_BREAK
 case 128:
 /* rule 128 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_type_content_isset != 0) {FAIL("Multiple definition of attribute content in <surfxml_storage_type>");}  surfxml_storage_type_content_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_storage_type_content);
-  YY_BREAK
+       YY_BREAK
 case 129:
 YY_RULE_SETUP
 {
@@ -5718,7 +5718,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_storage_type_size) FAIL("Required attribute `size' not set for `storage_type' element.");
   LEAVE; STag_surfxml_storage_type();surfxml_pcdata_ix = 0; ENTER(S_surfxml_storage_type);
  }
-  YY_BREAK
+       YY_BREAK
 case 130:
 YY_RULE_SETUP
 {
@@ -5731,18 +5731,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_2: case S_surfxml_AS_3: SET(S_surfxml_AS_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 131:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of storage_type element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 132:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `storage_type' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_storage_type):
 FAIL("EOF in attribute list of `storage_type' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 133:
 /* rule 133 can match eol */
@@ -5756,27 +5756,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_2: case S_surfxml_AS_3: SET(S_surfxml_AS_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 134:
 /* rule 134 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</storage_type>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 135:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</storage_type>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_storage_type):
 case YY_STATE_EOF(S_surfxml_storage_type_2):
 case YY_STATE_EOF(S_surfxml_storage_type):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</storage_type>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 136:
 /* rule 136 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <storage> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 137:
 /* rule 137 can match eol */
 YY_RULE_SETUP
@@ -5789,38 +5789,38 @@ YY_RULE_SETUP
   surfxml_storage_content_isset = 0;
   ENTER(AL_surfxml_storage); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 138:
 /* rule 138 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_storage>");} surfxml_storage_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_storage_id);
-  YY_BREAK
+       YY_BREAK
 case 139:
 /* rule 139 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_storage>");}  surfxml_storage_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_storage_id);
-  YY_BREAK
+       YY_BREAK
 case 140:
 /* rule 140 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_typeId_isset != 0) {FAIL("Multiple definition of attribute typeId in <surfxml_storage>");} surfxml_storage_typeId_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_storage_typeId);
-  YY_BREAK
+       YY_BREAK
 case 141:
 /* rule 141 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_typeId_isset != 0) {FAIL("Multiple definition of attribute typeId in <surfxml_storage>");}  surfxml_storage_typeId_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_storage_typeId);
-  YY_BREAK
+       YY_BREAK
 case 142:
 /* rule 142 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_content_isset != 0) {FAIL("Multiple definition of attribute content in <surfxml_storage>");} surfxml_storage_content_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_storage_content);
-  YY_BREAK
+       YY_BREAK
 case 143:
 /* rule 143 can match eol */
 YY_RULE_SETUP
 if (surfxml_storage_content_isset != 0) {FAIL("Multiple definition of attribute content in <surfxml_storage>");}  surfxml_storage_content_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_storage_content);
-  YY_BREAK
+       YY_BREAK
 case 144:
 YY_RULE_SETUP
 {
@@ -5828,7 +5828,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_storage_typeId) FAIL("Required attribute `typeId' not set for `storage' element.");
   LEAVE; STag_surfxml_storage();surfxml_pcdata_ix = 0; ENTER(S_surfxml_storage);
  }
-  YY_BREAK
+       YY_BREAK
 case 145:
 YY_RULE_SETUP
 {
@@ -5840,18 +5840,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_2: case S_surfxml_AS_3: SET(S_surfxml_AS_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 146:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of storage element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 147:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `storage' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_storage):
 FAIL("EOF in attribute list of `storage' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 148:
 /* rule 148 can match eol */
@@ -5865,27 +5865,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_2: case S_surfxml_AS_3: SET(S_surfxml_AS_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 149:
 /* rule 149 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</storage>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 150:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</storage>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_storage):
 case YY_STATE_EOF(S_surfxml_storage):
 case YY_STATE_EOF(S_surfxml_storage_2):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</storage>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 151:
 /* rule 151 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <mount> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 152:
 /* rule 152 can match eol */
 YY_RULE_SETUP
@@ -5896,28 +5896,28 @@ YY_RULE_SETUP
   surfxml_mount_name_isset = 0;
   ENTER(AL_surfxml_mount); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 153:
 /* rule 153 can match eol */
 YY_RULE_SETUP
 if (surfxml_mount_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_mount>");} surfxml_mount_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_mount_id);
-  YY_BREAK
+       YY_BREAK
 case 154:
 /* rule 154 can match eol */
 YY_RULE_SETUP
 if (surfxml_mount_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_mount>");}  surfxml_mount_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_mount_id);
-  YY_BREAK
+       YY_BREAK
 case 155:
 /* rule 155 can match eol */
 YY_RULE_SETUP
 if (surfxml_mount_name_isset != 0) {FAIL("Multiple definition of attribute name in <surfxml_mount>");} surfxml_mount_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_mount_name);
-  YY_BREAK
+       YY_BREAK
 case 156:
 /* rule 156 can match eol */
 YY_RULE_SETUP
 if (surfxml_mount_name_isset != 0) {FAIL("Multiple definition of attribute name in <surfxml_mount>");}  surfxml_mount_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_mount_name);
-  YY_BREAK
+       YY_BREAK
 case 157:
 YY_RULE_SETUP
 {
@@ -5925,7 +5925,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_mount_name) FAIL("Required attribute `name' not set for `mount' element.");
   LEAVE; STag_surfxml_mount();surfxml_pcdata_ix = 0; ENTER(E_surfxml_mount);
  }
-  YY_BREAK
+       YY_BREAK
 case 158:
 YY_RULE_SETUP
 {
@@ -5936,18 +5936,18 @@ YY_RULE_SETUP
    case S_surfxml_host_1: case S_surfxml_host_2: case S_surfxml_host: SET(S_surfxml_host_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 159:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of mount element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 160:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `mount' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_mount):
 FAIL("EOF in attribute list of `mount' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 161:
 /* rule 161 can match eol */
@@ -5960,25 +5960,25 @@ YY_RULE_SETUP
    case S_surfxml_host_1: case S_surfxml_host_2: case S_surfxml_host: SET(S_surfxml_host_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 162:
 /* rule 162 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</mount>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 163:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</mount>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_mount):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</mount>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 164:
 /* rule 164 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <mstorage> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 165:
 /* rule 165 can match eol */
 YY_RULE_SETUP
@@ -5989,28 +5989,28 @@ YY_RULE_SETUP
   surfxml_mstorage_name_isset = 0;
   ENTER(AL_surfxml_mstorage); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 166:
 /* rule 166 can match eol */
 YY_RULE_SETUP
 if (surfxml_mstorage_typeId_isset != 0) {FAIL("Multiple definition of attribute typeId in <surfxml_mstorage>");} surfxml_mstorage_typeId_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_mstorage_typeId);
-  YY_BREAK
+       YY_BREAK
 case 167:
 /* rule 167 can match eol */
 YY_RULE_SETUP
 if (surfxml_mstorage_typeId_isset != 0) {FAIL("Multiple definition of attribute typeId in <surfxml_mstorage>");}  surfxml_mstorage_typeId_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_mstorage_typeId);
-  YY_BREAK
+       YY_BREAK
 case 168:
 /* rule 168 can match eol */
 YY_RULE_SETUP
 if (surfxml_mstorage_name_isset != 0) {FAIL("Multiple definition of attribute name in <surfxml_mstorage>");} surfxml_mstorage_name_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_mstorage_name);
-  YY_BREAK
+       YY_BREAK
 case 169:
 /* rule 169 can match eol */
 YY_RULE_SETUP
 if (surfxml_mstorage_name_isset != 0) {FAIL("Multiple definition of attribute name in <surfxml_mstorage>");}  surfxml_mstorage_name_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_mstorage_name);
-  YY_BREAK
+       YY_BREAK
 case 170:
 YY_RULE_SETUP
 {
@@ -6018,7 +6018,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_mstorage_name) FAIL("Required attribute `name' not set for `mstorage' element.");
   LEAVE; STag_surfxml_mstorage();surfxml_pcdata_ix = 0; ENTER(E_surfxml_mstorage);
  }
-  YY_BREAK
+       YY_BREAK
 case 171:
 YY_RULE_SETUP
 {
@@ -6029,18 +6029,18 @@ YY_RULE_SETUP
    case S_surfxml_host_1: case S_surfxml_host_2: case S_surfxml_host: SET(S_surfxml_host_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 172:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of mstorage element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 173:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `mstorage' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_mstorage):
 FAIL("EOF in attribute list of `mstorage' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 174:
 /* rule 174 can match eol */
@@ -6053,25 +6053,25 @@ YY_RULE_SETUP
    case S_surfxml_host_1: case S_surfxml_host_2: case S_surfxml_host: SET(S_surfxml_host_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 175:
 /* rule 175 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</mstorage>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 176:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</mstorage>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_mstorage):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</mstorage>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 177:
 /* rule 177 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <host> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 178:
 /* rule 178 can match eol */
 YY_RULE_SETUP
@@ -6094,92 +6094,92 @@ YY_RULE_SETUP
   surfxml_host_coordinates_isset = 0;
   ENTER(AL_surfxml_host); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 179:
 /* rule 179 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_host>");} surfxml_host_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_host_id);
-  YY_BREAK
+       YY_BREAK
 case 180:
 /* rule 180 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_host>");}  surfxml_host_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_host_id);
-  YY_BREAK
+       YY_BREAK
 case 181:
 /* rule 181 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_power_isset != 0) {FAIL("Multiple definition of attribute power in <surfxml_host>");} surfxml_host_power_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_host_power);
-  YY_BREAK
+       YY_BREAK
 case 182:
 /* rule 182 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_power_isset != 0) {FAIL("Multiple definition of attribute power in <surfxml_host>");}  surfxml_host_power_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_host_power);
-  YY_BREAK
+       YY_BREAK
 case 183:
 /* rule 183 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_core_isset != 0) {FAIL("Multiple definition of attribute core in <surfxml_host>");} surfxml_host_core_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_host_core);
-  YY_BREAK
+       YY_BREAK
 case 184:
 /* rule 184 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_core_isset != 0) {FAIL("Multiple definition of attribute core in <surfxml_host>");}  surfxml_host_core_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_host_core);
-  YY_BREAK
+       YY_BREAK
 case 185:
 /* rule 185 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_availability_isset != 0) {FAIL("Multiple definition of attribute availability in <surfxml_host>");} surfxml_host_availability_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_host_availability);
-  YY_BREAK
+       YY_BREAK
 case 186:
 /* rule 186 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_availability_isset != 0) {FAIL("Multiple definition of attribute availability in <surfxml_host>");}  surfxml_host_availability_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_host_availability);
-  YY_BREAK
+       YY_BREAK
 case 187:
 /* rule 187 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_availability_file_isset != 0) {FAIL("Multiple definition of attribute availability_file in <surfxml_host>");} surfxml_host_availability_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_host_availability_file);
-  YY_BREAK
+       YY_BREAK
 case 188:
 /* rule 188 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_availability_file_isset != 0) {FAIL("Multiple definition of attribute availability_file in <surfxml_host>");}  surfxml_host_availability_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_host_availability_file);
-  YY_BREAK
+       YY_BREAK
 case 189:
 /* rule 189 can match eol */
 case 190:
 /* rule 190 can match eol */
 YY_RULE_SETUP
 A_surfxml_host_state = A_surfxml_host_state_ON;
-  YY_BREAK
+       YY_BREAK
 case 191:
 /* rule 191 can match eol */
 case 192:
 /* rule 192 can match eol */
 YY_RULE_SETUP
 A_surfxml_host_state = A_surfxml_host_state_OFF;
-  YY_BREAK
+       YY_BREAK
 case 193:
 /* rule 193 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_host>");} surfxml_host_state_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_host_state_file);
-  YY_BREAK
+       YY_BREAK
 case 194:
 /* rule 194 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_host>");}  surfxml_host_state_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_host_state_file);
-  YY_BREAK
+       YY_BREAK
 case 195:
 /* rule 195 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_coordinates_isset != 0) {FAIL("Multiple definition of attribute coordinates in <surfxml_host>");} surfxml_host_coordinates_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_host_coordinates);
-  YY_BREAK
+       YY_BREAK
 case 196:
 /* rule 196 can match eol */
 YY_RULE_SETUP
 if (surfxml_host_coordinates_isset != 0) {FAIL("Multiple definition of attribute coordinates in <surfxml_host>");}  surfxml_host_coordinates_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_host_coordinates);
-  YY_BREAK
+       YY_BREAK
 case 197:
 YY_RULE_SETUP
 {
@@ -6187,7 +6187,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_host_power) FAIL("Required attribute `power' not set for `host' element.");
   LEAVE; STag_surfxml_host();surfxml_pcdata_ix = 0; ENTER(S_surfxml_host);
  }
-  YY_BREAK
+       YY_BREAK
 case 198:
 YY_RULE_SETUP
 {
@@ -6198,18 +6198,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_11: case S_surfxml_AS_10: case S_surfxml_AS: SET(S_surfxml_AS_11); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 199:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of host element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 200:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `host' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_host):
 FAIL("EOF in attribute list of `host' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 201:
 /* rule 201 can match eol */
@@ -6222,27 +6222,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_11: case S_surfxml_AS_10: case S_surfxml_AS: SET(S_surfxml_AS_11); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 202:
 /* rule 202 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</host>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 203:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</host>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_host):
 case YY_STATE_EOF(E_surfxml_host):
 case YY_STATE_EOF(S_surfxml_host_2):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</host>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 204:
 /* rule 204 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <cluster> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 205:
 /* rule 205 can match eol */
 YY_RULE_SETUP
@@ -6279,173 +6279,173 @@ YY_RULE_SETUP
   surfxml_cluster_router_id_isset = 0;
   ENTER(AL_surfxml_cluster); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 206:
 /* rule 206 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_cluster>");} surfxml_cluster_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_id);
-  YY_BREAK
+       YY_BREAK
 case 207:
 /* rule 207 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_cluster>");}  surfxml_cluster_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_id);
-  YY_BREAK
+       YY_BREAK
 case 208:
 /* rule 208 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_prefix_isset != 0) {FAIL("Multiple definition of attribute prefix in <surfxml_cluster>");} surfxml_cluster_prefix_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_prefix);
-  YY_BREAK
+       YY_BREAK
 case 209:
 /* rule 209 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_prefix_isset != 0) {FAIL("Multiple definition of attribute prefix in <surfxml_cluster>");}  surfxml_cluster_prefix_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_prefix);
-  YY_BREAK
+       YY_BREAK
 case 210:
 /* rule 210 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_suffix_isset != 0) {FAIL("Multiple definition of attribute suffix in <surfxml_cluster>");} surfxml_cluster_suffix_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_suffix);
-  YY_BREAK
+       YY_BREAK
 case 211:
 /* rule 211 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_suffix_isset != 0) {FAIL("Multiple definition of attribute suffix in <surfxml_cluster>");}  surfxml_cluster_suffix_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_suffix);
-  YY_BREAK
+       YY_BREAK
 case 212:
 /* rule 212 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_radical_isset != 0) {FAIL("Multiple definition of attribute radical in <surfxml_cluster>");} surfxml_cluster_radical_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_radical);
-  YY_BREAK
+       YY_BREAK
 case 213:
 /* rule 213 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_radical_isset != 0) {FAIL("Multiple definition of attribute radical in <surfxml_cluster>");}  surfxml_cluster_radical_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_radical);
-  YY_BREAK
+       YY_BREAK
 case 214:
 /* rule 214 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_power_isset != 0) {FAIL("Multiple definition of attribute power in <surfxml_cluster>");} surfxml_cluster_power_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_power);
-  YY_BREAK
+       YY_BREAK
 case 215:
 /* rule 215 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_power_isset != 0) {FAIL("Multiple definition of attribute power in <surfxml_cluster>");}  surfxml_cluster_power_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_power);
-  YY_BREAK
+       YY_BREAK
 case 216:
 /* rule 216 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_core_isset != 0) {FAIL("Multiple definition of attribute core in <surfxml_cluster>");} surfxml_cluster_core_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_core);
-  YY_BREAK
+       YY_BREAK
 case 217:
 /* rule 217 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_core_isset != 0) {FAIL("Multiple definition of attribute core in <surfxml_cluster>");}  surfxml_cluster_core_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_core);
-  YY_BREAK
+       YY_BREAK
 case 218:
 /* rule 218 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_bw_isset != 0) {FAIL("Multiple definition of attribute bw in <surfxml_cluster>");} surfxml_cluster_bw_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_bw);
-  YY_BREAK
+       YY_BREAK
 case 219:
 /* rule 219 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_bw_isset != 0) {FAIL("Multiple definition of attribute bw in <surfxml_cluster>");}  surfxml_cluster_bw_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_bw);
-  YY_BREAK
+       YY_BREAK
 case 220:
 /* rule 220 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_lat_isset != 0) {FAIL("Multiple definition of attribute lat in <surfxml_cluster>");} surfxml_cluster_lat_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_lat);
-  YY_BREAK
+       YY_BREAK
 case 221:
 /* rule 221 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_lat_isset != 0) {FAIL("Multiple definition of attribute lat in <surfxml_cluster>");}  surfxml_cluster_lat_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_lat);
-  YY_BREAK
+       YY_BREAK
 case 222:
 /* rule 222 can match eol */
 case 223:
 /* rule 223 can match eol */
 YY_RULE_SETUP
 A_surfxml_cluster_sharing_policy = A_surfxml_cluster_sharing_policy_SHARED;
-  YY_BREAK
+       YY_BREAK
 case 224:
 /* rule 224 can match eol */
 case 225:
 /* rule 225 can match eol */
 YY_RULE_SETUP
 A_surfxml_cluster_sharing_policy = A_surfxml_cluster_sharing_policy_FULLDUPLEX;
-  YY_BREAK
+       YY_BREAK
 case 226:
 /* rule 226 can match eol */
 case 227:
 /* rule 227 can match eol */
 YY_RULE_SETUP
 A_surfxml_cluster_sharing_policy = A_surfxml_cluster_sharing_policy_FATPIPE;
-  YY_BREAK
+       YY_BREAK
 case 228:
 /* rule 228 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_bb_bw_isset != 0) {FAIL("Multiple definition of attribute bb_bw in <surfxml_cluster>");} surfxml_cluster_bb_bw_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_bb_bw);
-  YY_BREAK
+       YY_BREAK
 case 229:
 /* rule 229 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_bb_bw_isset != 0) {FAIL("Multiple definition of attribute bb_bw in <surfxml_cluster>");}  surfxml_cluster_bb_bw_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_bb_bw);
-  YY_BREAK
+       YY_BREAK
 case 230:
 /* rule 230 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_bb_lat_isset != 0) {FAIL("Multiple definition of attribute bb_lat in <surfxml_cluster>");} surfxml_cluster_bb_lat_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_bb_lat);
-  YY_BREAK
+       YY_BREAK
 case 231:
 /* rule 231 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_bb_lat_isset != 0) {FAIL("Multiple definition of attribute bb_lat in <surfxml_cluster>");}  surfxml_cluster_bb_lat_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_bb_lat);
-  YY_BREAK
+       YY_BREAK
 case 232:
 /* rule 232 can match eol */
 case 233:
 /* rule 233 can match eol */
 YY_RULE_SETUP
 A_surfxml_cluster_bb_sharing_policy = A_surfxml_cluster_bb_sharing_policy_SHARED;
-  YY_BREAK
+       YY_BREAK
 case 234:
 /* rule 234 can match eol */
 case 235:
 /* rule 235 can match eol */
 YY_RULE_SETUP
 A_surfxml_cluster_bb_sharing_policy = A_surfxml_cluster_bb_sharing_policy_FATPIPE;
-  YY_BREAK
+       YY_BREAK
 case 236:
 /* rule 236 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_availability_file_isset != 0) {FAIL("Multiple definition of attribute availability_file in <surfxml_cluster>");} surfxml_cluster_availability_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_availability_file);
-  YY_BREAK
+       YY_BREAK
 case 237:
 /* rule 237 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_availability_file_isset != 0) {FAIL("Multiple definition of attribute availability_file in <surfxml_cluster>");}  surfxml_cluster_availability_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_availability_file);
-  YY_BREAK
+       YY_BREAK
 case 238:
 /* rule 238 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_cluster>");} surfxml_cluster_state_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_state_file);
-  YY_BREAK
+       YY_BREAK
 case 239:
 /* rule 239 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_cluster>");}  surfxml_cluster_state_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_state_file);
-  YY_BREAK
+       YY_BREAK
 case 240:
 /* rule 240 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_router_id_isset != 0) {FAIL("Multiple definition of attribute router_id in <surfxml_cluster>");} surfxml_cluster_router_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_cluster_router_id);
-  YY_BREAK
+       YY_BREAK
 case 241:
 /* rule 241 can match eol */
 YY_RULE_SETUP
 if (surfxml_cluster_router_id_isset != 0) {FAIL("Multiple definition of attribute router_id in <surfxml_cluster>");}  surfxml_cluster_router_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_cluster_router_id);
-  YY_BREAK
+       YY_BREAK
 case 242:
 YY_RULE_SETUP
 {
@@ -6458,7 +6458,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_cluster_lat) FAIL("Required attribute `lat' not set for `cluster' element.");
   LEAVE; STag_surfxml_cluster();surfxml_pcdata_ix = 0; ENTER(E_surfxml_cluster);
  }
-  YY_BREAK
+       YY_BREAK
 case 243:
 YY_RULE_SETUP
 {
@@ -6476,18 +6476,18 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 244:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of cluster element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 245:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `cluster' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_cluster):
 FAIL("EOF in attribute list of `cluster' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 246:
 /* rule 246 can match eol */
@@ -6502,25 +6502,25 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 247:
 /* rule 247 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</cluster>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 248:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</cluster>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_cluster):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</cluster>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 249:
 /* rule 249 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <peer> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 250:
 /* rule 250 can match eol */
 YY_RULE_SETUP
@@ -6543,88 +6543,88 @@ YY_RULE_SETUP
   surfxml_peer_state_file_isset = 0;
   ENTER(AL_surfxml_peer); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 251:
 /* rule 251 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_peer>");} surfxml_peer_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_id);
-  YY_BREAK
+       YY_BREAK
 case 252:
 /* rule 252 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_peer>");}  surfxml_peer_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_id);
-  YY_BREAK
+       YY_BREAK
 case 253:
 /* rule 253 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_power_isset != 0) {FAIL("Multiple definition of attribute power in <surfxml_peer>");} surfxml_peer_power_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_power);
-  YY_BREAK
+       YY_BREAK
 case 254:
 /* rule 254 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_power_isset != 0) {FAIL("Multiple definition of attribute power in <surfxml_peer>");}  surfxml_peer_power_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_power);
-  YY_BREAK
+       YY_BREAK
 case 255:
 /* rule 255 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_bw_in_isset != 0) {FAIL("Multiple definition of attribute bw_in in <surfxml_peer>");} surfxml_peer_bw_in_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_bw_in);
-  YY_BREAK
+       YY_BREAK
 case 256:
 /* rule 256 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_bw_in_isset != 0) {FAIL("Multiple definition of attribute bw_in in <surfxml_peer>");}  surfxml_peer_bw_in_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_bw_in);
-  YY_BREAK
+       YY_BREAK
 case 257:
 /* rule 257 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_bw_out_isset != 0) {FAIL("Multiple definition of attribute bw_out in <surfxml_peer>");} surfxml_peer_bw_out_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_bw_out);
-  YY_BREAK
+       YY_BREAK
 case 258:
 /* rule 258 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_bw_out_isset != 0) {FAIL("Multiple definition of attribute bw_out in <surfxml_peer>");}  surfxml_peer_bw_out_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_bw_out);
-  YY_BREAK
+       YY_BREAK
 case 259:
 /* rule 259 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_lat_isset != 0) {FAIL("Multiple definition of attribute lat in <surfxml_peer>");} surfxml_peer_lat_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_lat);
-  YY_BREAK
+       YY_BREAK
 case 260:
 /* rule 260 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_lat_isset != 0) {FAIL("Multiple definition of attribute lat in <surfxml_peer>");}  surfxml_peer_lat_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_lat);
-  YY_BREAK
+       YY_BREAK
 case 261:
 /* rule 261 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_coordinates_isset != 0) {FAIL("Multiple definition of attribute coordinates in <surfxml_peer>");} surfxml_peer_coordinates_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_coordinates);
-  YY_BREAK
+       YY_BREAK
 case 262:
 /* rule 262 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_coordinates_isset != 0) {FAIL("Multiple definition of attribute coordinates in <surfxml_peer>");}  surfxml_peer_coordinates_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_coordinates);
-  YY_BREAK
+       YY_BREAK
 case 263:
 /* rule 263 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_availability_file_isset != 0) {FAIL("Multiple definition of attribute availability_file in <surfxml_peer>");} surfxml_peer_availability_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_availability_file);
-  YY_BREAK
+       YY_BREAK
 case 264:
 /* rule 264 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_availability_file_isset != 0) {FAIL("Multiple definition of attribute availability_file in <surfxml_peer>");}  surfxml_peer_availability_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_availability_file);
-  YY_BREAK
+       YY_BREAK
 case 265:
 /* rule 265 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_peer>");} surfxml_peer_state_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_peer_state_file);
-  YY_BREAK
+       YY_BREAK
 case 266:
 /* rule 266 can match eol */
 YY_RULE_SETUP
 if (surfxml_peer_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_peer>");}  surfxml_peer_state_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_peer_state_file);
-  YY_BREAK
+       YY_BREAK
 case 267:
 YY_RULE_SETUP
 {
@@ -6635,7 +6635,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_peer_lat) FAIL("Required attribute `lat' not set for `peer' element.");
   LEAVE; STag_surfxml_peer();surfxml_pcdata_ix = 0; ENTER(E_surfxml_peer);
  }
-  YY_BREAK
+       YY_BREAK
 case 268:
 YY_RULE_SETUP
 {
@@ -6651,18 +6651,18 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 269:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of peer element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 270:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `peer' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_peer):
 FAIL("EOF in attribute list of `peer' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 271:
 /* rule 271 can match eol */
@@ -6677,25 +6677,25 @@ YY_RULE_SETUP
    case S_surfxml_include: case S_surfxml_include_2: case S_surfxml_include_1: SET(S_surfxml_include_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 272:
 /* rule 272 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</peer>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 273:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</peer>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_peer):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</peer>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 274:
 /* rule 274 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <router> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 275:
 /* rule 275 can match eol */
 YY_RULE_SETUP
@@ -6706,35 +6706,35 @@ YY_RULE_SETUP
   surfxml_router_coordinates_isset = 0;
   ENTER(AL_surfxml_router); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 276:
 /* rule 276 can match eol */
 YY_RULE_SETUP
 if (surfxml_router_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_router>");} surfxml_router_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_router_id);
-  YY_BREAK
+       YY_BREAK
 case 277:
 /* rule 277 can match eol */
 YY_RULE_SETUP
 if (surfxml_router_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_router>");}  surfxml_router_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_router_id);
-  YY_BREAK
+       YY_BREAK
 case 278:
 /* rule 278 can match eol */
 YY_RULE_SETUP
 if (surfxml_router_coordinates_isset != 0) {FAIL("Multiple definition of attribute coordinates in <surfxml_router>");} surfxml_router_coordinates_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_router_coordinates);
-  YY_BREAK
+       YY_BREAK
 case 279:
 /* rule 279 can match eol */
 YY_RULE_SETUP
 if (surfxml_router_coordinates_isset != 0) {FAIL("Multiple definition of attribute coordinates in <surfxml_router>");}  surfxml_router_coordinates_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_router_coordinates);
-  YY_BREAK
+       YY_BREAK
 case 280:
 YY_RULE_SETUP
 {
   if (!AX_surfxml_router_id) FAIL("Required attribute `id' not set for `router' element.");
   LEAVE; STag_surfxml_router();surfxml_pcdata_ix = 0; ENTER(E_surfxml_router);
  }
-  YY_BREAK
+       YY_BREAK
 case 281:
 YY_RULE_SETUP
 {
@@ -6744,18 +6744,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_11: case S_surfxml_AS_10: case S_surfxml_AS: SET(S_surfxml_AS_11); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 282:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of router element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 283:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `router' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_router):
 FAIL("EOF in attribute list of `router' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 284:
 /* rule 284 can match eol */
@@ -6768,25 +6768,25 @@ YY_RULE_SETUP
    case S_surfxml_AS_11: case S_surfxml_AS_10: case S_surfxml_AS: SET(S_surfxml_AS_11); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 285:
 /* rule 285 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</router>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 286:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</router>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_router):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</router>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 287:
 /* rule 287 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <link> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 288:
 /* rule 288 can match eol */
 YY_RULE_SETUP
@@ -6809,103 +6809,103 @@ YY_RULE_SETUP
   surfxml_link_sharing_policy_isset = 0;
   ENTER(AL_surfxml_link); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 289:
 /* rule 289 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_link>");} surfxml_link_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_link_id);
-  YY_BREAK
+       YY_BREAK
 case 290:
 /* rule 290 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_link>");}  surfxml_link_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_link_id);
-  YY_BREAK
+       YY_BREAK
 case 291:
 /* rule 291 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_bandwidth_isset != 0) {FAIL("Multiple definition of attribute bandwidth in <surfxml_link>");} surfxml_link_bandwidth_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_link_bandwidth);
-  YY_BREAK
+       YY_BREAK
 case 292:
 /* rule 292 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_bandwidth_isset != 0) {FAIL("Multiple definition of attribute bandwidth in <surfxml_link>");}  surfxml_link_bandwidth_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_link_bandwidth);
-  YY_BREAK
+       YY_BREAK
 case 293:
 /* rule 293 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_bandwidth_file_isset != 0) {FAIL("Multiple definition of attribute bandwidth_file in <surfxml_link>");} surfxml_link_bandwidth_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_link_bandwidth_file);
-  YY_BREAK
+       YY_BREAK
 case 294:
 /* rule 294 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_bandwidth_file_isset != 0) {FAIL("Multiple definition of attribute bandwidth_file in <surfxml_link>");}  surfxml_link_bandwidth_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_link_bandwidth_file);
-  YY_BREAK
+       YY_BREAK
 case 295:
 /* rule 295 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_latency_isset != 0) {FAIL("Multiple definition of attribute latency in <surfxml_link>");} surfxml_link_latency_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_link_latency);
-  YY_BREAK
+       YY_BREAK
 case 296:
 /* rule 296 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_latency_isset != 0) {FAIL("Multiple definition of attribute latency in <surfxml_link>");}  surfxml_link_latency_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_link_latency);
-  YY_BREAK
+       YY_BREAK
 case 297:
 /* rule 297 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_latency_file_isset != 0) {FAIL("Multiple definition of attribute latency_file in <surfxml_link>");} surfxml_link_latency_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_link_latency_file);
-  YY_BREAK
+       YY_BREAK
 case 298:
 /* rule 298 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_latency_file_isset != 0) {FAIL("Multiple definition of attribute latency_file in <surfxml_link>");}  surfxml_link_latency_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_link_latency_file);
-  YY_BREAK
+       YY_BREAK
 case 299:
 /* rule 299 can match eol */
 case 300:
 /* rule 300 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_state = A_surfxml_link_state_ON;
-  YY_BREAK
+       YY_BREAK
 case 301:
 /* rule 301 can match eol */
 case 302:
 /* rule 302 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_state = A_surfxml_link_state_OFF;
-  YY_BREAK
+       YY_BREAK
 case 303:
 /* rule 303 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_link>");} surfxml_link_state_file_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_link_state_file);
-  YY_BREAK
+       YY_BREAK
 case 304:
 /* rule 304 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_state_file_isset != 0) {FAIL("Multiple definition of attribute state_file in <surfxml_link>");}  surfxml_link_state_file_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_link_state_file);
-  YY_BREAK
+       YY_BREAK
 case 305:
 /* rule 305 can match eol */
 case 306:
 /* rule 306 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_SHARED;
-  YY_BREAK
+       YY_BREAK
 case 307:
 /* rule 307 can match eol */
 case 308:
 /* rule 308 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FATPIPE;
-  YY_BREAK
+       YY_BREAK
 case 309:
 /* rule 309 can match eol */
 case 310:
 /* rule 310 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_sharing_policy = A_surfxml_link_sharing_policy_FULLDUPLEX;
-  YY_BREAK
+       YY_BREAK
 case 311:
 YY_RULE_SETUP
 {
@@ -6913,7 +6913,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_link_bandwidth) FAIL("Required attribute `bandwidth' not set for `link' element.");
   LEAVE; STag_surfxml_link();surfxml_pcdata_ix = 0; ENTER(S_surfxml_link);
  }
-  YY_BREAK
+       YY_BREAK
 case 312:
 YY_RULE_SETUP
 {
@@ -6925,18 +6925,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_2: case S_surfxml_AS_3: SET(S_surfxml_AS_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 313:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of link element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 314:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `link' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_link):
 FAIL("EOF in attribute list of `link' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 315:
 /* rule 315 can match eol */
@@ -6950,27 +6950,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_2: case S_surfxml_AS_3: SET(S_surfxml_AS_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 316:
 /* rule 316 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</link>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 317:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</link>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_link):
 case YY_STATE_EOF(S_surfxml_link_2):
 case YY_STATE_EOF(S_surfxml_link):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</link>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 318:
 /* rule 318 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <route> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 319:
 /* rule 319 can match eol */
 YY_RULE_SETUP
@@ -6983,42 +6983,42 @@ YY_RULE_SETUP
   surfxml_route_symmetrical_isset = 0;
   ENTER(AL_surfxml_route); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 320:
 /* rule 320 can match eol */
 YY_RULE_SETUP
 if (surfxml_route_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_route>");} surfxml_route_src_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_route_src);
-  YY_BREAK
+       YY_BREAK
 case 321:
 /* rule 321 can match eol */
 YY_RULE_SETUP
 if (surfxml_route_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_route>");}  surfxml_route_src_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_route_src);
-  YY_BREAK
+       YY_BREAK
 case 322:
 /* rule 322 can match eol */
 YY_RULE_SETUP
 if (surfxml_route_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_route>");} surfxml_route_dst_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_route_dst);
-  YY_BREAK
+       YY_BREAK
 case 323:
 /* rule 323 can match eol */
 YY_RULE_SETUP
 if (surfxml_route_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_route>");}  surfxml_route_dst_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_route_dst);
-  YY_BREAK
+       YY_BREAK
 case 324:
 /* rule 324 can match eol */
 case 325:
 /* rule 325 can match eol */
 YY_RULE_SETUP
 A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_YES;
-  YY_BREAK
+       YY_BREAK
 case 326:
 /* rule 326 can match eol */
 case 327:
 /* rule 327 can match eol */
 YY_RULE_SETUP
 A_surfxml_route_symmetrical = A_surfxml_route_symmetrical_NO;
-  YY_BREAK
+       YY_BREAK
 case 328:
 YY_RULE_SETUP
 {
@@ -7026,7 +7026,7 @@ YY_RULE_SETUP
   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);
  }
-  YY_BREAK
+       YY_BREAK
 case 329:
 YY_RULE_SETUP
 {
@@ -7037,18 +7037,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_12: case S_surfxml_AS_9: case S_surfxml_AS_11: case S_surfxml_AS_13: case S_surfxml_AS: SET(S_surfxml_AS_13); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 330:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of route element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 331:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `route' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_route):
 FAIL("EOF in attribute list of `route' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 332:
 /* rule 332 can match eol */
@@ -7061,27 +7061,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_12: case S_surfxml_AS_9: case S_surfxml_AS_11: case S_surfxml_AS_13: case S_surfxml_AS: SET(S_surfxml_AS_13); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 333:
 /* rule 333 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</route>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 334:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</route>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_route):
 case YY_STATE_EOF(S_surfxml_route_2):
 case YY_STATE_EOF(E_surfxml_route):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</route>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 335:
 /* rule 335 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <ASroute> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 336:
 /* rule 336 can match eol */
 YY_RULE_SETUP
@@ -7098,62 +7098,62 @@ YY_RULE_SETUP
   surfxml_ASroute_symmetrical_isset = 0;
   ENTER(AL_surfxml_ASroute); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 337:
 /* rule 337 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_ASroute>");} surfxml_ASroute_src_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_ASroute_src);
-  YY_BREAK
+       YY_BREAK
 case 338:
 /* rule 338 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_ASroute>");}  surfxml_ASroute_src_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_ASroute_src);
-  YY_BREAK
+       YY_BREAK
 case 339:
 /* rule 339 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_ASroute>");} surfxml_ASroute_dst_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_ASroute_dst);
-  YY_BREAK
+       YY_BREAK
 case 340:
 /* rule 340 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_ASroute>");}  surfxml_ASroute_dst_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_ASroute_dst);
-  YY_BREAK
+       YY_BREAK
 case 341:
 /* rule 341 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_gw_src_isset != 0) {FAIL("Multiple definition of attribute gw_src in <surfxml_ASroute>");} surfxml_ASroute_gw_src_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_ASroute_gw_src);
-  YY_BREAK
+       YY_BREAK
 case 342:
 /* rule 342 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_gw_src_isset != 0) {FAIL("Multiple definition of attribute gw_src in <surfxml_ASroute>");}  surfxml_ASroute_gw_src_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_ASroute_gw_src);
-  YY_BREAK
+       YY_BREAK
 case 343:
 /* rule 343 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_gw_dst_isset != 0) {FAIL("Multiple definition of attribute gw_dst in <surfxml_ASroute>");} surfxml_ASroute_gw_dst_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_ASroute_gw_dst);
-  YY_BREAK
+       YY_BREAK
 case 344:
 /* rule 344 can match eol */
 YY_RULE_SETUP
 if (surfxml_ASroute_gw_dst_isset != 0) {FAIL("Multiple definition of attribute gw_dst in <surfxml_ASroute>");}  surfxml_ASroute_gw_dst_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_ASroute_gw_dst);
-  YY_BREAK
+       YY_BREAK
 case 345:
 /* rule 345 can match eol */
 case 346:
 /* rule 346 can match eol */
 YY_RULE_SETUP
 A_surfxml_ASroute_symmetrical = A_surfxml_ASroute_symmetrical_YES;
-  YY_BREAK
+       YY_BREAK
 case 347:
 /* rule 347 can match eol */
 case 348:
 /* rule 348 can match eol */
 YY_RULE_SETUP
 A_surfxml_ASroute_symmetrical = A_surfxml_ASroute_symmetrical_NO;
-  YY_BREAK
+       YY_BREAK
 case 349:
 YY_RULE_SETUP
 {
@@ -7163,7 +7163,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_ASroute_gw_dst) FAIL("Required attribute `gw_dst' not set for `ASroute' element.");
   LEAVE; STag_surfxml_ASroute();surfxml_pcdata_ix = 0; ENTER(S_surfxml_ASroute);
  }
-  YY_BREAK
+       YY_BREAK
 case 350:
 YY_RULE_SETUP
 {
@@ -7176,18 +7176,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_1: case S_surfxml_AS_5: case S_surfxml_AS: case S_surfxml_AS_6: case S_surfxml_AS_3: SET(S_surfxml_AS_6); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 351:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of ASroute element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 352:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `ASroute' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_ASroute):
 FAIL("EOF in attribute list of `ASroute' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 353:
 /* rule 353 can match eol */
@@ -7200,27 +7200,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_1: case S_surfxml_AS_5: case S_surfxml_AS: case S_surfxml_AS_6: case S_surfxml_AS_3: SET(S_surfxml_AS_6); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 354:
 /* rule 354 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</ASroute>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 355:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</ASroute>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_ASroute):
 case YY_STATE_EOF(S_surfxml_ASroute):
 case YY_STATE_EOF(S_surfxml_ASroute_2):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</ASroute>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 356:
 /* rule 356 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <link_ctn> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 357:
 /* rule 357 can match eol */
 YY_RULE_SETUP
@@ -7231,46 +7231,46 @@ YY_RULE_SETUP
   surfxml_link_ctn_direction_isset = 0;
   ENTER(AL_surfxml_link_ctn); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 358:
 /* rule 358 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_ctn_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_link_ctn>");} surfxml_link_ctn_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_link_ctn_id);
-  YY_BREAK
+       YY_BREAK
 case 359:
 /* rule 359 can match eol */
 YY_RULE_SETUP
 if (surfxml_link_ctn_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_link_ctn>");}  surfxml_link_ctn_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_link_ctn_id);
-  YY_BREAK
+       YY_BREAK
 case 360:
 /* rule 360 can match eol */
 case 361:
 /* rule 361 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_UP;
-  YY_BREAK
+       YY_BREAK
 case 362:
 /* rule 362 can match eol */
 case 363:
 /* rule 363 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_DOWN;
-  YY_BREAK
+       YY_BREAK
 case 364:
 /* rule 364 can match eol */
 case 365:
 /* rule 365 can match eol */
 YY_RULE_SETUP
 A_surfxml_link_ctn_direction = A_surfxml_link_ctn_direction_NONE;
-  YY_BREAK
+       YY_BREAK
 case 366:
 YY_RULE_SETUP
 {
   if (!AX_surfxml_link_ctn_id) FAIL("Required attribute `id' not set for `link_ctn' element.");
   LEAVE; STag_surfxml_link_ctn();surfxml_pcdata_ix = 0; ENTER(E_surfxml_link_ctn);
  }
-  YY_BREAK
+       YY_BREAK
 case 367:
 YY_RULE_SETUP
 {
@@ -7283,18 +7283,18 @@ YY_RULE_SETUP
    case S_surfxml_ASroute: case S_surfxml_ASroute_1: case S_surfxml_ASroute_2: SET(S_surfxml_ASroute_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 368:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of link_ctn element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 369:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `link_ctn' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_link_ctn):
 FAIL("EOF in attribute list of `link_ctn' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 370:
 /* rule 370 can match eol */
@@ -7310,25 +7310,25 @@ YY_RULE_SETUP
    case S_surfxml_ASroute: case S_surfxml_ASroute_1: case S_surfxml_ASroute_2: SET(S_surfxml_ASroute_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 371:
 /* rule 371 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</link_ctn>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 372:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</link_ctn>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_link_ctn):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</link_ctn>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 373:
 /* rule 373 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <bypassRoute> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 374:
 /* rule 374 can match eol */
 YY_RULE_SETUP
@@ -7339,28 +7339,28 @@ YY_RULE_SETUP
   surfxml_bypassRoute_dst_isset = 0;
   ENTER(AL_surfxml_bypassRoute); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 375:
 /* rule 375 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassRoute_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_bypassRoute>");} surfxml_bypassRoute_src_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_bypassRoute_src);
-  YY_BREAK
+       YY_BREAK
 case 376:
 /* rule 376 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassRoute_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_bypassRoute>");}  surfxml_bypassRoute_src_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_bypassRoute_src);
-  YY_BREAK
+       YY_BREAK
 case 377:
 /* rule 377 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassRoute_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_bypassRoute>");} surfxml_bypassRoute_dst_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_bypassRoute_dst);
-  YY_BREAK
+       YY_BREAK
 case 378:
 /* rule 378 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassRoute_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_bypassRoute>");}  surfxml_bypassRoute_dst_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_bypassRoute_dst);
-  YY_BREAK
+       YY_BREAK
 case 379:
 YY_RULE_SETUP
 {
@@ -7368,7 +7368,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_bypassRoute_dst) FAIL("Required attribute `dst' not set for `bypassRoute' element.");
   LEAVE; STag_surfxml_bypassRoute();surfxml_pcdata_ix = 0; ENTER(S_surfxml_bypassRoute);
  }
-  YY_BREAK
+       YY_BREAK
 case 380:
 YY_RULE_SETUP
 {
@@ -7379,18 +7379,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_12: case S_surfxml_AS_9: case S_surfxml_AS_11: case S_surfxml_AS_13: case S_surfxml_AS: SET(S_surfxml_AS_13); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 381:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of bypassRoute element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 382:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `bypassRoute' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_bypassRoute):
 FAIL("EOF in attribute list of `bypassRoute' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 383:
 /* rule 383 can match eol */
@@ -7403,27 +7403,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_12: case S_surfxml_AS_9: case S_surfxml_AS_11: case S_surfxml_AS_13: case S_surfxml_AS: SET(S_surfxml_AS_13); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 384:
 /* rule 384 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</bypassRoute>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 385:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</bypassRoute>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_bypassRoute):
 case YY_STATE_EOF(S_surfxml_bypassRoute_2):
 case YY_STATE_EOF(E_surfxml_bypassRoute):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</bypassRoute>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 386:
 /* rule 386 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <bypassASroute> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 387:
 /* rule 387 can match eol */
 YY_RULE_SETUP
@@ -7438,48 +7438,48 @@ YY_RULE_SETUP
   surfxml_bypassASroute_gw_dst_isset = 0;
   ENTER(AL_surfxml_bypassASroute); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 388:
 /* rule 388 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_bypassASroute>");} surfxml_bypassASroute_src_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_bypassASroute_src);
-  YY_BREAK
+       YY_BREAK
 case 389:
 /* rule 389 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_src_isset != 0) {FAIL("Multiple definition of attribute src in <surfxml_bypassASroute>");}  surfxml_bypassASroute_src_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_bypassASroute_src);
-  YY_BREAK
+       YY_BREAK
 case 390:
 /* rule 390 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_bypassASroute>");} surfxml_bypassASroute_dst_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_bypassASroute_dst);
-  YY_BREAK
+       YY_BREAK
 case 391:
 /* rule 391 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_dst_isset != 0) {FAIL("Multiple definition of attribute dst in <surfxml_bypassASroute>");}  surfxml_bypassASroute_dst_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_bypassASroute_dst);
-  YY_BREAK
+       YY_BREAK
 case 392:
 /* rule 392 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_gw_src_isset != 0) {FAIL("Multiple definition of attribute gw_src in <surfxml_bypassASroute>");} surfxml_bypassASroute_gw_src_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_bypassASroute_gw_src);
-  YY_BREAK
+       YY_BREAK
 case 393:
 /* rule 393 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_gw_src_isset != 0) {FAIL("Multiple definition of attribute gw_src in <surfxml_bypassASroute>");}  surfxml_bypassASroute_gw_src_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_bypassASroute_gw_src);
-  YY_BREAK
+       YY_BREAK
 case 394:
 /* rule 394 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_gw_dst_isset != 0) {FAIL("Multiple definition of attribute gw_dst in <surfxml_bypassASroute>");} surfxml_bypassASroute_gw_dst_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_bypassASroute_gw_dst);
-  YY_BREAK
+       YY_BREAK
 case 395:
 /* rule 395 can match eol */
 YY_RULE_SETUP
 if (surfxml_bypassASroute_gw_dst_isset != 0) {FAIL("Multiple definition of attribute gw_dst in <surfxml_bypassASroute>");}  surfxml_bypassASroute_gw_dst_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_bypassASroute_gw_dst);
-  YY_BREAK
+       YY_BREAK
 case 396:
 YY_RULE_SETUP
 {
@@ -7489,7 +7489,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_bypassASroute_gw_dst) FAIL("Required attribute `gw_dst' not set for `bypassASroute' element.");
   LEAVE; STag_surfxml_bypassASroute();surfxml_pcdata_ix = 0; ENTER(S_surfxml_bypassASroute);
  }
-  YY_BREAK
+       YY_BREAK
 case 397:
 YY_RULE_SETUP
 {
@@ -7502,18 +7502,18 @@ YY_RULE_SETUP
    case S_surfxml_AS_1: case S_surfxml_AS_5: case S_surfxml_AS: case S_surfxml_AS_6: case S_surfxml_AS_3: SET(S_surfxml_AS_6); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 398:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of bypassASroute element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 399:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `bypassASroute' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_bypassASroute):
 FAIL("EOF in attribute list of `bypassASroute' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 400:
 /* rule 400 can match eol */
@@ -7526,27 +7526,27 @@ YY_RULE_SETUP
    case S_surfxml_AS_1: case S_surfxml_AS_5: case S_surfxml_AS: case S_surfxml_AS_6: case S_surfxml_AS_3: SET(S_surfxml_AS_6); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 401:
 /* rule 401 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</bypassASroute>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 402:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</bypassASroute>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_bypassASroute_2):
 case YY_STATE_EOF(E_surfxml_bypassASroute):
 case YY_STATE_EOF(S_surfxml_bypassASroute):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</bypassASroute>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 403:
 /* rule 403 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <process> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 404:
 /* rule 404 can match eol */
 YY_RULE_SETUP
@@ -7561,48 +7561,48 @@ YY_RULE_SETUP
   surfxml_process_kill_time_isset = 0;
   ENTER(AL_surfxml_process); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 405:
 /* rule 405 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_host_isset != 0) {FAIL("Multiple definition of attribute host in <surfxml_process>");} surfxml_process_host_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_process_host);
-  YY_BREAK
+       YY_BREAK
 case 406:
 /* rule 406 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_host_isset != 0) {FAIL("Multiple definition of attribute host in <surfxml_process>");}  surfxml_process_host_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_process_host);
-  YY_BREAK
+       YY_BREAK
 case 407:
 /* rule 407 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_function_isset != 0) {FAIL("Multiple definition of attribute function in <surfxml_process>");} surfxml_process_function_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_process_function);
-  YY_BREAK
+       YY_BREAK
 case 408:
 /* rule 408 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_function_isset != 0) {FAIL("Multiple definition of attribute function in <surfxml_process>");}  surfxml_process_function_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_process_function);
-  YY_BREAK
+       YY_BREAK
 case 409:
 /* rule 409 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_start_time_isset != 0) {FAIL("Multiple definition of attribute start_time in <surfxml_process>");} surfxml_process_start_time_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_process_start_time);
-  YY_BREAK
+       YY_BREAK
 case 410:
 /* rule 410 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_start_time_isset != 0) {FAIL("Multiple definition of attribute start_time in <surfxml_process>");}  surfxml_process_start_time_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_process_start_time);
-  YY_BREAK
+       YY_BREAK
 case 411:
 /* rule 411 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_kill_time_isset != 0) {FAIL("Multiple definition of attribute kill_time in <surfxml_process>");} surfxml_process_kill_time_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_process_kill_time);
-  YY_BREAK
+       YY_BREAK
 case 412:
 /* rule 412 can match eol */
 YY_RULE_SETUP
 if (surfxml_process_kill_time_isset != 0) {FAIL("Multiple definition of attribute kill_time in <surfxml_process>");}  surfxml_process_kill_time_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_process_kill_time);
-  YY_BREAK
+       YY_BREAK
 case 413:
 YY_RULE_SETUP
 {
@@ -7610,7 +7610,7 @@ YY_RULE_SETUP
   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);
  }
-  YY_BREAK
+       YY_BREAK
 case 414:
 YY_RULE_SETUP
 {
@@ -7621,18 +7621,18 @@ YY_RULE_SETUP
    case S_surfxml_platform_6: case S_surfxml_platform_4: case S_surfxml_platform_1: case S_surfxml_platform: case S_surfxml_platform_8: case S_surfxml_platform_7: case S_surfxml_platform_3: SET(S_surfxml_platform_8); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 415:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of process element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 416:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `process' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_process):
 FAIL("EOF in attribute list of `process' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 417:
 /* rule 417 can match eol */
@@ -7645,27 +7645,27 @@ YY_RULE_SETUP
    case S_surfxml_platform_6: case S_surfxml_platform_4: case S_surfxml_platform_1: case S_surfxml_platform: case S_surfxml_platform_8: case S_surfxml_platform_7: case S_surfxml_platform_3: SET(S_surfxml_platform_8); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 418:
 /* rule 418 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</process>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 419:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</process>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_process):
 case YY_STATE_EOF(S_surfxml_process):
 case YY_STATE_EOF(S_surfxml_process_2):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</process>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 420:
 /* rule 420 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <argument> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 421:
 /* rule 421 can match eol */
 YY_RULE_SETUP
@@ -7674,25 +7674,25 @@ YY_RULE_SETUP
   surfxml_argument_value_isset = 0;
   ENTER(AL_surfxml_argument); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 422:
 /* rule 422 can match eol */
 YY_RULE_SETUP
 if (surfxml_argument_value_isset != 0) {FAIL("Multiple definition of attribute value in <surfxml_argument>");} surfxml_argument_value_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_argument_value);
-  YY_BREAK
+       YY_BREAK
 case 423:
 /* rule 423 can match eol */
 YY_RULE_SETUP
 if (surfxml_argument_value_isset != 0) {FAIL("Multiple definition of attribute value in <surfxml_argument>");}  surfxml_argument_value_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_argument_value);
-  YY_BREAK
+       YY_BREAK
 case 424:
 YY_RULE_SETUP
 {
   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);
  }
-  YY_BREAK
+       YY_BREAK
 case 425:
 YY_RULE_SETUP
 {
@@ -7702,18 +7702,18 @@ YY_RULE_SETUP
    case S_surfxml_process_1: case S_surfxml_process: case S_surfxml_process_2: SET(S_surfxml_process_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 426:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of argument element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 427:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `argument' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_argument):
 FAIL("EOF in attribute list of `argument' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 428:
 /* rule 428 can match eol */
@@ -7726,25 +7726,25 @@ YY_RULE_SETUP
    case S_surfxml_process_1: case S_surfxml_process: case S_surfxml_process_2: SET(S_surfxml_process_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 429:
 /* rule 429 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</argument>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 430:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</argument>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_argument):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</argument>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 case 431:
 /* rule 431 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <config> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 432:
 /* rule 432 can match eol */
 YY_RULE_SETUP
@@ -7753,24 +7753,24 @@ YY_RULE_SETUP
   surfxml_config_id_isset = 0;
   ENTER(AL_surfxml_config); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 433:
 /* rule 433 can match eol */
 YY_RULE_SETUP
 if (surfxml_config_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_config>");} surfxml_config_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_config_id);
-  YY_BREAK
+       YY_BREAK
 case 434:
 /* rule 434 can match eol */
 YY_RULE_SETUP
 if (surfxml_config_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_config>");}  surfxml_config_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_config_id);
-  YY_BREAK
+       YY_BREAK
 case 435:
 YY_RULE_SETUP
 {
   LEAVE; STag_surfxml_config();surfxml_pcdata_ix = 0; ENTER(S_surfxml_config);
  }
-  YY_BREAK
+       YY_BREAK
 case 436:
 YY_RULE_SETUP
 {
@@ -7779,18 +7779,18 @@ YY_RULE_SETUP
    case S_surfxml_platform_2: case S_surfxml_platform: case S_surfxml_platform_3: SET(S_surfxml_platform_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 437:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of config element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 438:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `config' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_config):
 FAIL("EOF in attribute list of `config' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 439:
 /* rule 439 can match eol */
@@ -7803,21 +7803,21 @@ YY_RULE_SETUP
    case S_surfxml_platform_2: case S_surfxml_platform: case S_surfxml_platform_3: SET(S_surfxml_platform_3); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 440:
 /* rule 440 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</config>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 441:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</config>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(S_surfxml_config):
 case YY_STATE_EOF(S_surfxml_config_2):
 case YY_STATE_EOF(E_surfxml_config):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</config>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 /* <!-- <!ATTLIST prop key CDATA #REQUIRED> -->
   * <!-- <!ATTLIST prop key CDATA #REQUIRED> -->  */
@@ -7825,7 +7825,7 @@ case 442:
 /* rule 442 can match eol */
 YY_RULE_SETUP
 FAIL("Starting tag <prop> is not allowed here.");
-  YY_BREAK
+       YY_BREAK
 case 443:
 /* rule 443 can match eol */
 YY_RULE_SETUP
@@ -7836,28 +7836,28 @@ YY_RULE_SETUP
   surfxml_prop_value_isset = 0;
   ENTER(AL_surfxml_prop); pushbuffer(0);
   }
-  YY_BREAK
+       YY_BREAK
 
 case 444:
 /* rule 444 can match eol */
 YY_RULE_SETUP
 if (surfxml_prop_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_prop>");} surfxml_prop_id_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_prop_id);
-  YY_BREAK
+       YY_BREAK
 case 445:
 /* rule 445 can match eol */
 YY_RULE_SETUP
 if (surfxml_prop_id_isset != 0) {FAIL("Multiple definition of attribute id in <surfxml_prop>");}  surfxml_prop_id_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_prop_id);
-  YY_BREAK
+       YY_BREAK
 case 446:
 /* rule 446 can match eol */
 YY_RULE_SETUP
 if (surfxml_prop_value_isset != 0) {FAIL("Multiple definition of attribute value in <surfxml_prop>");} surfxml_prop_value_isset = 1; ENTER(VALUE1); BUFFERSET(AX_surfxml_prop_value);
-  YY_BREAK
+       YY_BREAK
 case 447:
 /* rule 447 can match eol */
 YY_RULE_SETUP
 if (surfxml_prop_value_isset != 0) {FAIL("Multiple definition of attribute value in <surfxml_prop>");}  surfxml_prop_value_isset = 1; ENTER(VALUE2); BUFFERSET(AX_surfxml_prop_value);
-  YY_BREAK
+       YY_BREAK
 case 448:
 YY_RULE_SETUP
 {
@@ -7865,7 +7865,7 @@ YY_RULE_SETUP
   if (!AX_surfxml_prop_value) FAIL("Required attribute `value' not set for `prop' element.");
   LEAVE; STag_surfxml_prop();surfxml_pcdata_ix = 0; ENTER(E_surfxml_prop);
  }
-  YY_BREAK
+       YY_BREAK
 case 449:
 YY_RULE_SETUP
 {
@@ -7882,18 +7882,18 @@ YY_RULE_SETUP
    case S_surfxml_link_1: case S_surfxml_link_2: case S_surfxml_link: SET(S_surfxml_link_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 450:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c' in attribute list of prop element.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 451:
 YY_RULE_SETUP
 FAIL("Bad attribute `%s' in `prop' element start tag.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(AL_surfxml_prop):
 FAIL("EOF in attribute list of `prop' element.");
-  YY_BREAK
+       YY_BREAK
 
 case 452:
 /* rule 452 can match eol */
@@ -7912,29 +7912,29 @@ YY_RULE_SETUP
    case S_surfxml_link_1: case S_surfxml_link_2: case S_surfxml_link: SET(S_surfxml_link_2); break;
   }
  }
-  YY_BREAK
+       YY_BREAK
 case 453:
 /* rule 453 can match eol */
 YY_RULE_SETUP
 FAIL("Unexpected end-tag `%s': `</prop>' expected.",surf_parse_text);
-  YY_BREAK
+       YY_BREAK
 case 454:
 YY_RULE_SETUP
 FAIL("Unexpected character `%c': `</prop>' expected.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(E_surfxml_prop):
 if(!ETag_surfxml_include_state()) FAIL("Premature EOF: `</prop>' expected.");
-  YY_BREAK
+       YY_BREAK
 
 /* EPILOG: after the root element. */
 
 case 455:
 YY_RULE_SETUP
 {SET(PROLOG); yyless(0); CLEANUP; return -1;}
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(EPILOG):
 SUCCEED;
-  YY_BREAK
+       YY_BREAK
 
 /* CHARACTER DATA. */
 
@@ -7942,32 +7942,32 @@ SUCCEED;
 case 456:
 YY_RULE_SETUP
 BUFFERPUTC('&');
-  YY_BREAK
+       YY_BREAK
 case 457:
 YY_RULE_SETUP
 BUFFERPUTC('<');
-  YY_BREAK
+       YY_BREAK
 case 458:
 YY_RULE_SETUP
 BUFFERPUTC('>');
-  YY_BREAK
+       YY_BREAK
 case 459:
 YY_RULE_SETUP
 BUFFERPUTC('\'');
-  YY_BREAK
+       YY_BREAK
 case 460:
 YY_RULE_SETUP
 BUFFERPUTC('"');
-  YY_BREAK
+       YY_BREAK
 /* Character entities. */
 case 461:
 YY_RULE_SETUP
 BUFFERPUTC((unsigned char)atoi(surf_parse_text+2));
-  YY_BREAK
+       YY_BREAK
 case 462:
 YY_RULE_SETUP
 BUFFERPUTC((unsigned char)strtol(surf_parse_text+3,NULL,16));
-  YY_BREAK
+       YY_BREAK
 
 case 463:
 /* rule 463 can match eol */
@@ -7979,55 +7979,55 @@ case 466:
 /* rule 466 can match eol */
 YY_RULE_SETUP
 BUFFERPUTC('\n');
-  YY_BREAK
+       YY_BREAK
 
 case 467:
 YY_RULE_SETUP
 ENTER(CDATA);
-  YY_BREAK
+       YY_BREAK
 case 468:
 YY_RULE_SETUP
 FAIL("Unexpected `]""]>' in character data.");
-  YY_BREAK
+       YY_BREAK
 
 case 469:
 YY_RULE_SETUP
 BUFFERDONE; LEAVE;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(VALUE1):
 FAIL("EOF in literal (\"'\" expected).");
-  YY_BREAK
+       YY_BREAK
 
 case 470:
 YY_RULE_SETUP
 BUFFERDONE; LEAVE;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(VALUE2):
 FAIL("EOF in literal (`\"' expected).");
-  YY_BREAK
+       YY_BREAK
 
 case 471:
 /* rule 471 can match eol */
 YY_RULE_SETUP
 BUFFERPUTC(surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case 472:
 YY_RULE_SETUP
 FAIL("Spurious `%c' in character data.",surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 
 case 473:
 YY_RULE_SETUP
 LEAVE;
-  YY_BREAK
-/* "]""]"    BUFFERPUTC(surf_parse_text[0]); BUFFERPUTC(surf_parse_text[1]); */
+       YY_BREAK
+/* "]""]"              BUFFERPUTC(surf_parse_text[0]); BUFFERPUTC(surf_parse_text[1]); */
 case 474:
 YY_RULE_SETUP
 BUFFERPUTC(surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(CDATA):
 FAIL("EOF in CDATA section.");
-  YY_BREAK
+       YY_BREAK
 
 /* Impossible rules to avoid warnings from flex(1). */
 /* Ideally, this should be replaced by code in flexml.pl that
@@ -8037,12 +8037,12 @@ case 475:
 /* rule 475 can match eol */
 YY_RULE_SETUP
 FAIL("Syntax error on character `%c'.", surf_parse_text[0]);
-  YY_BREAK
+       YY_BREAK
 
 case 476:
 YY_RULE_SETUP
 ECHO;
-  YY_BREAK
+       YY_BREAK
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(ROOT_surfxml_platform):
 case YY_STATE_EOF(S_surfxml_platform_2):
@@ -8066,331 +8066,331 @@ case YY_STATE_EOF(S_surfxml_bypassASroute_1):
 case YY_STATE_EOF(S_surfxml_process_1):
 case YY_STATE_EOF(S_surfxml_config_1):
 case YY_STATE_EOF(IMPOSSIBLE):
-  yyterminate();
-
-  case YY_END_OF_BUFFER:
-    {
-    /* Amount of text matched not including the EOB char. */
-    int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
-
-    /* Undo the effects of YY_DO_BEFORE_ACTION. */
-    *yy_cp = (yy_hold_char);
-    YY_RESTORE_YY_MORE_OFFSET
-
-    if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-      {
-      /* We're scanning a new file or input source.  It's
-       * possible that this happened because the user
-       * just pointed surf_parse_in at a new source and called
-       * surf_parse_lex().  If so, then we have to assure
-       * consistency between YY_CURRENT_BUFFER and our
-       * globals.  Here is the right place to do so, because
-       * this is the first action (other than possibly a
-       * back-up) that will match for the new input source.
-       */
-      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-      YY_CURRENT_BUFFER_LVALUE->yy_input_file = surf_parse_in;
-      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-      }
-
-    /* Note that here we test for yy_c_buf_p "<=" to the position
-     * of the first EOB in the buffer, since yy_c_buf_p will
-     * already have been incremented past the NUL character
-     * (since all states make transitions on EOB to the
-     * end-of-buffer state).  Contrast this with the test
-     * in input().
-     */
-    if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-      { /* This was really a NUL. */
-      yy_state_type yy_next_state;
-
-      (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-
-      yy_current_state = yy_get_previous_state(  );
-
-      /* Okay, we're now positioned to make the NUL
-       * transition.  We couldn't have
-       * yy_get_previous_state() go ahead and do it
-       * for us because it doesn't know how to deal
-       * with the possibility of jamming (and we don't
-       * want to build jamming into it because then it
-       * will run more slowly).
-       */
-
-      yy_next_state = yy_try_NUL_trans( yy_current_state );
-
-      yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-
-      if ( yy_next_state )
-        {
-        /* Consume the NUL. */
-        yy_cp = ++(yy_c_buf_p);
-        yy_current_state = yy_next_state;
-        goto yy_match;
-        }
-
-      else
-        {
-        yy_cp = (yy_c_buf_p);
-        goto yy_find_action;
-        }
-      }
-
-    else switch ( yy_get_next_buffer(  ) )
-      {
-      case EOB_ACT_END_OF_FILE:
-        {
-        (yy_did_buffer_switch_on_eof) = 0;
-
-        if ( surf_parse_wrap( ) )
-          {
-          /* Note: because we've taken care in
-           * yy_get_next_buffer() to have set up
-           * surf_parse_text, we can now set up
-           * yy_c_buf_p so that if some total
-           * hoser (like flex itself) wants to
-           * call the scanner after we return the
-           * YY_NULL, it'll still work - another
-           * YY_NULL will get returned.
-           */
-          (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
-
-          yy_act = YY_STATE_EOF(YY_START);
-          goto do_action;
-          }
-
-        else
-          {
-          if ( ! (yy_did_buffer_switch_on_eof) )
-            YY_NEW_FILE;
-          }
-        break;
-        }
-
-      case EOB_ACT_CONTINUE_SCAN:
-        (yy_c_buf_p) =
-          (yytext_ptr) + yy_amount_of_matched_text;
-
-        yy_current_state = yy_get_previous_state(  );
-
-        yy_cp = (yy_c_buf_p);
-        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-        goto yy_match;
-
-      case EOB_ACT_LAST_MATCH:
-        (yy_c_buf_p) =
-        &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
-
-        yy_current_state = yy_get_previous_state(  );
-
-        yy_cp = (yy_c_buf_p);
-        yy_bp = (yytext_ptr) + YY_MORE_ADJ;
-        goto yy_find_action;
-      }
-    break;
-    }
-
-  default:
-    YY_FATAL_ERROR(
-      "fatal flex scanner internal error--no action found" );
-  } /* end of action switch */
-    } /* end of scanning one token */
+       yyterminate();
+
+       case YY_END_OF_BUFFER:
+               {
+               /* Amount of text matched not including the EOB char. */
+               int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+               /* Undo the effects of YY_DO_BEFORE_ACTION. */
+               *yy_cp = (yy_hold_char);
+               YY_RESTORE_YY_MORE_OFFSET
+
+               if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+                       {
+                       /* We're scanning a new file or input source.  It's
+                        * possible that this happened because the user
+                        * just pointed surf_parse_in at a new source and called
+                        * surf_parse_lex().  If so, then we have to assure
+                        * consistency between YY_CURRENT_BUFFER and our
+                        * globals.  Here is the right place to do so, because
+                        * this is the first action (other than possibly a
+                        * back-up) that will match for the new input source.
+                        */
+                       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+                       YY_CURRENT_BUFFER_LVALUE->yy_input_file = surf_parse_in;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+                       }
+
+               /* Note that here we test for yy_c_buf_p "<=" to the position
+                * of the first EOB in the buffer, since yy_c_buf_p will
+                * already have been incremented past the NUL character
+                * (since all states make transitions on EOB to the
+                * end-of-buffer state).  Contrast this with the test
+                * in input().
+                */
+               if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+                       { /* This was really a NUL. */
+                       yy_state_type yy_next_state;
+
+                       (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+                       yy_current_state = yy_get_previous_state(  );
+
+                       /* Okay, we're now positioned to make the NUL
+                        * transition.  We couldn't have
+                        * yy_get_previous_state() go ahead and do it
+                        * for us because it doesn't know how to deal
+                        * with the possibility of jamming (and we don't
+                        * want to build jamming into it because then it
+                        * will run more slowly).
+                        */
+
+                       yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+                       yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+                       if ( yy_next_state )
+                               {
+                               /* Consume the NUL. */
+                               yy_cp = ++(yy_c_buf_p);
+                               yy_current_state = yy_next_state;
+                               goto yy_match;
+                               }
+
+                       else
+                               {
+                               yy_cp = (yy_c_buf_p);
+                               goto yy_find_action;
+                               }
+                       }
+
+               else switch ( yy_get_next_buffer(  ) )
+                       {
+                       case EOB_ACT_END_OF_FILE:
+                               {
+                               (yy_did_buffer_switch_on_eof) = 0;
+
+                               if ( surf_parse_wrap( ) )
+                                       {
+                                       /* Note: because we've taken care in
+                                        * yy_get_next_buffer() to have set up
+                                        * surf_parse_text, we can now set up
+                                        * yy_c_buf_p so that if some total
+                                        * hoser (like flex itself) wants to
+                                        * call the scanner after we return the
+                                        * YY_NULL, it'll still work - another
+                                        * YY_NULL will get returned.
+                                        */
+                                       (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+                                       yy_act = YY_STATE_EOF(YY_START);
+                                       goto do_action;
+                                       }
+
+                               else
+                                       {
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
+                                       }
+                               break;
+                               }
+
+                       case EOB_ACT_CONTINUE_SCAN:
+                               (yy_c_buf_p) =
+                                       (yytext_ptr) + yy_amount_of_matched_text;
+
+                               yy_current_state = yy_get_previous_state(  );
+
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_match;
+
+                       case EOB_ACT_LAST_MATCH:
+                               (yy_c_buf_p) =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+                               yy_current_state = yy_get_previous_state(  );
+
+                               yy_cp = (yy_c_buf_p);
+                               yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+                               goto yy_find_action;
+                       }
+               break;
+               }
+
+       default:
+               YY_FATAL_ERROR(
+                       "fatal flex scanner internal error--no action found" );
+       } /* end of action switch */
+               } /* end of scanning one token */
 } /* end of surf_parse_lex */
 
 /* yy_get_next_buffer - try to read in a new buffer
  *
  * Returns a code representing an action:
- *  EOB_ACT_LAST_MATCH -
- *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *  EOB_ACT_END_OF_FILE - end of file
+ *     EOB_ACT_LAST_MATCH -
+ *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *     EOB_ACT_END_OF_FILE - end of file
  */
 static int yy_get_next_buffer (void)
 {
-      register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-  register char *source = (yytext_ptr);
-  register int number_to_move, i;
-  int ret_val;
-
-  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
-    YY_FATAL_ERROR(
-    "fatal flex scanner internal error--end of buffer missed" );
-
-  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
-    { /* Don't try to fill the buffer, so this is an EOF. */
-    if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
-      {
-      /* We matched a single character, the EOB, so
-       * treat this as a final EOF.
-       */
-      return EOB_ACT_END_OF_FILE;
-      }
-
-    else
-      {
-      /* We matched some text prior to the EOB, first
-       * process it.
-       */
-      return EOB_ACT_LAST_MATCH;
-      }
-    }
-
-  /* Try to read more data. */
-
-  /* First move last chars to start of buffer. */
-  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
-
-  for ( i = 0; i < number_to_move; ++i )
-    *(dest++) = *(source++);
-
-  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
-    /* don't do the read, it's not guaranteed to return an EOF,
-     * just force an EOF
-     */
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
-
-  else
-    {
-      int num_to_read =
-      YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
-
-    while ( num_to_read <= 0 )
-      { /* Not enough room in the buffer - grow it. */
-
-      /* just a shorter name for the current buffer */
-      YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-
-      int yy_c_buf_p_offset =
-        (int) ((yy_c_buf_p) - b->yy_ch_buf);
-
-      if ( b->yy_is_our_buffer )
-        {
-        int new_size = b->yy_buf_size * 2;
-
-        if ( new_size <= 0 )
-          b->yy_buf_size += b->yy_buf_size / 8;
-        else
-          b->yy_buf_size *= 2;
-
-        b->yy_ch_buf = (char *)
-          /* Include room in for 2 EOB chars. */
-          surf_parse_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
-        }
-      else
-        /* Can't grow it, we don't own it. */
-        b->yy_ch_buf = 0;
-
-      if ( ! b->yy_ch_buf )
-        YY_FATAL_ERROR(
-        "fatal error - scanner input buffer overflow" );
-
-      (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
-
-      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
-            number_to_move - 1;
-
-      }
-
-    if ( num_to_read > YY_READ_BUF_SIZE )
-      num_to_read = YY_READ_BUF_SIZE;
-
-    /* Read in more data. */
-    YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
-      (yy_n_chars), (size_t) num_to_read );
-
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-    }
+       register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       register char *source = (yytext_ptr);
+       register int number_to_move, i;
+       int ret_val;
+
+       if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+               YY_FATAL_ERROR(
+               "fatal flex scanner internal error--end of buffer missed" );
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+               { /* Don't try to fill the buffer, so this is an EOF. */
+               if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+                       {
+                       /* We matched a single character, the EOB, so
+                        * treat this as a final EOF.
+                        */
+                       return EOB_ACT_END_OF_FILE;
+                       }
+
+               else
+                       {
+                       /* We matched some text prior to the EOB, first
+                        * process it.
+                        */
+                       return EOB_ACT_LAST_MATCH;
+                       }
+               }
+
+       /* Try to read more data. */
+
+       /* First move last chars to start of buffer. */
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
+
+       for ( i = 0; i < number_to_move; ++i )
+               *(dest++) = *(source++);
+
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+               /* don't do the read, it's not guaranteed to return an EOF,
+                * just force an EOF
+                */
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+       else
+               {
+                       int num_to_read =
+                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+               while ( num_to_read <= 0 )
+                       { /* Not enough room in the buffer - grow it. */
+
+                       /* just a shorter name for the current buffer */
+                       YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
+
+                       int yy_c_buf_p_offset =
+                               (int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+                       if ( b->yy_is_our_buffer )
+                               {
+                               int new_size = b->yy_buf_size * 2;
+
+                               if ( new_size <= 0 )
+                                       b->yy_buf_size += b->yy_buf_size / 8;
+                               else
+                                       b->yy_buf_size *= 2;
+
+                               b->yy_ch_buf = (char *)
+                                       /* Include room in for 2 EOB chars. */
+                                       surf_parse_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
+                               }
+                       else
+                               /* Can't grow it, we don't own it. */
+                               b->yy_ch_buf = 0;
+
+                       if ( ! b->yy_ch_buf )
+                               YY_FATAL_ERROR(
+                               "fatal error - scanner input buffer overflow" );
+
+                       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+                       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+                                               number_to_move - 1;
+
+                       }
+
+               if ( num_to_read > YY_READ_BUF_SIZE )
+                       num_to_read = YY_READ_BUF_SIZE;
+
+               /* Read in more data. */
+               YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+                       (yy_n_chars), (size_t) num_to_read );
+
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       if ( (yy_n_chars) == 0 )
+               {
+               if ( number_to_move == YY_MORE_ADJ )
+                       {
+                       ret_val = EOB_ACT_END_OF_FILE;
+                       surf_parse_restart(surf_parse_in  );
+                       }
+
+               else
+                       {
+                       ret_val = EOB_ACT_LAST_MATCH;
+                       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+                               YY_BUFFER_EOF_PENDING;
+                       }
+               }
+
+       else
+               ret_val = EOB_ACT_CONTINUE_SCAN;
+
+       if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+               /* Extend the array by 50%, plus the number we really need. */
+               yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) surf_parse_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
+               if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+                       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+       }
+
+       (yy_n_chars) += number_to_move;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+       YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+       (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
 
-  if ( (yy_n_chars) == 0 )
-    {
-    if ( number_to_move == YY_MORE_ADJ )
-      {
-      ret_val = EOB_ACT_END_OF_FILE;
-      surf_parse_restart(surf_parse_in  );
-      }
-
-    else
-      {
-      ret_val = EOB_ACT_LAST_MATCH;
-      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
-        YY_BUFFER_EOF_PENDING;
-      }
-    }
-
-  else
-    ret_val = EOB_ACT_CONTINUE_SCAN;
-
-  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-    /* Extend the array by 50%, plus the number we really need. */
-    yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) surf_parse_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
-    if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
-      YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
-  }
-
-  (yy_n_chars) += number_to_move;
-  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
-  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
-
-  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
-
-  return ret_val;
+       return ret_val;
 }
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
     static yy_state_type yy_get_previous_state (void)
 {
-  register yy_state_type yy_current_state;
-  register char *yy_cp;
+       register yy_state_type yy_current_state;
+       register char *yy_cp;
     
-  yy_current_state = (yy_start);
-
-  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
-    {
-    register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-    if ( yy_accept[yy_current_state] )
-      {
-      (yy_last_accepting_state) = yy_current_state;
-      (yy_last_accepting_cpos) = yy_cp;
-      }
-    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-      {
-      yy_current_state = (int) yy_def[yy_current_state];
-      if ( yy_current_state >= 2809 )
-        yy_c = yy_meta[(unsigned int) yy_c];
-      }
-    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-    }
-
-  return yy_current_state;
+       yy_current_state = (yy_start);
+
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+               {
+               register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+               if ( yy_accept[yy_current_state] )
+                       {
+                       (yy_last_accepting_state) = yy_current_state;
+                       (yy_last_accepting_cpos) = yy_cp;
+                       }
+               while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                       {
+                       yy_current_state = (int) yy_def[yy_current_state];
+                       if ( yy_current_state >= 2809 )
+                               yy_c = yy_meta[(unsigned int) yy_c];
+                       }
+               yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+               }
+
+       return yy_current_state;
 }
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
- *  next_state = yy_try_NUL_trans( current_state );
+ *     next_state = yy_try_NUL_trans( current_state );
  */
     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
 {
-  register int yy_is_jam;
-      register char *yy_cp = (yy_c_buf_p);
-
-  register YY_CHAR yy_c = 1;
-  if ( yy_accept[yy_current_state] )
-    {
-    (yy_last_accepting_state) = yy_current_state;
-    (yy_last_accepting_cpos) = yy_cp;
-    }
-  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-    {
-    yy_current_state = (int) yy_def[yy_current_state];
-    if ( yy_current_state >= 2809 )
-      yy_c = yy_meta[(unsigned int) yy_c];
-    }
-  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-  yy_is_jam = (yy_current_state == 2808);
-
-  return yy_is_jam ? 0 : yy_current_state;
+       register int yy_is_jam;
+       register char *yy_cp = (yy_c_buf_p);
+
+       register YY_CHAR yy_c = 1;
+       if ( yy_accept[yy_current_state] )
+               {
+               (yy_last_accepting_state) = yy_current_state;
+               (yy_last_accepting_cpos) = yy_cp;
+               }
+       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+               {
+               yy_current_state = (int) yy_def[yy_current_state];
+               if ( yy_current_state >= 2809 )
+                       yy_c = yy_meta[(unsigned int) yy_c];
+               }
+       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+       yy_is_jam = (yy_current_state == 2808);
+
+       return yy_is_jam ? 0 : yy_current_state;
 }
 
 #ifndef YY_NO_INPUT
@@ -8401,76 +8401,76 @@ static int yy_get_next_buffer (void)
 #endif
 
 {
-  int c;
+       int c;
     
-  *(yy_c_buf_p) = (yy_hold_char);
-
-  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
-    {
-    /* yy_c_buf_p now points to the character we want to return.
-     * If this occurs *before* the EOB characters, then it's a
-     * valid NUL; if not, then we've hit the end of the buffer.
-     */
-    if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-      /* This was really a NUL. */
-      *(yy_c_buf_p) = '\0';
-
-    else
-      { /* need more input */
-      int offset = (yy_c_buf_p) - (yytext_ptr);
-      ++(yy_c_buf_p);
-
-      switch ( yy_get_next_buffer(  ) )
-        {
-        case EOB_ACT_LAST_MATCH:
-          /* This happens because yy_g_n_b()
-           * sees that we've accumulated a
-           * token and flags that we need to
-           * try matching the token before
-           * proceeding.  But for input(),
-           * there's no matching to consider.
-           * So convert the EOB_ACT_LAST_MATCH
-           * to EOB_ACT_END_OF_FILE.
-           */
-
-          /* Reset buffer status. */
-          surf_parse_restart(surf_parse_in );
-
-          /*FALLTHROUGH*/
-
-        case EOB_ACT_END_OF_FILE:
-          {
-          if ( surf_parse_wrap( ) )
-            return EOF;
-
-          if ( ! (yy_did_buffer_switch_on_eof) )
-            YY_NEW_FILE;
+       *(yy_c_buf_p) = (yy_hold_char);
+
+       if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+               {
+               /* yy_c_buf_p now points to the character we want to return.
+                * If this occurs *before* the EOB characters, then it's a
+                * valid NUL; if not, then we've hit the end of the buffer.
+                */
+               if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+                       /* This was really a NUL. */
+                       *(yy_c_buf_p) = '\0';
+
+               else
+                       { /* need more input */
+                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       ++(yy_c_buf_p);
+
+                       switch ( yy_get_next_buffer(  ) )
+                               {
+                               case EOB_ACT_LAST_MATCH:
+                                       /* This happens because yy_g_n_b()
+                                        * sees that we've accumulated a
+                                        * token and flags that we need to
+                                        * try matching the token before
+                                        * proceeding.  But for input(),
+                                        * there's no matching to consider.
+                                        * So convert the EOB_ACT_LAST_MATCH
+                                        * to EOB_ACT_END_OF_FILE.
+                                        */
+
+                                       /* Reset buffer status. */
+                                       surf_parse_restart(surf_parse_in );
+
+                                       /*FALLTHROUGH*/
+
+                               case EOB_ACT_END_OF_FILE:
+                                       {
+                                       if ( surf_parse_wrap( ) )
+                                               return EOF;
+
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;
 #ifdef __cplusplus
-          return yyinput();
+                                       return yyinput();
 #else
-          return input();
+                                       return input();
 #endif
-          }
+                                       }
 
-        case EOB_ACT_CONTINUE_SCAN:
-          (yy_c_buf_p) = (yytext_ptr) + offset;
-          break;
-        }
-      }
-    }
+                               case EOB_ACT_CONTINUE_SCAN:
+                                       (yy_c_buf_p) = (yytext_ptr) + offset;
+                                       break;
+                               }
+                       }
+               }
 
-  c = *(unsigned char *) (yy_c_buf_p);  /* cast for 8-bit char's */
-  *(yy_c_buf_p) = '\0';  /* preserve surf_parse_text */
-  (yy_hold_char) = *++(yy_c_buf_p);
+       c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
+       *(yy_c_buf_p) = '\0';   /* preserve surf_parse_text */
+       (yy_hold_char) = *++(yy_c_buf_p);
 
-  if ( c == '\n' )
-       
+       if ( c == '\n' )
+                  
     surf_parse_lineno++;
 ;
 
-  return c;
+       return c;
 }
-#endif  /* ifndef YY_NO_INPUT */
+#endif /* ifndef YY_NO_INPUT */
 
 /** Immediately switch to a different input stream.
  * @param input_file A readable stream.
@@ -8480,14 +8480,14 @@ static int yy_get_next_buffer (void)
     void surf_parse_restart  (FILE * input_file )
 {
     
-  if ( ! YY_CURRENT_BUFFER ){
+       if ( ! YY_CURRENT_BUFFER ){
         surf_parse_ensure_buffer_stack ();
-    YY_CURRENT_BUFFER_LVALUE =
+               YY_CURRENT_BUFFER_LVALUE =
             surf_parse__create_buffer(surf_parse_in,YY_BUF_SIZE );
-  }
+       }
 
-  surf_parse__init_buffer(YY_CURRENT_BUFFER,input_file );
-  surf_parse__load_buffer_state( );
+       surf_parse__init_buffer(YY_CURRENT_BUFFER,input_file );
+       surf_parse__load_buffer_state( );
 }
 
 /** Switch to a different input buffer.
@@ -8497,40 +8497,40 @@ static int yy_get_next_buffer (void)
     void surf_parse__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
 {
     
-  /* TODO. We should be able to replace this entire function body
-   * with
-   *    surf_parse_pop_buffer_state();
-   *    surf_parse_push_buffer_state(new_buffer);
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              surf_parse_pop_buffer_state();
+        *              surf_parse_push_buffer_state(new_buffer);
      */
-  surf_parse_ensure_buffer_stack ();
-  if ( YY_CURRENT_BUFFER == new_buffer )
-    return;
-
-  if ( YY_CURRENT_BUFFER )
-    {
-    /* Flush out information for old buffer. */
-    *(yy_c_buf_p) = (yy_hold_char);
-    YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-    }
-
-  YY_CURRENT_BUFFER_LVALUE = new_buffer;
-  surf_parse__load_buffer_state( );
-
-  /* We don't actually know whether we did this switch during
-   * EOF (surf_parse_wrap()) processing, but the only time this flag
-   * is looked at is after surf_parse_wrap() is called, so it's safe
-   * to go ahead and always set it.
-   */
-  (yy_did_buffer_switch_on_eof) = 1;
+       surf_parse_ensure_buffer_stack ();
+       if ( YY_CURRENT_BUFFER == new_buffer )
+               return;
+
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
+
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       surf_parse__load_buffer_state( );
+
+       /* We don't actually know whether we did this switch during
+        * EOF (surf_parse_wrap()) processing, but the only time this flag
+        * is looked at is after surf_parse_wrap() is called, so it's safe
+        * to go ahead and always set it.
+        */
+       (yy_did_buffer_switch_on_eof) = 1;
 }
 
 static void surf_parse__load_buffer_state  (void)
 {
-      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
-  surf_parse_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
-  (yy_hold_char) = *(yy_c_buf_p);
+       (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+       (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+       surf_parse_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);
 }
 
 /** Allocate and initialize an input buffer state.
@@ -8541,26 +8541,26 @@ static void surf_parse__load_buffer_state  (void)
  */
     YY_BUFFER_STATE surf_parse__create_buffer  (FILE * file, int  size )
 {
-  YY_BUFFER_STATE b;
+       YY_BUFFER_STATE b;
     
-  b = (YY_BUFFER_STATE) surf_parse_alloc(sizeof( struct yy_buffer_state )  );
-  if ( ! b )
-    YY_FATAL_ERROR( "out of dynamic memory in surf_parse__create_buffer()" );
+       b = (YY_BUFFER_STATE) surf_parse_alloc(sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__create_buffer()" );
 
-  b->yy_buf_size = size;
+       b->yy_buf_size = size;
 
-  /* yy_ch_buf has to be 2 characters longer than the size given because
-   * we need to put in 2 end-of-buffer characters.
-   */
-  b->yy_ch_buf = (char *) surf_parse_alloc(b->yy_buf_size + 2  );
-  if ( ! b->yy_ch_buf )
-    YY_FATAL_ERROR( "out of dynamic memory in surf_parse__create_buffer()" );
+       /* yy_ch_buf has to be 2 characters longer than the size given because
+        * we need to put in 2 end-of-buffer characters.
+        */
+       b->yy_ch_buf = (char *) surf_parse_alloc(b->yy_buf_size + 2  );
+       if ( ! b->yy_ch_buf )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__create_buffer()" );
 
-  b->yy_is_our_buffer = 1;
+       b->yy_is_our_buffer = 1;
 
-  surf_parse__init_buffer(b,file );
+       surf_parse__init_buffer(b,file );
 
-  return b;
+       return b;
 }
 
 /** Destroy the buffer.
@@ -8570,16 +8570,16 @@ static void surf_parse__load_buffer_state  (void)
     void surf_parse__delete_buffer (YY_BUFFER_STATE  b )
 {
     
-  if ( ! b )
-    return;
+       if ( ! b )
+               return;
 
-  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
-    YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+       if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+               YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
-  if ( b->yy_is_our_buffer )
-    surf_parse_free((void *) b->yy_ch_buf  );
+       if ( b->yy_is_our_buffer )
+               surf_parse_free((void *) b->yy_ch_buf  );
 
-  surf_parse_free((void *) b  );
+       surf_parse_free((void *) b  );
 }
 
 #ifndef __cplusplus
@@ -8593,12 +8593,12 @@ extern int isatty (int );
     static void surf_parse__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
 
 {
-  int oerrno = errno;
+       int oerrno = errno;
     
-  surf_parse__flush_buffer(b );
+       surf_parse__flush_buffer(b );
 
-  b->yy_input_file = file;
-  b->yy_fill_buffer = 1;
+       b->yy_input_file = file;
+       b->yy_fill_buffer = 1;
 
     /* If b is the current buffer, then surf_parse__init_buffer was _probably_
      * called from surf_parse_restart() or through yy_get_next_buffer.
@@ -8611,7 +8611,7 @@ extern int isatty (int );
 
         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
     
-  errno = oerrno;
+       errno = oerrno;
 }
 
 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
@@ -8620,25 +8620,25 @@ extern int isatty (int );
  */
     void surf_parse__flush_buffer (YY_BUFFER_STATE  b )
 {
-      if ( ! b )
-    return;
+       if ( ! b )
+               return;
 
-  b->yy_n_chars = 0;
+       b->yy_n_chars = 0;
 
-  /* We always need two end-of-buffer characters.  The first causes
-   * a transition to the end-of-buffer state.  The second causes
-   * a jam in that state.
-   */
-  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
-  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+       /* We always need two end-of-buffer characters.  The first causes
+        * a transition to the end-of-buffer state.  The second causes
+        * a jam in that state.
+        */
+       b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+       b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
 
-  b->yy_buf_pos = &b->yy_ch_buf[0];
+       b->yy_buf_pos = &b->yy_ch_buf[0];
 
-  b->yy_at_bol = 1;
-  b->yy_buffer_status = YY_BUFFER_NEW;
+       b->yy_at_bol = 1;
+       b->yy_buffer_status = YY_BUFFER_NEW;
 
-  if ( b == YY_CURRENT_BUFFER )
-    surf_parse__load_buffer_state( );
+       if ( b == YY_CURRENT_BUFFER )
+               surf_parse__load_buffer_state( );
 }
 
 /** Pushes the new state onto the stack. The new state becomes
@@ -8649,28 +8649,28 @@ extern int isatty (int );
  */
 void surf_parse_push_buffer_state (YY_BUFFER_STATE new_buffer )
 {
-      if (new_buffer == NULL)
-    return;
+       if (new_buffer == NULL)
+               return;
 
-  surf_parse_ensure_buffer_stack();
+       surf_parse_ensure_buffer_stack();
 
-  /* This block is copied from surf_parse__switch_to_buffer. */
-  if ( YY_CURRENT_BUFFER )
-    {
-    /* Flush out information for old buffer. */
-    *(yy_c_buf_p) = (yy_hold_char);
-    YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
-    }
+       /* This block is copied from surf_parse__switch_to_buffer. */
+       if ( YY_CURRENT_BUFFER )
+               {
+               /* Flush out information for old buffer. */
+               *(yy_c_buf_p) = (yy_hold_char);
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+               }
 
-  /* Only push if top exists. Otherwise, replace top. */
-  if (YY_CURRENT_BUFFER)
-    (yy_buffer_stack_top)++;
-  YY_CURRENT_BUFFER_LVALUE = new_buffer;
+       /* Only push if top exists. Otherwise, replace top. */
+       if (YY_CURRENT_BUFFER)
+               (yy_buffer_stack_top)++;
+       YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
-  /* copied from surf_parse__switch_to_buffer. */
-  surf_parse__load_buffer_state( );
-  (yy_did_buffer_switch_on_eof) = 1;
+       /* copied from surf_parse__switch_to_buffer. */
+       surf_parse__load_buffer_state( );
+       (yy_did_buffer_switch_on_eof) = 1;
 }
 
 /** Removes and deletes the top of the stack, if present.
@@ -8679,18 +8679,18 @@ void surf_parse_push_buffer_state (YY_BUFFER_STATE new_buffer )
  */
 void surf_parse_pop_buffer_state (void)
 {
-      if (!YY_CURRENT_BUFFER)
-    return;
+       if (!YY_CURRENT_BUFFER)
+               return;
 
-  surf_parse__delete_buffer(YY_CURRENT_BUFFER );
-  YY_CURRENT_BUFFER_LVALUE = NULL;
-  if ((yy_buffer_stack_top) > 0)
-    --(yy_buffer_stack_top);
+       surf_parse__delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
 
-  if (YY_CURRENT_BUFFER) {
-    surf_parse__load_buffer_state( );
-    (yy_did_buffer_switch_on_eof) = 1;
-  }
+       if (YY_CURRENT_BUFFER) {
+               surf_parse__load_buffer_state( );
+               (yy_did_buffer_switch_on_eof) = 1;
+       }
 }
 
 /* Allocates the stack if it does not exist.
@@ -8698,45 +8698,45 @@ void surf_parse_pop_buffer_state (void)
  */
 static void surf_parse_ensure_buffer_stack (void)
 {
-  int num_to_alloc;
+       int num_to_alloc;
     
-  if (!(yy_buffer_stack)) {
+       if (!(yy_buffer_stack)) {
 
-    /* First allocation is just for 2 elements, since we don't know if this
-     * scanner will even need a stack. We use 2 instead of 1 to avoid an
-     * immediate realloc on the next call.
+               /* First allocation is just for 2 elements, since we don't know if this
+                * scanner will even need a stack. We use 2 instead of 1 to avoid an
+                * immediate realloc on the next call.
          */
-    num_to_alloc = 1;
-    (yy_buffer_stack) = (struct yy_buffer_state**)surf_parse_alloc
-                (num_to_alloc * sizeof(struct yy_buffer_state*)
-                );
-    if ( ! (yy_buffer_stack) )
-      YY_FATAL_ERROR( "out of dynamic memory in surf_parse_ensure_buffer_stack()" );
-                  
-    memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-        
-    (yy_buffer_stack_max) = num_to_alloc;
-    (yy_buffer_stack_top) = 0;
-    return;
-  }
-
-  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
-
-    /* Increase the buffer to prepare for a possible push. */
-    int grow_size = 8 /* arbitrary grow size */;
-
-    num_to_alloc = (yy_buffer_stack_max) + grow_size;
-    (yy_buffer_stack) = (struct yy_buffer_state**)surf_parse_realloc
-                ((yy_buffer_stack),
-                num_to_alloc * sizeof(struct yy_buffer_state*)
-                );
-    if ( ! (yy_buffer_stack) )
-      YY_FATAL_ERROR( "out of dynamic memory in surf_parse_ensure_buffer_stack()" );
-
-    /* zero only the new slots.*/
-    memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
-    (yy_buffer_stack_max) = num_to_alloc;
-  }
+               num_to_alloc = 1;
+               (yy_buffer_stack) = (struct yy_buffer_state**)surf_parse_alloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in surf_parse_ensure_buffer_stack()" );
+                                                                 
+               memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+                               
+               (yy_buffer_stack_max) = num_to_alloc;
+               (yy_buffer_stack_top) = 0;
+               return;
+       }
+
+       if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+               /* Increase the buffer to prepare for a possible push. */
+               int grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)surf_parse_realloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in surf_parse_ensure_buffer_stack()" );
+
+               /* zero only the new slots.*/
+               memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+               (yy_buffer_stack_max) = num_to_alloc;
+       }
 }
 
 /** Setup the input buffer state to scan directly from a user-specified character buffer.
@@ -8747,31 +8747,31 @@ static void surf_parse_ensure_buffer_stack (void)
  */
 YY_BUFFER_STATE surf_parse__scan_buffer  (char * base, yy_size_t  size )
 {
-  YY_BUFFER_STATE b;
+       YY_BUFFER_STATE b;
     
-  if ( size < 2 ||
-       base[size-2] != YY_END_OF_BUFFER_CHAR ||
-       base[size-1] != YY_END_OF_BUFFER_CHAR )
-    /* They forgot to leave room for the EOB's. */
-    return 0;
-
-  b = (YY_BUFFER_STATE) surf_parse_alloc(sizeof( struct yy_buffer_state )  );
-  if ( ! b )
-    YY_FATAL_ERROR( "out of dynamic memory in surf_parse__scan_buffer()" );
-
-  b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
-  b->yy_buf_pos = b->yy_ch_buf = base;
-  b->yy_is_our_buffer = 0;
-  b->yy_input_file = 0;
-  b->yy_n_chars = b->yy_buf_size;
-  b->yy_is_interactive = 0;
-  b->yy_at_bol = 1;
-  b->yy_fill_buffer = 0;
-  b->yy_buffer_status = YY_BUFFER_NEW;
-
-  surf_parse__switch_to_buffer(b  );
-
-  return b;
+       if ( size < 2 ||
+            base[size-2] != YY_END_OF_BUFFER_CHAR ||
+            base[size-1] != YY_END_OF_BUFFER_CHAR )
+               /* They forgot to leave room for the EOB's. */
+               return 0;
+
+       b = (YY_BUFFER_STATE) surf_parse_alloc(sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__scan_buffer()" );
+
+       b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
+       b->yy_buf_pos = b->yy_ch_buf = base;
+       b->yy_is_our_buffer = 0;
+       b->yy_input_file = 0;
+       b->yy_n_chars = b->yy_buf_size;
+       b->yy_is_interactive = 0;
+       b->yy_at_bol = 1;
+       b->yy_fill_buffer = 0;
+       b->yy_buffer_status = YY_BUFFER_NEW;
+
+       surf_parse__switch_to_buffer(b  );
+
+       return b;
 }
 
 /** Setup the input buffer state to scan a string. The next call to surf_parse_lex() will
@@ -8785,7 +8785,7 @@ YY_BUFFER_STATE surf_parse__scan_buffer  (char * base, yy_size_t  size )
 YY_BUFFER_STATE surf_parse__scan_string (yyconst char * yystr )
 {
     
-  return surf_parse__scan_bytes(yystr,strlen(yystr) );
+       return surf_parse__scan_bytes(yystr,strlen(yystr) );
 }
 
 /** Setup the input buffer state to scan the given bytes. The next call to surf_parse_lex() will
@@ -8797,64 +8797,64 @@ YY_BUFFER_STATE surf_parse__scan_string (yyconst char * yystr )
  */
 YY_BUFFER_STATE surf_parse__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 {
-  YY_BUFFER_STATE b;
-  char *buf;
-  yy_size_t n;
-  int i;
+       YY_BUFFER_STATE b;
+       char *buf;
+       yy_size_t n;
+       int i;
     
-  /* Get memory for full buffer, including space for trailing EOB's. */
-  n = _yybytes_len + 2;
-  buf = (char *) surf_parse_alloc(n  );
-  if ( ! buf )
-    YY_FATAL_ERROR( "out of dynamic memory in surf_parse__scan_bytes()" );
+       /* Get memory for full buffer, including space for trailing EOB's. */
+       n = _yybytes_len + 2;
+       buf = (char *) surf_parse_alloc(n  );
+       if ( ! buf )
+               YY_FATAL_ERROR( "out of dynamic memory in surf_parse__scan_bytes()" );
 
-  for ( i = 0; i < _yybytes_len; ++i )
-    buf[i] = yybytes[i];
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
 
-  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-  b = surf_parse__scan_buffer(buf,n );
-  if ( ! b )
-    YY_FATAL_ERROR( "bad buffer in surf_parse__scan_bytes()" );
+       b = surf_parse__scan_buffer(buf,n );
+       if ( ! b )
+               YY_FATAL_ERROR( "bad buffer in surf_parse__scan_bytes()" );
 
-  /* It's okay to grow etc. this buffer, and we should throw it
-   * away when we're done.
-   */
-  b->yy_is_our_buffer = 1;
+       /* It's okay to grow etc. this buffer, and we should throw it
+        * away when we're done.
+        */
+       b->yy_is_our_buffer = 1;
 
-  return b;
+       return b;
 }
 
     static void yy_push_state (int  new_state )
 {
-      if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
-    {
-    yy_size_t new_size;
+       if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
+               {
+               yy_size_t new_size;
 
-    (yy_start_stack_depth) += YY_START_STACK_INCR;
-    new_size = (yy_start_stack_depth) * sizeof( int );
+               (yy_start_stack_depth) += YY_START_STACK_INCR;
+               new_size = (yy_start_stack_depth) * sizeof( int );
 
-    if ( ! (yy_start_stack) )
-      (yy_start_stack) = (int *) surf_parse_alloc(new_size  );
+               if ( ! (yy_start_stack) )
+                       (yy_start_stack) = (int *) surf_parse_alloc(new_size  );
 
-    else
-      (yy_start_stack) = (int *) surf_parse_realloc((void *) (yy_start_stack),new_size  );
+               else
+                       (yy_start_stack) = (int *) surf_parse_realloc((void *) (yy_start_stack),new_size  );
 
-    if ( ! (yy_start_stack) )
-      YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
-    }
+               if ( ! (yy_start_stack) )
+                       YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
+               }
 
-  (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
+       (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
 
-  BEGIN(new_state);
+       BEGIN(new_state);
 }
 
     static void yy_pop_state  (void)
 {
-      if ( --(yy_start_stack_ptr) < 0 )
-    YY_FATAL_ERROR( "start-condition stack underflow" );
+       if ( --(yy_start_stack_ptr) < 0 )
+               YY_FATAL_ERROR( "start-condition stack underflow" );
 
-  BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
+       BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
 }
 
 #ifndef YY_EXIT_FAILURE
@@ -8863,26 +8863,26 @@ YY_BUFFER_STATE surf_parse__scan_bytes  (yyconst char * yybytes, int  _yybytes_l
 
 static void yy_fatal_error (yyconst char* msg )
 {
-      (void) fprintf( stderr, "%s\n", msg );
-  exit( YY_EXIT_FAILURE );
+       (void) fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );
 }
 
 /* Redefine yyless() so it works in section 3 code. */
 
 #undef yyless
 #define yyless(n) \
-  do \
-    { \
-    /* Undo effects of setting up surf_parse_text. */ \
+       do \
+               { \
+               /* Undo effects of setting up surf_parse_text. */ \
         int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
-    surf_parse_text[surf_parse_leng] = (yy_hold_char); \
-    (yy_c_buf_p) = surf_parse_text + yyless_macro_arg; \
-    (yy_hold_char) = *(yy_c_buf_p); \
-    *(yy_c_buf_p) = '\0'; \
-    surf_parse_leng = yyless_macro_arg; \
-    } \
-  while ( 0 )
+               surf_parse_text[surf_parse_leng] = (yy_hold_char); \
+               (yy_c_buf_p) = surf_parse_text + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               surf_parse_leng = yyless_macro_arg; \
+               } \
+       while ( 0 )
 
 /* Accessor  methods (get/set functions) to struct members. */
 
@@ -9004,15 +9004,15 @@ int surf_parse_lex_destroy  (void)
 {
     
     /* Pop the buffer stack, destroying each element. */
-  while(YY_CURRENT_BUFFER){
-    surf_parse__delete_buffer(YY_CURRENT_BUFFER  );
-    YY_CURRENT_BUFFER_LVALUE = NULL;
-    surf_parse_pop_buffer_state();
-  }
+       while(YY_CURRENT_BUFFER){
+               surf_parse__delete_buffer(YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               surf_parse_pop_buffer_state();
+       }
 
-  /* Destroy the stack itself. */
-  surf_parse_free((yy_buffer_stack) );
-  (yy_buffer_stack) = NULL;
+       /* Destroy the stack itself. */
+       surf_parse_free((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;
 
     /* Destroy the start condition stack. */
         surf_parse_free((yy_start_stack)  );
@@ -9032,43 +9032,43 @@ int surf_parse_lex_destroy  (void)
 #ifndef yytext_ptr
 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 {
-  register int i;
-  for ( i = 0; i < n; ++i )
-    s1[i] = s2[i];
+       register int i;
+       for ( i = 0; i < n; ++i )
+               s1[i] = s2[i];
 }
 #endif
 
 #ifdef YY_NEED_STRLEN
 static int yy_flex_strlen (yyconst char * s )
 {
-  register int n;
-  for ( n = 0; s[n]; ++n )
-    ;
+       register int n;
+       for ( n = 0; s[n]; ++n )
+               ;
 
-  return n;
+       return n;
 }
 #endif
 
 void *surf_parse_alloc (yy_size_t  size )
 {
-  return (void *) malloc( size );
+       return (void *) malloc( size );
 }
 
 void *surf_parse_realloc  (void * ptr, yy_size_t  size )
 {
-  /* The cast to (char *) in the following accommodates both
-   * implementations that use char* generic pointers, and those
-   * that use void* generic pointers.  It works with the latter
-   * because both ANSI C and C++ allow castless assignment from
-   * any pointer type to void*, and deal with argument conversions
-   * as though doing an assignment.
-   */
-  return (void *) realloc( (char *) ptr, size );
+       /* The cast to (char *) in the following accommodates both
+        * implementations that use char* generic pointers, and those
+        * that use void* generic pointers.  It works with the latter
+        * because both ANSI C and C++ allow castless assignment from
+        * any pointer type to void*, and deal with argument conversions
+        * as though doing an assignment.
+        */
+       return (void *) realloc( (char *) ptr, size );
 }
 
 void surf_parse_free (void * ptr )
 {
-  free( (char *) ptr );  /* see surf_parse_realloc() for (char *) cast */
+       free( (char *) ptr );   /* see surf_parse_realloc() for (char *) cast */
 }
 
 #define YYTABLES_NAME "yytables"
@@ -9077,8 +9077,8 @@ void surf_parse_free (void * ptr )
 int surfxml_element_context(int i)
 {
   return (0<i && i<yy_start_stack_depth
-    ? yy_start_stack[yy_start_stack_ptr - i]
-    : 0);
+         ? yy_start_stack[yy_start_stack_ptr - i]
+         : 0);
 }
 
 #ifdef FLEX_DEBUG
@@ -9117,7 +9117,7 @@ static void debug_enter(int state, const char* statename) {
 static void debug_leave(void) {
     if (surf_parse__flex_debug) {
         print_yy_stack("--LEAVE : ");
-  print_surfxml_bufferstack();
+       print_surfxml_bufferstack();
     }
   yy_pop_state();
 }
@@ -9132,7 +9132,7 @@ static void cleanup(void)
 {
     if (surfxml_statenames) {
         free(surfxml_statenames);
-  surfxml_statenames = NULL;
+       surfxml_statenames = NULL;
     }
     free(surfxml_bufferstack);
     surfxml_bufferstack = NULL;
@@ -9147,12 +9147,12 @@ static int fail(const char* fmt, ...)
     va_list ap; va_start(ap, fmt);
 #ifdef FLEXML_yylineno
     used = sprintf(flexml_err_msg,
-       "Invalid XML (XML input line %d, state %d): ",
-       surf_parse_lineno, YY_START);
+                  "Invalid XML (XML input line %d, state %d): ",
+                  surf_parse_lineno, YY_START);
 #else
     used = sprintf(flexml_err_msg,
-       "Invalid XML (state %d): ",
-       YY_START);
+                  "Invalid XML (state %d): ",
+                  YY_START);
 #endif
     chars_left = flexml_max_err_msg_size - used - 1;
     vsnprintf(flexml_err_msg + used, chars_left, fmt, ap);
index c84f31c..a7395b1 100644 (file)
@@ -112,15 +112,15 @@ typedef unsigned int flex_uint32_t;
 /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST
 
-#else  /* ! __cplusplus */
+#else  /* ! __cplusplus */
 
 /* C99 requires __STDC__ to be defined as 1. */
 #if defined (__STDC__)
 
 #define YY_USE_CONST
 
-#endif  /* defined (__STDC__) */
-#endif  /* ! __cplusplus */
+#endif /* defined (__STDC__) */
+#endif /* ! __cplusplus */
 
 #ifdef YY_USE_CONST
 #define yyconst const
@@ -193,17 +193,17 @@ extern FILE *xbt_automaton_parse_in, *xbt_automaton_parse_out;
     
 /* Return all but the first "n" matched characters back to the input stream. */
 #define yyless(n) \
-  do \
-    { \
-    /* Undo effects of setting up xbt_automaton_parse_text. */ \
+       do \
+               { \
+               /* Undo effects of setting up xbt_automaton_parse_text. */ \
         int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
-    *yy_cp = (yy_hold_char); \
-    YY_RESTORE_YY_MORE_OFFSET \
-    (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
-    YY_DO_BEFORE_ACTION; /* set up xbt_automaton_parse_text again */ \
-    } \
-  while ( 0 )
+               *yy_cp = (yy_hold_char); \
+               YY_RESTORE_YY_MORE_OFFSET \
+               (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+               YY_DO_BEFORE_ACTION; /* set up xbt_automaton_parse_text again */ \
+               } \
+       while ( 0 )
 
 #define unput(c) yyunput( c, (yytext_ptr)  )
 
@@ -215,66 +215,66 @@ typedef size_t yy_size_t;
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state
-  {
-  FILE *yy_input_file;
-
-  char *yy_ch_buf;    /* input buffer */
-  char *yy_buf_pos;    /* current position in input buffer */
-
-  /* Size of input buffer in bytes, not including room for EOB
-   * characters.
-   */
-  yy_size_t yy_buf_size;
-
-  /* Number of characters read into yy_ch_buf, not including EOB
-   * characters.
-   */
-  int yy_n_chars;
-
-  /* Whether we "own" the buffer - i.e., we know we created it,
-   * and can realloc() it to grow it, and should free() it to
-   * delete it.
-   */
-  int yy_is_our_buffer;
-
-  /* Whether this is an "interactive" input source; if so, and
-   * if we're using stdio for input, then we want to use getc()
-   * instead of fread(), to make sure we stop fetching input after
-   * each newline.
-   */
-  int yy_is_interactive;
-
-  /* Whether we're considered to be at the beginning of a line.
-   * If so, '^' rules will be active on the next match, otherwise
-   * not.
-   */
-  int yy_at_bol;
+       {
+       FILE *yy_input_file;
+
+       char *yy_ch_buf;                /* input buffer */
+       char *yy_buf_pos;               /* current position in input buffer */
+
+       /* Size of input buffer in bytes, not including room for EOB
+        * characters.
+        */
+       yy_size_t yy_buf_size;
+
+       /* Number of characters read into yy_ch_buf, not including EOB
+        * characters.
+        */
+       int yy_n_chars;
+
+       /* Whether we "own" the buffer - i.e., we know we created it,
+        * and can realloc() it to grow it, and should free() it to
+        * delete it.
+        */
+       int yy_is_our_buffer;
+
+       /* Whether this is an "interactive" input source; if so, and
+        * if we're using stdio for input, then we want to use getc()
+        * instead of fread(), to make sure we stop fetching input after
+        * each newline.
+        */
+       int yy_is_interactive;
+
+       /* Whether we're considered to be at the beginning of a line.
+        * If so, '^' rules will be active on the next match, otherwise
+        * not.
+        */
+       int yy_at_bol;
 
     int yy_bs_lineno; /**< The line count. */
     int yy_bs_column; /**< The column count. */
     
-  /* Whether to try to fill the input buffer when we reach the
-   * end of it.
-   */
-  int yy_fill_buffer;
+       /* Whether to try to fill the input buffer when we reach the
+        * end of it.
+        */
+       int yy_fill_buffer;
 
-  int yy_buffer_status;
+       int yy_buffer_status;
 
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
-  /* When an EOF's been seen but there's still some text to process
-   * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-   * shouldn't try reading from the input source any more.  We might
-   * still have a bunch of tokens to match, though, because of
-   * possible backing-up.
-   *
-   * When we actually see the EOF, we change the status to "new"
-   * (via xbt_automaton_parse_restart()), so that the user can continue scanning by
-   * just pointing xbt_automaton_parse_in at a new input file.
-   */
+       /* When an EOF's been seen but there's still some text to process
+        * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+        * shouldn't try reading from the input source any more.  We might
+        * still have a bunch of tokens to match, though, because of
+        * possible backing-up.
+        *
+        * When we actually see the EOF, we change the status to "new"
+        * (via xbt_automaton_parse_restart()), so that the user can continue scanning by
+        * just pointing xbt_automaton_parse_in at a new input file.
+        */
 #define YY_BUFFER_EOF_PENDING 2
 
-  };
+       };
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
 /* Stack of input buffers. */
@@ -299,13 +299,13 @@ static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 
 /* yy_hold_char holds the character lost when xbt_automaton_parse_text is formed. */
 static char yy_hold_char;
-static int yy_n_chars;    /* number of characters read into yy_ch_buf */
+static int yy_n_chars;         /* number of characters read into yy_ch_buf */
 int xbt_automaton_parse_leng;
 
 /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 0;    /* whether we need to initialize */
-static int yy_start = 0;  /* start state number */
+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_automaton_parse_wrap()'s to do buffer switches
  * instead of setting up a fresh xbt_automaton_parse_in.  A bit of a hack ...
@@ -337,24 +337,24 @@ void xbt_automaton_parse_free (void *  );
 #define yy_new_buffer xbt_automaton_parse__create_buffer
 
 #define yy_set_interactive(is_interactive) \
-  { \
-  if ( ! YY_CURRENT_BUFFER ){ \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){ \
         xbt_automaton_parse_ensure_buffer_stack (); \
-    YY_CURRENT_BUFFER_LVALUE =    \
+               YY_CURRENT_BUFFER_LVALUE =    \
             xbt_automaton_parse__create_buffer(xbt_automaton_parse_in,YY_BUF_SIZE ); \
-  } \
-  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
-  }
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+       }
 
 #define yy_set_bol(at_bol) \
-  { \
-  if ( ! YY_CURRENT_BUFFER ){\
+       { \
+       if ( ! YY_CURRENT_BUFFER ){\
         xbt_automaton_parse_ensure_buffer_stack (); \
-    YY_CURRENT_BUFFER_LVALUE =    \
+               YY_CURRENT_BUFFER_LVALUE =    \
             xbt_automaton_parse__create_buffer(xbt_automaton_parse_in,YY_BUF_SIZE ); \
-  } \
-  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
-  }
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+       }
 
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
@@ -385,21 +385,21 @@ static void yy_fatal_error (yyconst char msg[]  );
  * corresponding action - sets up xbt_automaton_parse_text.
  */
 #define YY_DO_BEFORE_ACTION \
-  (yytext_ptr) = yy_bp; \
-  xbt_automaton_parse_leng = (size_t) (yy_cp - yy_bp); \
-  (yy_hold_char) = *yy_cp; \
-  *yy_cp = '\0'; \
-  (yy_c_buf_p) = yy_cp;
+       (yytext_ptr) = yy_bp; \
+       xbt_automaton_parse_leng = (size_t) (yy_cp - yy_bp); \
+       (yy_hold_char) = *yy_cp; \
+       *yy_cp = '\0'; \
+       (yy_c_buf_p) = yy_cp;
 
 #define YY_NUM_RULES 25
 #define YY_END_OF_BUFFER 26
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
-  {
-  flex_int32_t yy_verify;
-  flex_int32_t yy_nxt;
-  };
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
 static yyconst flex_int16_t yy_accept[54] =
     {   0,
         0,    0,   26,   24,   18,   23,    8,   24,   24,    9,
@@ -631,33 +631,33 @@ static int input (void );
  */
 #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \
-  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
-    { \
-    int c = '*'; \
-    size_t n; \
-    for ( n = 0; n < max_size && \
-           (c = getc( xbt_automaton_parse_in )) != EOF && c != '\n'; ++n ) \
-      buf[n] = (char) c; \
-    if ( c == '\n' ) \
-      buf[n++] = (char) c; \
-    if ( c == EOF && ferror( xbt_automaton_parse_in ) ) \
-      YY_FATAL_ERROR( "input in flex scanner failed" ); \
-    result = n; \
-    } \
-  else \
-    { \
-    errno=0; \
-    while ( (result = fread(buf, 1, max_size, xbt_automaton_parse_in))==0 && ferror(xbt_automaton_parse_in)) \
-      { \
-      if( errno != EINTR) \
-        { \
-        YY_FATAL_ERROR( "input in flex scanner failed" ); \
-        break; \
-        } \
-      errno=0; \
-      clearerr(xbt_automaton_parse_in); \
-      } \
-    }\
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+               { \
+               int c = '*'; \
+               size_t n; \
+               for ( n = 0; n < max_size && \
+                            (c = getc( xbt_automaton_parse_in )) != EOF && c != '\n'; ++n ) \
+                       buf[n] = (char) c; \
+               if ( c == '\n' ) \
+                       buf[n++] = (char) c; \
+               if ( c == EOF && ferror( xbt_automaton_parse_in ) ) \
+                       YY_FATAL_ERROR( "input in flex scanner failed" ); \
+               result = n; \
+               } \
+       else \
+               { \
+               errno=0; \
+               while ( (result = fread(buf, 1, max_size, xbt_automaton_parse_in))==0 && ferror(xbt_automaton_parse_in)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(xbt_automaton_parse_in); \
+                       } \
+               }\
 \
 
 #endif
@@ -706,208 +706,208 @@ extern int xbt_automaton_parse_lex (void);
 #endif
 
 #define YY_RULE_SETUP \
-  YY_USER_ACTION
+       YY_USER_ACTION
 
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {
-  register yy_state_type yy_current_state;
-  register char *yy_cp, *yy_bp;
-  register int yy_act;
+       register yy_state_type yy_current_state;
+       register char *yy_cp, *yy_bp;
+       register int yy_act;
     
 #line 28 "parserPromela.lex"
 
 
 #line 723 "automaton_parse.yy.c"
 
-  if ( !(yy_init) )
-    {
-    (yy_init) = 1;
+       if ( !(yy_init) )
+               {
+               (yy_init) = 1;
 
 #ifdef YY_USER_INIT
-    YY_USER_INIT;
+               YY_USER_INIT;
 #endif
 
-    if ( ! (yy_start) )
-      (yy_start) = 1;  /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */
 
-    if ( ! xbt_automaton_parse_in )
-      xbt_automaton_parse_in = stdin;
+               if ( ! xbt_automaton_parse_in )
+                       xbt_automaton_parse_in = stdin;
 
-    if ( ! xbt_automaton_parse_out )
-      xbt_automaton_parse_out = stdout;
+               if ( ! xbt_automaton_parse_out )
+                       xbt_automaton_parse_out = stdout;
 
-    if ( ! YY_CURRENT_BUFFER ) {
-      xbt_automaton_parse_ensure_buffer_stack ();
-      YY_CURRENT_BUFFER_LVALUE =
-        xbt_automaton_parse__create_buffer(xbt_automaton_parse_in,YY_BUF_SIZE );
-    }
+               if ( ! YY_CURRENT_BUFFER ) {
+                       xbt_automaton_parse_ensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               xbt_automaton_parse__create_buffer(xbt_automaton_parse_in,YY_BUF_SIZE );
+               }
 
-    xbt_automaton_parse__load_buffer_state( );
-    }
+               xbt_automaton_parse__load_buffer_state( );
+               }
 
-  while ( 1 )    /* loops until end-of-file is reached */
-    {
-    yy_cp = (yy_c_buf_p);
+       while ( 1 )             /* loops until end-of-file is reached */
+               {
+               yy_cp = (yy_c_buf_p);
 
-    /* Support of xbt_automaton_parse_text. */
-    *yy_cp = (yy_hold_char);
+               /* Support of xbt_automaton_parse_text. */
+               *yy_cp = (yy_hold_char);
 
-    /* yy_bp points to the position in yy_ch_buf of the start of
-     * the current run.
-     */
-    yy_bp = yy_cp;
+               /* yy_bp points to the position in yy_ch_buf of the start of
+                * the current run.
+                */
+               yy_bp = yy_cp;
 
-    yy_current_state = (yy_start);
+               yy_current_state = (yy_start);
 yy_match:
-    do
-      {
-      register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-      if ( yy_accept[yy_current_state] )
-        {
-        (yy_last_accepting_state) = yy_current_state;
-        (yy_last_accepting_cpos) = yy_cp;
-        }
-      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-        {
-        yy_current_state = (int) yy_def[yy_current_state];
-        if ( yy_current_state >= 54 )
-          yy_c = yy_meta[(unsigned int) yy_c];
-        }
-      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-      ++yy_cp;
-      }
-    while ( yy_base[yy_current_state] != 90 );
+               do
+                       {
+                       register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+                       if ( yy_accept[yy_current_state] )
+                               {
+                               (yy_last_accepting_state) = yy_current_state;
+                               (yy_last_accepting_cpos) = yy_cp;
+                               }
+                       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                               {
+                               yy_current_state = (int) yy_def[yy_current_state];
+                               if ( yy_current_state >= 54 )
+                                       yy_c = yy_meta[(unsigned int) yy_c];
+                               }
+                       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                       ++yy_cp;
+                       }
+               while ( yy_base[yy_current_state] != 90 );
 
 yy_find_action:
-    yy_act = yy_accept[yy_current_state];
-    if ( yy_act == 0 )
-      { /* have to back up */
-      yy_cp = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      yy_act = yy_accept[yy_current_state];
-      }
-
-    YY_DO_BEFORE_ACTION;
-
-do_action:  /* This label is used only to access EOF actions. */
-
-    switch ( yy_act )
-  { /* beginning of action switch */
-      case 0: /* must back up */
-      /* undo the effects of YY_DO_BEFORE_ACTION */
-      *yy_cp = (yy_hold_char);
-      yy_cp = (yy_last_accepting_cpos);
-      yy_current_state = (yy_last_accepting_state);
-      goto yy_find_action;
+               yy_act = yy_accept[yy_current_state];
+               if ( yy_act == 0 )
+                       { /* have to back up */
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
+                       yy_act = yy_accept[yy_current_state];
+                       }
+
+               YY_DO_BEFORE_ACTION;
+
+do_action:     /* This label is used only to access EOF actions. */
+
+               switch ( yy_act )
+       { /* beginning of action switch */
+                       case 0: /* must back up */
+                       /* undo the effects of YY_DO_BEFORE_ACTION */
+                       *yy_cp = (yy_hold_char);
+                       yy_cp = (yy_last_accepting_cpos);
+                       yy_current_state = (yy_last_accepting_state);
+                       goto yy_find_action;
 
 case 1:
 YY_RULE_SETUP
 #line 30 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (NEVER); }
-  YY_BREAK
+       YY_BREAK
 case 2:
 YY_RULE_SETUP
 #line 31 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (IF); }
-  YY_BREAK
+       YY_BREAK
 case 3:
 YY_RULE_SETUP
 #line 32 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); 
                return (FI); }
-  YY_BREAK
+       YY_BREAK
 case 4:
 YY_RULE_SETUP
 #line 34 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (IMPLIES); }
-  YY_BREAK
+       YY_BREAK
 case 5:
 YY_RULE_SETUP
 #line 35 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (GOTO); }
-  YY_BREAK
+       YY_BREAK
 case 6:
 YY_RULE_SETUP
 #line 36 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (AND); }
-  YY_BREAK
+       YY_BREAK
 case 7:
 YY_RULE_SETUP
 #line 37 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (OR); }
-  YY_BREAK
+       YY_BREAK
 case 8:
 YY_RULE_SETUP
 #line 38 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (NOT); }
-  YY_BREAK
+       YY_BREAK
 case 9:
 YY_RULE_SETUP
 #line 39 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (LEFT_PAR); }
-  YY_BREAK
+       YY_BREAK
 case 10:
 YY_RULE_SETUP
 #line 40 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (RIGHT_PAR); }
-  YY_BREAK
+       YY_BREAK
 case 11:
 YY_RULE_SETUP
 #line 41 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (CASE); }
-  YY_BREAK
+       YY_BREAK
 case 12:
 YY_RULE_SETUP
 #line 42 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (COLON); }
-  YY_BREAK
+       YY_BREAK
 case 13:
 YY_RULE_SETUP
 #line 43 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (SEMI_COLON); }
-  YY_BREAK
+       YY_BREAK
 case 14:
 YY_RULE_SETUP
 #line 44 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (CASE_TRUE); }
-  YY_BREAK
+       YY_BREAK
 case 15:
 YY_RULE_SETUP
 #line 45 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (LEFT_BRACE); }
-  YY_BREAK
+       YY_BREAK
 case 16:
 YY_RULE_SETUP
 #line 46 "parserPromela.lex"
 { printf("%s", xbt_automaton_parse_text); return (RIGHT_BRACE); }
-  YY_BREAK
+       YY_BREAK
 case 17:
 /* rule 17 can match eol */
 YY_RULE_SETUP
 #line 49 "parserPromela.lex"
 { printf(" ");}
-  YY_BREAK
+       YY_BREAK
 case 18:
 YY_RULE_SETUP
 #line 51 "parserPromela.lex"
 { printf("%s",xbt_automaton_parse_text); }
-  YY_BREAK
+       YY_BREAK
 case 19:
 YY_RULE_SETUP
 #line 54 "parserPromela.lex"
 { printf("%s",xbt_automaton_parse_text); 
                             sscanf(xbt_automaton_parse_text,"%lf",&yylval.real); 
                             return (LITT_REEL); }
-  YY_BREAK
+       YY_BREAK
 case 20:
 YY_RULE_SETUP
 #line 58 "parserPromela.lex"
 { printf("%s",xbt_automaton_parse_text); 
                             sscanf(xbt_automaton_parse_text,"%d",&yylval.integer); 
                             return (LITT_ENT); }
-  YY_BREAK
+       YY_BREAK
 case 21:
 /* rule 21 can match eol */
 YY_RULE_SETUP
@@ -916,395 +916,395 @@ YY_RULE_SETUP
                             yylval.string=(char *)malloc(strlen(xbt_automaton_parse_text)+1);
                             sscanf(xbt_automaton_parse_text,"%s",yylval.string); 
                             return (LITT_CHAINE); }
-  YY_BREAK
+       YY_BREAK
 case 22:
 YY_RULE_SETUP
 #line 67 "parserPromela.lex"
 { printf("%s",xbt_automaton_parse_text); 
-          yylval.string=(char *)malloc(strlen(xbt_automaton_parse_text)+1);
-          sscanf(xbt_automaton_parse_text,"%s",yylval.string);
-          return (ID); }
-  YY_BREAK
+                           yylval.string=(char *)malloc(strlen(xbt_automaton_parse_text)+1);
+                           sscanf(xbt_automaton_parse_text,"%s",yylval.string);
+                           return (ID); }
+       YY_BREAK
 case 23:
 /* rule 23 can match eol */
 YY_RULE_SETUP
 #line 72 "parserPromela.lex"
 { printf("\n"); }
-  YY_BREAK
+       YY_BREAK
 case 24:
 YY_RULE_SETUP
 #line 74 "parserPromela.lex"
 { printf("caractère inconnu\n"); }
-  YY_BREAK
+       YY_BREAK
 case 25:
 YY_RULE_SETUP
 #line 76 "parserPromela.lex"
 ECHO;
-  YY_BREAK
+       YY_BREAK
 #line 945 "automaton_parse.yy.c"
 case YY_STATE_EOF(INITIAL):
-  yyterminate();
-
-  case YY_END_OF_BUFFER:
-    {
-    /* Amount of text matched not including the EOB char. */
-    int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
-
-    /* Undo the effects of YY_DO_BEFORE_ACTION. */
-    *yy_cp = (yy_hold_char);
-    YY_RESTORE_YY_MORE_OFFSET
-
-    if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
-      {
-      /* We're scanning a new file or input source.  It's
-       * possible that this happened because the user
-       * just pointed xbt_automaton_parse_in at a new source and called
-       * xbt_automaton_parse_lex().  If so, then we have to assure
-       * consistency between YY_CURRENT_BUFFER and our
-       * globals.  Here is the right place to do so, because
-       * this is the first action (other than possibly a
-       * back-up) that will match for the new input source.
-       */
-      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
-      YY_CURRENT_BUFFER_LVALUE->yy_input_file = xbt_automaton_parse_in;
-      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
-      }
-
-    /* Note that here we test for yy_c_buf_p "<=" to the position
-     * of the first EOB in the buffer, since yy_c_buf_p will
-     * already have been incremented past the NUL character
-     * (since all states make transitions on EOB to the
-     * end-of-buffer state).  Contrast this with the test
-     * in input().
-     */
-    if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
-      { /* This was really a NUL. */
-      yy_state_type yy_next_state;
-
-      (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
-
-      yy_current_state = yy_get_previous_state(  );
-
-      /* Okay, we're now positioned to make the NUL
-       * trans