regenerate with Flex 2.6.4

diff --git a/src/xbt/automaton/automaton_lexer.yy.c b/src/xbt/automaton/automaton_lexer.yy.c
index 3958730..98e6db8 100644 (file)
--- a/src/xbt/automaton/automaton_lexer.yy.c
+++ b/src/xbt/automaton/automaton_lexer.yy.c
@@ -8,11 +8,17 @@
 
 #define yy_create_buffer xbt_automaton_parser__create_buffer
 #define yy_delete_buffer xbt_automaton_parser__delete_buffer
 
 #define yy_create_buffer xbt_automaton_parser__create_buffer
 #define yy_delete_buffer xbt_automaton_parser__delete_buffer

-#define yy_flex_debug xbt_automaton_parser__flex_debug
+#define yy_scan_buffer xbt_automaton_parser__scan_buffer
+#define yy_scan_string xbt_automaton_parser__scan_string
+#define yy_scan_bytes xbt_automaton_parser__scan_bytes

 #define yy_init_buffer xbt_automaton_parser__init_buffer
 #define yy_flush_buffer xbt_automaton_parser__flush_buffer
 #define yy_load_buffer_state xbt_automaton_parser__load_buffer_state
 #define yy_switch_to_buffer xbt_automaton_parser__switch_to_buffer
 #define yy_init_buffer xbt_automaton_parser__init_buffer
 #define yy_flush_buffer xbt_automaton_parser__flush_buffer
 #define yy_load_buffer_state xbt_automaton_parser__load_buffer_state
 #define yy_switch_to_buffer xbt_automaton_parser__switch_to_buffer

+#define yypush_buffer_state xbt_automaton_parser_push_buffer_state
+#define yypop_buffer_state xbt_automaton_parser_pop_buffer_state
+#define yyensure_buffer_stack xbt_automaton_parser_ensure_buffer_stack
+#define yy_flex_debug xbt_automaton_parser__flex_debug

 #define yyin xbt_automaton_parser_in
 #define yyleng xbt_automaton_parser_leng
 #define yylex xbt_automaton_parser_lex
 #define yyin xbt_automaton_parser_in
 #define yyleng xbt_automaton_parser_leng
 #define yylex xbt_automaton_parser_lex


@@ -28,11 +34,245 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 6
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 6

-#define YY_FLEX_SUBMINOR_VERSION 1
+#define YY_FLEX_SUBMINOR_VERSION 4

 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
 
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
 

+#ifdef yy_create_buffer
+#define xbt_automaton_parser__create_buffer_ALREADY_DEFINED
+#else
+#define yy_create_buffer xbt_automaton_parser__create_buffer
+#endif
+
+#ifdef yy_delete_buffer
+#define xbt_automaton_parser__delete_buffer_ALREADY_DEFINED
+#else
+#define yy_delete_buffer xbt_automaton_parser__delete_buffer
+#endif
+
+#ifdef yy_scan_buffer
+#define xbt_automaton_parser__scan_buffer_ALREADY_DEFINED
+#else
+#define yy_scan_buffer xbt_automaton_parser__scan_buffer
+#endif
+
+#ifdef yy_scan_string
+#define xbt_automaton_parser__scan_string_ALREADY_DEFINED
+#else
+#define yy_scan_string xbt_automaton_parser__scan_string
+#endif
+
+#ifdef yy_scan_bytes
+#define xbt_automaton_parser__scan_bytes_ALREADY_DEFINED
+#else
+#define yy_scan_bytes xbt_automaton_parser__scan_bytes
+#endif
+
+#ifdef yy_init_buffer
+#define xbt_automaton_parser__init_buffer_ALREADY_DEFINED
+#else
+#define yy_init_buffer xbt_automaton_parser__init_buffer
+#endif
+
+#ifdef yy_flush_buffer
+#define xbt_automaton_parser__flush_buffer_ALREADY_DEFINED
+#else
+#define yy_flush_buffer xbt_automaton_parser__flush_buffer
+#endif
+
+#ifdef yy_load_buffer_state
+#define xbt_automaton_parser__load_buffer_state_ALREADY_DEFINED
+#else
+#define yy_load_buffer_state xbt_automaton_parser__load_buffer_state
+#endif
+
+#ifdef yy_switch_to_buffer
+#define xbt_automaton_parser__switch_to_buffer_ALREADY_DEFINED
+#else
+#define yy_switch_to_buffer xbt_automaton_parser__switch_to_buffer
+#endif
+
+#ifdef yypush_buffer_state
+#define xbt_automaton_parser_push_buffer_state_ALREADY_DEFINED
+#else
+#define yypush_buffer_state xbt_automaton_parser_push_buffer_state
+#endif
+
+#ifdef yypop_buffer_state
+#define xbt_automaton_parser_pop_buffer_state_ALREADY_DEFINED
+#else
+#define yypop_buffer_state xbt_automaton_parser_pop_buffer_state
+#endif
+
+#ifdef yyensure_buffer_stack
+#define xbt_automaton_parser_ensure_buffer_stack_ALREADY_DEFINED
+#else
+#define yyensure_buffer_stack xbt_automaton_parser_ensure_buffer_stack
+#endif
+
+#ifdef yylex
+#define xbt_automaton_parser_lex_ALREADY_DEFINED
+#else
+#define yylex xbt_automaton_parser_lex
+#endif
+
+#ifdef yyrestart
+#define xbt_automaton_parser_restart_ALREADY_DEFINED
+#else
+#define yyrestart xbt_automaton_parser_restart
+#endif
+
+#ifdef yylex_init
+#define xbt_automaton_parser_lex_init_ALREADY_DEFINED
+#else
+#define yylex_init xbt_automaton_parser_lex_init
+#endif
+
+#ifdef yylex_init_extra
+#define xbt_automaton_parser_lex_init_extra_ALREADY_DEFINED
+#else
+#define yylex_init_extra xbt_automaton_parser_lex_init_extra
+#endif
+
+#ifdef yylex_destroy
+#define xbt_automaton_parser_lex_destroy_ALREADY_DEFINED
+#else
+#define yylex_destroy xbt_automaton_parser_lex_destroy
+#endif
+
+#ifdef yyget_debug
+#define xbt_automaton_parser_get_debug_ALREADY_DEFINED
+#else
+#define yyget_debug xbt_automaton_parser_get_debug
+#endif
+
+#ifdef yyset_debug
+#define xbt_automaton_parser_set_debug_ALREADY_DEFINED
+#else
+#define yyset_debug xbt_automaton_parser_set_debug
+#endif
+
+#ifdef yyget_extra
+#define xbt_automaton_parser_get_extra_ALREADY_DEFINED
+#else
+#define yyget_extra xbt_automaton_parser_get_extra
+#endif
+
+#ifdef yyset_extra
+#define xbt_automaton_parser_set_extra_ALREADY_DEFINED
+#else
+#define yyset_extra xbt_automaton_parser_set_extra
+#endif
+
+#ifdef yyget_in
+#define xbt_automaton_parser_get_in_ALREADY_DEFINED
+#else
+#define yyget_in xbt_automaton_parser_get_in
+#endif
+
+#ifdef yyset_in
+#define xbt_automaton_parser_set_in_ALREADY_DEFINED
+#else
+#define yyset_in xbt_automaton_parser_set_in
+#endif
+
+#ifdef yyget_out
+#define xbt_automaton_parser_get_out_ALREADY_DEFINED
+#else
+#define yyget_out xbt_automaton_parser_get_out
+#endif
+
+#ifdef yyset_out
+#define xbt_automaton_parser_set_out_ALREADY_DEFINED
+#else
+#define yyset_out xbt_automaton_parser_set_out
+#endif
+
+#ifdef yyget_leng
+#define xbt_automaton_parser_get_leng_ALREADY_DEFINED
+#else
+#define yyget_leng xbt_automaton_parser_get_leng
+#endif
+
+#ifdef yyget_text
+#define xbt_automaton_parser_get_text_ALREADY_DEFINED
+#else
+#define yyget_text xbt_automaton_parser_get_text
+#endif
+
+#ifdef yyget_lineno
+#define xbt_automaton_parser_get_lineno_ALREADY_DEFINED
+#else
+#define yyget_lineno xbt_automaton_parser_get_lineno
+#endif
+
+#ifdef yyset_lineno
+#define xbt_automaton_parser_set_lineno_ALREADY_DEFINED
+#else
+#define yyset_lineno xbt_automaton_parser_set_lineno
+#endif
+
+#ifdef yywrap
+#define xbt_automaton_parser_wrap_ALREADY_DEFINED
+#else
+#define yywrap xbt_automaton_parser_wrap
+#endif
+
+#ifdef yyalloc
+#define xbt_automaton_parser_alloc_ALREADY_DEFINED
+#else
+#define yyalloc xbt_automaton_parser_alloc
+#endif
+
+#ifdef yyrealloc
+#define xbt_automaton_parser_realloc_ALREADY_DEFINED
+#else
+#define yyrealloc xbt_automaton_parser_realloc
+#endif
+
+#ifdef yyfree
+#define xbt_automaton_parser_free_ALREADY_DEFINED
+#else
+#define yyfree xbt_automaton_parser_free
+#endif
+
+#ifdef yytext
+#define xbt_automaton_parser_text_ALREADY_DEFINED
+#else
+#define yytext xbt_automaton_parser_text
+#endif
+
+#ifdef yyleng
+#define xbt_automaton_parser_leng_ALREADY_DEFINED
+#else
+#define yyleng xbt_automaton_parser_leng
+#endif
+
+#ifdef yyin
+#define xbt_automaton_parser_in_ALREADY_DEFINED
+#else
+#define yyin xbt_automaton_parser_in
+#endif
+
+#ifdef yyout
+#define xbt_automaton_parser_out_ALREADY_DEFINED
+#else
+#define yyout xbt_automaton_parser_out
+#endif
+
+#ifdef yy_flex_debug
+#define xbt_automaton_parser__flex_debug_ALREADY_DEFINED
+#else
+#define yy_flex_debug xbt_automaton_parser__flex_debug
+#endif
+
+#ifdef yylineno
+#define xbt_automaton_parser_lineno_ALREADY_DEFINED
+#else
+#define yylineno xbt_automaton_parser_lineno
+#endif
+

 /* First, we deal with  platform-specific or compiler-specific issues. */
 
 /* begin standard C headers. */
 /* First, we deal with  platform-specific or compiler-specific issues. */
 
 /* begin standard C headers. */


@@ -53,7 +293,7 @@
 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 
 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 
 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,

- * if you want the limit (max/min) macros for int types.
+ * if you want the limit (max/min) macros for int types. 

  */
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS 1
  */
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS 1


@@ -70,7 +310,7 @@ typedef uint32_t flex_uint32_t;
 typedef signed char flex_int8_t;
 typedef short int flex_int16_t;
 typedef int flex_int32_t;
 typedef signed char flex_int8_t;
 typedef short int flex_int16_t;
 typedef int flex_int32_t;

-typedef unsigned char flex_uint8_t;
+typedef unsigned char flex_uint8_t; 

 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
 
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
 


@@ -103,10 +343,16 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
 #define UINT32_MAX             (4294967295U)
 #endif
 

+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+

 #endif /* ! C99 */
 
 #endif /* ! FLEXINT_H */
 
 #endif /* ! C99 */
 
 #endif /* ! FLEXINT_H */
 

+/* begin standard C++ headers. */
+

 /* TODO: this is always defined, so inline it */
 #define yyconst const
 
 /* TODO: this is always defined, so inline it */
 #define yyconst const
 


@@ -119,32 +365,26 @@ typedef unsigned int flex_uint32_t;
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 

-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index.  If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.

  */
  */

-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))

 
 /* Enter a start condition.  This macro really ought to take a parameter,
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
 #define BEGIN (yy_start) = 1 + 2 *
 
 /* Enter a start condition.  This macro really ought to take a parameter,
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
 #define BEGIN (yy_start) = 1 + 2 *

-

 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
 #define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
 #define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START

-

 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

-

 /* Special action meaning "start processing a new file". */
 /* Special action meaning "start processing a new file". */

-#define YY_NEW_FILE xbt_automaton_parser_restart(xbt_automaton_parser_in  )
-
+#define YY_NEW_FILE yyrestart( yyin  )

 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */


@@ -174,97 +414,101 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
 typedef size_t yy_size_t;
 #endif
 
 typedef size_t yy_size_t;
 #endif
 

-extern int xbt_automaton_parser_leng;
+extern int yyleng;

 
 

-extern FILE *xbt_automaton_parser_in, *xbt_automaton_parser_out;
+extern FILE *yyin, *yyout;

 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2

-
+    

     #define YY_LESS_LINENO(n)
     #define YY_LINENO_REWIND_TO(ptr)
     #define YY_LESS_LINENO(n)
     #define YY_LINENO_REWIND_TO(ptr)

-
+    

 /* Return all but the first "n" matched characters back to the input stream. */
 /* Return all but the first "n" matched characters back to the input stream. */

-#define yyless(n)                                                                                                      \
-  do {                                                                                                                 \
-    /* Undo effects of setting up xbt_automaton_parser_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_parser_text again */                                                  \
-  } while (0)
-
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up yytext. */ \
+        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 yytext again */ \
+               } \
+       while ( 0 )

 #define unput(c) yyunput( c, (yytext_ptr)  )
 
 #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE
 #define unput(c) yyunput( c, (yytext_ptr)  )
 
 #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.
-   */
-  int 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;
-
-  int yy_buffer_status;
+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.
+        */
+       int 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;
+
+       int yy_buffer_status;

 
 #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1
 
 #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_parser_restart()), so that the user can continue scanning by
-   * just pointing xbt_automaton_parser_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 yyrestart()), so that the user can continue scanning by
+        * just pointing yyin at a new input file.
+        */

 #define YY_BUFFER_EOF_PENDING 2
 #define YY_BUFFER_EOF_PENDING 2

-};
+
+       };

 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
 /* Stack of input buffers. */
 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 
 /* Stack of input buffers. */
 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */

-static YY_BUFFER_STATE* yy_buffer_stack = NULL; /**< Stack as an array. */
+static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */

 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general


@@ -275,116 +519,111 @@ static YY_BUFFER_STATE* yy_buffer_stack = NULL; /**< Stack as an array. */
 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                           : NULL)
 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                           : NULL)

-

 /* Same as previous macro, but useful when we know that the buffer stack is not
  * NULL or when we need an lvalue. For internal use only.
  */
 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 
 /* Same as previous macro, but useful when we know that the buffer stack is not
  * NULL or when we need an lvalue. For internal use only.
  */
 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 

-/* yy_hold_char holds the character lost when xbt_automaton_parser_text is formed. */
+/* yy_hold_char holds the character lost when yytext is formed. */

 static char yy_hold_char;
 static char yy_hold_char;

-static int yy_n_chars; /* number of characters read into yy_ch_buf */
-int xbt_automaton_parser_leng;
+static int yy_n_chars;         /* number of characters read into yy_ch_buf */
+int yyleng;

 
 /* Points to current character in buffer. */
 
 /* Points to current character in buffer. */

-static char* yy_c_buf_p = NULL;
-static int yy_init      = 0; /* whether we need to initialize */
-static int yy_start     = 0; /* start state number */
+static char *yy_c_buf_p = NULL;
+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_parser_wrap()'s to do buffer switches
- * instead of setting up a fresh xbt_automaton_parser_in.  A bit of a hack ...
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...

  */
 static int yy_did_buffer_switch_on_eof;
 
  */
 static int yy_did_buffer_switch_on_eof;
 

-void xbt_automaton_parser_restart (FILE *input_file  );
-void xbt_automaton_parser__switch_to_buffer (YY_BUFFER_STATE new_buffer  );
-YY_BUFFER_STATE xbt_automaton_parser__create_buffer (FILE *file,int size  );
-void xbt_automaton_parser__delete_buffer (YY_BUFFER_STATE b  );
-void xbt_automaton_parser__flush_buffer (YY_BUFFER_STATE b  );
-void xbt_automaton_parser_push_buffer_state (YY_BUFFER_STATE new_buffer  );
-void xbt_automaton_parser_pop_buffer_state (void );
-
-static void xbt_automaton_parser_ensure_buffer_stack (void );
-static void xbt_automaton_parser__load_buffer_state (void );
-static void xbt_automaton_parser__init_buffer (YY_BUFFER_STATE b,FILE *file  );
-
-#define YY_FLUSH_BUFFER xbt_automaton_parser__flush_buffer(YY_CURRENT_BUFFER )
-
-YY_BUFFER_STATE xbt_automaton_parser__scan_buffer (char *base,yy_size_t size  );
-YY_BUFFER_STATE xbt_automaton_parser__scan_string (yyconst char *yy_str  );
-YY_BUFFER_STATE xbt_automaton_parser__scan_bytes(yyconst char* bytes, int len);
-
-void *xbt_automaton_parser_alloc (yy_size_t  );
-void *xbt_automaton_parser_realloc (void *,yy_size_t  );
-void xbt_automaton_parser_free (void *  );
-
-#define yy_new_buffer xbt_automaton_parser__create_buffer
-
-#define yy_set_interactive(is_interactive)                                                                             \
-  {                                                                                                                    \
-    if (!YY_CURRENT_BUFFER) {                                                                                          \
-      xbt_automaton_parser_ensure_buffer_stack();                                                                      \
-      YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);            \
-    }                                                                                                                  \
-    YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive;                                                      \
-  }
-
-#define yy_set_bol(at_bol)                                                                                             \
-  {                                                                                                                    \
-    if (!YY_CURRENT_BUFFER) {                                                                                          \
-      xbt_automaton_parser_ensure_buffer_stack();                                                                      \
-      YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);            \
-    }                                                                                                                  \
-    YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol;                                                                      \
-  }
-
+void yyrestart ( FILE *input_file  );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size  );
+void yy_delete_buffer ( YY_BUFFER_STATE b  );
+void yy_flush_buffer ( YY_BUFFER_STATE b  );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state ( void );
+
+static void yyensure_buffer_stack ( void );
+static void yy_load_buffer_state ( void );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
+
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len  );
+
+void *yyalloc ( yy_size_t  );
+void *yyrealloc ( void *, yy_size_t  );
+void yyfree ( void *  );
+
+#define yy_new_buffer yy_create_buffer
+#define yy_set_interactive(is_interactive) \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){ \
+        yyensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+       }
+#define yy_set_bol(at_bol) \
+       { \
+       if ( ! YY_CURRENT_BUFFER ){\
+        yyensure_buffer_stack (); \
+               YY_CURRENT_BUFFER_LVALUE =    \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
+       } \
+       YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+       }

 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
 /* Begin user sect3 */
 
 #define xbt_automaton_parser_wrap() (/*CONSTCOND*/1)
 #define YY_SKIP_YYWRAP
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
 /* Begin user sect3 */
 
 #define xbt_automaton_parser_wrap() (/*CONSTCOND*/1)
 #define YY_SKIP_YYWRAP

+typedef flex_uint8_t YY_CHAR;

 
 

-typedef unsigned char YY_CHAR;
-
-FILE *xbt_automaton_parser_in = NULL, *xbt_automaton_parser_out = NULL;
+FILE *yyin = NULL, *yyout = NULL;

 
 typedef int yy_state_type;
 
 
 typedef int yy_state_type;
 

-extern int xbt_automaton_parser_lineno;
+extern int yylineno;
+int yylineno = 1;

 
 

-int xbt_automaton_parser_lineno = 1;
-
-extern char *xbt_automaton_parser_text;
+extern char *yytext;

 #ifdef yytext_ptr
 #undef yytext_ptr
 #endif
 #ifdef yytext_ptr
 #undef yytext_ptr
 #endif

-#define yytext_ptr xbt_automaton_parser_text
+#define yytext_ptr yytext

 
 

-static yy_state_type yy_get_previous_state (void );
-static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
-static int yy_get_next_buffer (void );
-static void yynoreturn yy_fatal_error(yyconst char* msg);
+static yy_state_type yy_get_previous_state ( void );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  );
+static int yy_get_next_buffer ( void );
+static void yynoreturn yy_fatal_error ( const char* msg  );

 
 /* Done after the current pattern has been matched and before the
 
 /* Done after the current pattern has been matched and before the

- * corresponding action - sets up xbt_automaton_parser_text.
+ * corresponding action - sets up yytext.

  */
  */

-#define YY_DO_BEFORE_ACTION                                                                                            \
-  (yytext_ptr)              = yy_bp;                                                                                   \
-  xbt_automaton_parser_leng = (int)(yy_cp - yy_bp);                                                                    \
-  (yy_hold_char)            = *yy_cp;                                                                                  \
-  *yy_cp                    = '\0';                                                                                    \
-  (yy_c_buf_p)              = yy_cp;
-
+#define YY_DO_BEFORE_ACTION \
+       (yytext_ptr) = yy_bp; \
+       yyleng = (int) (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. */
 #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;
-};
-static yyconst flex_int16_t yy_accept[54] =
+struct yy_trans_info
+       {
+       flex_int32_t yy_verify;
+       flex_int32_t yy_nxt;
+       };
+static const flex_int16_t yy_accept[54] =

     {   0,
         0,    0,   26,   24,   18,   23,    8,   24,   24,    9,
        10,   24,   24,   20,   14,   12,   13,   22,   22,   22,
     {   0,
         0,    0,   26,   24,   18,   23,    8,   24,   24,    9,
        10,   24,   24,   20,   14,   12,   13,   22,   22,   22,


@@ -394,7 +633,7 @@ static yyconst flex_int16_t yy_accept[54] =
        22,    1,    0
     } ;
 
        22,    1,    0
     } ;
 

-static yyconst YY_CHAR yy_ec[256] =
+static const YY_CHAR yy_ec[256] =

     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,


@@ -426,7 +665,7 @@ static yyconst YY_CHAR yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
         1,    1,    1,    1,    1
     } ;
 

-static yyconst YY_CHAR yy_meta[34] =
+static const YY_CHAR yy_meta[34] =

     {   0,
         1,    1,    2,    2,    1,    2,    1,    1,    1,    1,
         1,    1,    3,    4,    4,    1,    1,    1,    4,    2,
     {   0,
         1,    1,    2,    2,    1,    2,    1,    1,    1,    1,
         1,    1,    3,    4,    4,    1,    1,    1,    4,    2,


@@ -434,7 +673,7 @@ static yyconst YY_CHAR yy_meta[34] =
         1,    1,    1
     } ;
 
         1,    1,    1
     } ;
 

-static yyconst flex_uint16_t yy_base[57] =
+static const flex_int16_t yy_base[57] =

     {   0,
         0,    0,   89,   90,   32,   90,   90,   34,   81,   90,
        90,   69,   76,   27,   31,   69,   90,    0,   59,   56,
     {   0,
         0,    0,   89,   90,   32,   90,   90,   34,   81,   90,
        90,   69,   76,   27,   31,   69,   90,    0,   59,   56,


@@ -444,7 +683,7 @@ static yyconst flex_uint16_t yy_base[57] =
        16,    0,   90,   74,   31,   78
     } ;
 
        16,    0,   90,   74,   31,   78
     } ;
 

-static yyconst flex_int16_t yy_def[57] =
+static const flex_int16_t yy_def[57] =

     {   0,
        53,    1,   53,   53,   53,   53,   53,   54,   53,   53,
        53,   53,   53,   53,   53,   53,   53,   55,   55,   55,
     {   0,
        53,    1,   53,   53,   53,   53,   53,   54,   53,   53,
        53,   53,   53,   53,   53,   53,   53,   55,   55,   55,


@@ -454,7 +693,7 @@ static yyconst flex_int16_t yy_def[57] =
        55,   55,    0,   53,   53,   53
     } ;
 
        55,   55,    0,   53,   53,   53
     } ;
 

-static yyconst flex_uint16_t yy_nxt[124] =
+static const flex_int16_t yy_nxt[124] =

     {   0,
         4,    5,    6,    5,    7,    8,    9,   10,   11,    4,
        12,    4,   13,   14,   15,   16,   17,    4,   18,    4,
     {   0,
         4,    5,    6,    5,    7,    8,    9,   10,   11,    4,
        12,    4,   13,   14,   15,   16,   17,    4,   18,    4,


@@ -472,7 +711,7 @@ static yyconst flex_uint16_t yy_nxt[124] =
        53,   53,   53
     } ;
 
        53,   53,   53
     } ;
 

-static yyconst flex_int16_t yy_chk[124] =
+static const flex_int16_t yy_chk[124] =

     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,


@@ -493,8 +732,8 @@ static yyconst flex_int16_t yy_chk[124] =
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
 
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
 

-extern int xbt_automaton_parser__flex_debug;
-int xbt_automaton_parser__flex_debug = 0;
+extern int yy_flex_debug;
+int yy_flex_debug = 0;

 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.


@@ -503,7 +742,7 @@ int xbt_automaton_parser__flex_debug = 0;
 #define yymore() yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET
 #define yymore() yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
 #define YY_RESTORE_YY_MORE_OFFSET

-char *xbt_automaton_parser_text;
+char *yytext;

 #line 1 "parserPromela.lex"
 /* Copyright (c) 2012-2019. The SimGrid Team.
  * All rights reserved.                                                     */
 #line 1 "parserPromela.lex"
 /* Copyright (c) 2012-2019. The SimGrid Team.
  * All rights reserved.                                                     */


@@ -521,7 +760,8 @@ char *xbt_automaton_parser_text;
 
   extern YYSTYPE yylval;
 
 
   extern YYSTYPE yylval;
 

-#line 533 "automaton_lexer.yy.c"
+#line 764 "automaton_lexer.yy.c"
+#line 765 "automaton_lexer.yy.c"

 
 #define INITIAL 0
 
 
 #define INITIAL 0
 


@@ -537,36 +777,36 @@ char *xbt_automaton_parser_text;
 #define YY_EXTRA_TYPE void *
 #endif
 
 #define YY_EXTRA_TYPE void *
 #endif
 

-static int yy_init_globals (void );
+static int yy_init_globals ( void );

 
 /* Accessor methods to globals.
    These are made visible to non-reentrant scanners for convenience. */
 
 
 /* Accessor methods to globals.
    These are made visible to non-reentrant scanners for convenience. */
 

-int xbt_automaton_parser_lex_destroy (void );
+int yylex_destroy ( void );

 
 

-int xbt_automaton_parser_get_debug (void );
+int yyget_debug ( void );

 
 

-void xbt_automaton_parser_set_debug (int debug_flag  );
+void yyset_debug ( int debug_flag  );

 
 

-YY_EXTRA_TYPE xbt_automaton_parser_get_extra (void );
+YY_EXTRA_TYPE yyget_extra ( void );

 
 

-void xbt_automaton_parser_set_extra (YY_EXTRA_TYPE user_defined  );
+void yyset_extra ( YY_EXTRA_TYPE user_defined  );

 
 

-FILE *xbt_automaton_parser_get_in (void );
+FILE *yyget_in ( void );

 
 

-void xbt_automaton_parser_set_in  (FILE * _in_str  );
+void yyset_in  ( FILE * _in_str  );

 
 

-FILE *xbt_automaton_parser_get_out (void );
+FILE *yyget_out ( void );

 
 

-void xbt_automaton_parser_set_out  (FILE * _out_str  );
+void yyset_out  ( FILE * _out_str  );

 
 

-int xbt_automaton_parser_get_leng(void);
+                       int yyget_leng ( void );

 
 

-char *xbt_automaton_parser_get_text (void );
+char *yyget_text ( void );

 
 

-int xbt_automaton_parser_get_lineno (void );
+int yyget_lineno ( void );

 
 

-void xbt_automaton_parser_set_lineno (int _line_number  );
+void yyset_lineno ( int _line_number  );

 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.


@@ -574,32 +814,31 @@ void xbt_automaton_parser_set_lineno (int _line_number  );
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus

-extern "C" int xbt_automaton_parser_wrap (void );
+extern "C" int yywrap ( void );

 #else
 #else

-extern int xbt_automaton_parser_wrap (void );
+extern int yywrap ( void );

 #endif
 #endif
 
 #ifndef YY_NO_UNPUT
 #endif
 #endif
 
 #ifndef YY_NO_UNPUT

-
-    static void yyunput (int c,char *buf_ptr  );
-
+    
+    static void yyunput ( int c, char *buf_ptr  );
+    

 #endif
 
 #ifndef yytext_ptr
 #endif
 
 #ifndef yytext_ptr

-static void yy_flex_strncpy (char *,yyconst char *,int );
+static void yy_flex_strncpy ( char *, const char *, int );

 #endif
 
 #ifdef YY_NEED_STRLEN
 #endif
 
 #ifdef YY_NEED_STRLEN

-static int yy_flex_strlen (yyconst char * );
+static int yy_flex_strlen ( const char * );

 #endif
 
 #ifndef YY_NO_INPUT
 #endif
 
 #ifndef YY_NO_INPUT

-

 #ifdef __cplusplus
 #ifdef __cplusplus

-static int yyinput (void );
+static int yyinput ( void );

 #else
 #else

-static int input (void );
+static int input ( void );

 #endif
 
 #endif
 #endif
 
 #endif


@@ -619,39 +858,42 @@ static int input (void );
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */

-#define ECHO                                                                                                           \
-  do {                                                                                                                 \
-    if (fwrite(xbt_automaton_parser_text, (size_t)xbt_automaton_parser_leng, 1, xbt_automaton_parser_out)) {           \
-    }                                                                                                                  \
-  } while (0)
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)

 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  * is returned in "result".
  */
 #ifndef YY_INPUT
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  * is returned in "result".
  */
 #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_parser_in)) != EOF && c != '\n'; ++n)                          \
-      buf[n] = (char)c;                                                                                                \
-    if (c == '\n')                                                                                                     \
-      buf[n++] = (char)c;                                                                                              \
-    if (c == EOF && ferror(xbt_automaton_parser_in))                                                                   \
-      YY_FATAL_ERROR("input in flex scanner failed");                                                                  \
-    result = n;                                                                                                        \
-  } else {                                                                                                             \
-    errno = 0;                                                                                                         \
-    while ((result = (int)fread(buf, 1, max_size, xbt_automaton_parser_in)) == 0 && ferror(xbt_automaton_parser_in)) { \
-      if (errno != EINTR) {                                                                                            \
-        YY_FATAL_ERROR("input in flex scanner failed");                                                                \
-        break;                                                                                                         \
-      }                                                                                                                \
-      errno = 0;                                                                                                       \
-      clearerr(xbt_automaton_parser_in);                                                                               \
-    }                                                                                                                  \
-  }
+#define YY_INPUT(buf,result,max_size) \
+       if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+               { \
+               int c = '*'; \
+               int n; \
+               for ( n = 0; n < max_size && \
+                            (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+                       buf[n] = (char) c; \
+               if ( c == '\n' ) \
+                       buf[n++] = (char) c; \
+               if ( c == EOF && ferror( yyin ) ) \
+                       YY_FATAL_ERROR( "input in flex scanner failed" ); \
+               result = n; \
+               } \
+       else \
+               { \
+               errno=0; \
+               while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+                       { \
+                       if( errno != EINTR) \
+                               { \
+                               YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                               break; \
+                               } \
+                       errno=0; \
+                       clearerr(yyin); \
+                       } \
+               }\
+\

 
 #endif
 
 
 #endif
 


@@ -681,12 +923,12 @@ static int input (void );
 #ifndef YY_DECL
 #define YY_DECL_IS_OURS 1
 
 #ifndef YY_DECL
 #define YY_DECL_IS_OURS 1
 

-extern int xbt_automaton_parser_lex (void);
+extern int yylex (void);

 
 

-#define YY_DECL int xbt_automaton_parser_lex (void)
+#define YY_DECL int yylex (void)

 #endif /* !YY_DECL */
 
 #endif /* !YY_DECL */
 

-/* Code executed at the beginning of each rule, after xbt_automaton_parser_text and xbt_automaton_parser_leng
+/* Code executed at the beginning of each rule, after yytext and yyleng

  * have been set up.
  */
 #ifndef YY_USER_ACTION
  * have been set up.
  */
 #ifndef YY_USER_ACTION


@@ -698,351 +940,371 @@ extern int xbt_automaton_parser_lex (void);
 #define YY_BREAK /*LINTED*/break;
 #endif
 
 #define YY_BREAK /*LINTED*/break;
 #endif
 

-#define YY_RULE_SETUP YY_USER_ACTION
+#define YY_RULE_SETUP \
+       YY_USER_ACTION

 
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {
 
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {

-  yy_state_type yy_current_state;
-  char *yy_cp, *yy_bp;
-  int yy_act;
-
-  if (!(yy_init)) {
-    (yy_init) = 1;
+       yy_state_type yy_current_state;
+       char *yy_cp, *yy_bp;
+       int yy_act;
+    
+       if ( !(yy_init) )
+               {
+               (yy_init) = 1;

 
 #ifdef YY_USER_INIT
 
 #ifdef YY_USER_INIT

-    YY_USER_INIT;
+               YY_USER_INIT;

 #endif
 
 #endif
 

-    if (!(yy_start))
-      (yy_start) = 1; /* first start state */
+               if ( ! (yy_start) )
+                       (yy_start) = 1; /* first start state */

 
 

-    if (!xbt_automaton_parser_in)
-      xbt_automaton_parser_in = stdin;
+               if ( ! yyin )
+                       yyin = stdin;

 
 

-    if (!xbt_automaton_parser_out)
-      xbt_automaton_parser_out = stdout;
+               if ( ! yyout )
+                       yyout = stdout;

 
 

-    if (!YY_CURRENT_BUFFER) {
-      xbt_automaton_parser_ensure_buffer_stack();
-      YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);
-    }
+               if ( ! YY_CURRENT_BUFFER ) {
+                       yyensure_buffer_stack ();
+                       YY_CURRENT_BUFFER_LVALUE =
+                               yy_create_buffer( yyin, YY_BUF_SIZE );
+               }

 
 

-    xbt_automaton_parser__load_buffer_state();
-  }
+               yy_load_buffer_state(  );
+               }

 
 

-  {
+       {

 #line 38 "parserPromela.lex"
 
 #line 38 "parserPromela.lex"
 

-#line 754 "automaton_lexer.yy.c"
-
-    while (/*CONSTCOND*/ 1) /* loops until end-of-file is reached */
-    {
-      yy_cp = (yy_c_buf_p);
-
-      /* Support of xbt_automaton_parser_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_current_state = (yy_start);
-    yy_match:
-      do {
-        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] + (flex_int16_t)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;
-
-        case 1:
-          YY_RULE_SETUP
+
+#line 985 "automaton_lexer.yy.c"
+
+       while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
+               {
+               yy_cp = (yy_c_buf_p);
+
+               /* Support of yytext. */
+               *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_current_state = (yy_start);
+yy_match:
+               do
+                       {
+                       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[yy_c];
+                               }
+                       yy_current_state = yy_nxt[yy_base[yy_current_state] + 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;
+
+case 1:
+YY_RULE_SETUP

 #line 40 "parserPromela.lex"
 { return (NEVER); }
 #line 40 "parserPromela.lex"
 { return (NEVER); }

-YY_BREAK
+       YY_BREAK

 case 2:
 YY_RULE_SETUP
 #line 41 "parserPromela.lex"
 { return (IF); }
 case 2:
 YY_RULE_SETUP
 #line 41 "parserPromela.lex"
 { return (IF); }

-YY_BREAK
+       YY_BREAK

 case 3:
 YY_RULE_SETUP
 #line 42 "parserPromela.lex"
 { return (FI); }
 case 3:
 YY_RULE_SETUP
 #line 42 "parserPromela.lex"
 { return (FI); }

-YY_BREAK
+       YY_BREAK

 case 4:
 YY_RULE_SETUP
 #line 43 "parserPromela.lex"
 { return (IMPLIES); }
 case 4:
 YY_RULE_SETUP
 #line 43 "parserPromela.lex"
 { return (IMPLIES); }

-YY_BREAK
+       YY_BREAK

 case 5:
 YY_RULE_SETUP
 #line 44 "parserPromela.lex"
 { return (GOTO); }
 case 5:
 YY_RULE_SETUP
 #line 44 "parserPromela.lex"
 { return (GOTO); }

-YY_BREAK
+       YY_BREAK

 case 6:
 YY_RULE_SETUP
 #line 45 "parserPromela.lex"
 { return (AND); }
 case 6:
 YY_RULE_SETUP
 #line 45 "parserPromela.lex"
 { return (AND); }

-YY_BREAK
+       YY_BREAK

 case 7:
 YY_RULE_SETUP
 #line 46 "parserPromela.lex"
 { return (OR); }
 case 7:
 YY_RULE_SETUP
 #line 46 "parserPromela.lex"
 { return (OR); }

-YY_BREAK
+       YY_BREAK

 case 8:
 YY_RULE_SETUP
 #line 47 "parserPromela.lex"
 { return (NOT); }
 case 8:
 YY_RULE_SETUP
 #line 47 "parserPromela.lex"
 { return (NOT); }

-YY_BREAK
+       YY_BREAK

 case 9:
 YY_RULE_SETUP
 #line 48 "parserPromela.lex"
 { return (LEFT_PAR); }
 case 9:
 YY_RULE_SETUP
 #line 48 "parserPromela.lex"
 { return (LEFT_PAR); }

-YY_BREAK
+       YY_BREAK

 case 10:
 YY_RULE_SETUP
 #line 49 "parserPromela.lex"
 { return (RIGHT_PAR); }
 case 10:
 YY_RULE_SETUP
 #line 49 "parserPromela.lex"
 { return (RIGHT_PAR); }

-YY_BREAK
+       YY_BREAK

 case 11:
 YY_RULE_SETUP
 #line 50 "parserPromela.lex"
 { return (CASE); }
 case 11:
 YY_RULE_SETUP
 #line 50 "parserPromela.lex"
 { return (CASE); }

-YY_BREAK
+       YY_BREAK

 case 12:
 YY_RULE_SETUP
 #line 51 "parserPromela.lex"
 { return (COLON); }
 case 12:
 YY_RULE_SETUP
 #line 51 "parserPromela.lex"
 { return (COLON); }

-YY_BREAK
+       YY_BREAK

 case 13:
 YY_RULE_SETUP
 #line 52 "parserPromela.lex"
 { return (SEMI_COLON); }
 case 13:
 YY_RULE_SETUP
 #line 52 "parserPromela.lex"
 { return (SEMI_COLON); }

-YY_BREAK
+       YY_BREAK

 case 14:
 YY_RULE_SETUP
 #line 53 "parserPromela.lex"
 { return (CASE_TRUE); }
 case 14:
 YY_RULE_SETUP
 #line 53 "parserPromela.lex"
 { return (CASE_TRUE); }

-YY_BREAK
+       YY_BREAK

 case 15:
 YY_RULE_SETUP
 #line 54 "parserPromela.lex"
 { return (LEFT_BRACE); }
 case 15:
 YY_RULE_SETUP
 #line 54 "parserPromela.lex"
 { return (LEFT_BRACE); }

-YY_BREAK
+       YY_BREAK

 case 16:
 YY_RULE_SETUP
 #line 55 "parserPromela.lex"
 { return (RIGHT_BRACE); }
 case 16:
 YY_RULE_SETUP
 #line 55 "parserPromela.lex"
 { return (RIGHT_BRACE); }

-YY_BREAK
+       YY_BREAK

 case 17:
 /* rule 17 can match eol */
 YY_RULE_SETUP
 #line 58 "parserPromela.lex"
 { }
 case 17:
 /* rule 17 can match eol */
 YY_RULE_SETUP
 #line 58 "parserPromela.lex"
 { }

-YY_BREAK
+       YY_BREAK

 case 18:
 YY_RULE_SETUP
 #line 60 "parserPromela.lex"
 { }
 case 18:
 YY_RULE_SETUP
 #line 60 "parserPromela.lex"
 { }

-YY_BREAK
+       YY_BREAK

 case 19:
 YY_RULE_SETUP
 #line 63 "parserPromela.lex"
 case 19:
 YY_RULE_SETUP
 #line 63 "parserPromela.lex"

-{ sscanf(xbt_automaton_parser_text,"%lf",&yylval.real);
+{ sscanf(yytext,"%lf",&yylval.real);

                             return (LITT_REEL); }
                             return (LITT_REEL); }

-YY_BREAK
+       YY_BREAK

 case 20:
 YY_RULE_SETUP
 #line 66 "parserPromela.lex"
 case 20:
 YY_RULE_SETUP
 #line 66 "parserPromela.lex"

-{ sscanf(xbt_automaton_parser_text,"%d",&yylval.integer);
+{ sscanf(yytext,"%d",&yylval.integer);

                             return (LITT_ENT); }
                             return (LITT_ENT); }

-YY_BREAK
+       YY_BREAK

 case 21:
 /* rule 21 can match eol */
 YY_RULE_SETUP
 #line 69 "parserPromela.lex"
 case 21:
 /* rule 21 can match eol */
 YY_RULE_SETUP
 #line 69 "parserPromela.lex"

-{ yylval.string=(char *)malloc(strlen(xbt_automaton_parser_text)+1);
-                            sscanf(xbt_automaton_parser_text,"%s",yylval.string);
+{ yylval.string=(char *)malloc(strlen(yytext)+1);
+                            sscanf(yytext,"%s",yylval.string);

                             return (LITT_CHAINE); }
                             return (LITT_CHAINE); }

-YY_BREAK
+       YY_BREAK

 case 22:
 YY_RULE_SETUP
 #line 73 "parserPromela.lex"
 case 22:
 YY_RULE_SETUP
 #line 73 "parserPromela.lex"

-{ yylval.string=(char *)malloc(strlen(xbt_automaton_parser_text)+1);
-                            sscanf(xbt_automaton_parser_text,"%s",yylval.string);
-                            return (ID);
-}
-YY_BREAK
+{ yylval.string=(char *)malloc(strlen(yytext)+1);
+                            sscanf(yytext,"%s",yylval.string);
+                                             return (ID); }
+       YY_BREAK

 case 23:
 /* rule 23 can match eol */
 YY_RULE_SETUP
 #line 77 "parserPromela.lex"
 { }
 case 23:
 /* rule 23 can match eol */
 YY_RULE_SETUP
 #line 77 "parserPromela.lex"
 { }

-YY_BREAK
+       YY_BREAK

 case 24:
 YY_RULE_SETUP
 #line 79 "parserPromela.lex"
 { }
 case 24:
 YY_RULE_SETUP
 #line 79 "parserPromela.lex"
 { }

-YY_BREAK
+       YY_BREAK

 case 25:
 YY_RULE_SETUP
 #line 81 "parserPromela.lex"
 ECHO;
 case 25:
 YY_RULE_SETUP
 #line 81 "parserPromela.lex"
 ECHO;

-YY_BREAK
-#line 945 "automaton_lexer.yy.c"
+       YY_BREAK
+#line 1176 "automaton_lexer.yy.c"

 case YY_STATE_EOF(INITIAL):
 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_parser_in at a new source and called
-     * xbt_automaton_parser_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_parser_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 (xbt_automaton_parser_wrap()) {
-          /* Note: because we've taken care in
-           * yy_get_next_buffer() to have set up
-           * xbt_automaton_parser_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 user's declarations */
-} /* end of xbt_automaton_parser_lex */
+       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 yyin at a new source and called
+                        * yylex().  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 = yyin;
+                       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 ( yywrap(  ) )
+                                       {
+                                       /* Note: because we've taken care in
+                                        * yy_get_next_buffer() to have set up
+                                        * yytext, 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 user's declarations */
+} /* end of yylex */

 
 /* yy_get_next_buffer - try to read in a new buffer
  *
 
 /* yy_get_next_buffer - try to read in a new buffer
  *


@@ -1053,143 +1315,167 @@ default:
  */
 static int yy_get_next_buffer (void)
 {
  */
 static int yy_get_next_buffer (void)
 {

-  char* dest   = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
-  char* source = (yytext_ptr);
-  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_LVALUE;
-
-      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. */
-            xbt_automaton_parser_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 = NULL;
-
-      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), 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;
-      xbt_automaton_parser_restart(xbt_automaton_parser_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_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
-    /* Extend the array by 50%, plus the number we really need. */
-    int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf =
-        (char*)xbt_automaton_parser_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;
+       char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+       char *source = (yytext_ptr);
+       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_LVALUE;
+
+                       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. */
+                                       yyrealloc( (void *) b->yy_ch_buf,
+                                                        (yy_size_t) (b->yy_buf_size + 2)  );
+                               }
+                       else
+                               /* Can't grow it, we don't own it. */
+                               b->yy_ch_buf = NULL;
+
+                       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), 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;
+                       yyrestart( yyin  );
+                       }
+
+               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_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+               /* Extend the array by 50%, plus the number we really need. */
+               int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+                       (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size  );
+               if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+                       YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+               /* "- 2" to take care of EOB's */
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
+       }
+
+       (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;

 }
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
     static yy_state_type yy_get_previous_state (void)
 {
 }
 
 /* yy_get_previous_state - get the state just before the EOB char was reached */
 
     static yy_state_type yy_get_previous_state (void)
 {

-  yy_state_type yy_current_state;
-  char* yy_cp;
-
-  yy_current_state = (yy_start);
-
-  for (yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp) {
-    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 >= 54)
-        yy_c = yy_meta[(unsigned int)yy_c];
-    }
-    yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t)yy_c];
-  }
-
-  return yy_current_state;
+       yy_state_type yy_current_state;
+       char *yy_cp;
+    
+       yy_current_state = (yy_start);
+
+       for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+               {
+               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 >= 54 )
+                               yy_c = yy_meta[yy_c];
+                       }
+               yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+               }
+
+       return yy_current_state;

 }
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character
 }
 
 /* yy_try_NUL_trans - try to make a transition on the NUL character


@@ -1197,60 +1483,66 @@ static int yy_get_next_buffer (void)
  * synopsis
  *     next_state = yy_try_NUL_trans( current_state );
  */
  * synopsis
  *     next_state = yy_try_NUL_trans( current_state );
  */

-static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )

 {
 {

-  int yy_is_jam;
-  char* yy_cp = (yy_c_buf_p);
-
-  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 >= 54)
-      yy_c = yy_meta[(unsigned int)yy_c];
-  }
-  yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t)yy_c];
-  yy_is_jam        = (yy_current_state == 53);
-
-  return yy_is_jam ? 0 : yy_current_state;
+       int yy_is_jam;
+       char *yy_cp = (yy_c_buf_p);
+
+       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 >= 54 )
+                       yy_c = yy_meta[yy_c];
+               }
+       yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+       yy_is_jam = (yy_current_state == 53);
+
+               return yy_is_jam ? 0 : yy_current_state;

 }
 
 #ifndef YY_NO_UNPUT
 
     static void yyunput (int c, char * yy_bp )
 {
 }
 
 #ifndef YY_NO_UNPUT
 
     static void yyunput (int c, char * yy_bp )
 {

-  char* yy_cp;
-
-  yy_cp = (yy_c_buf_p);
-
-  /* undo effects of setting up xbt_automaton_parser_text */
-  *yy_cp = (yy_hold_char);
-
-  if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2) { /* need to shift things up to make room */
-    /* +2 for EOB chars. */
-    int number_to_move = (yy_n_chars) + 2;
-    char* dest         = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
-    char* source       = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
-
-    while (source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
-      *--dest = *--source;
-
-    yy_cp += (int)(dest - source);
-    yy_bp += (int)(dest - source);
-    YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = (int)YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
-
-    if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2)
-      YY_FATAL_ERROR("flex scanner push-back overflow");
-  }
-
-  *--yy_cp = (char)c;
-
-  (yytext_ptr)   = yy_bp;
-  (yy_hold_char) = *yy_cp;
-  (yy_c_buf_p)   = yy_cp;
+       char *yy_cp;
+    
+    yy_cp = (yy_c_buf_p);
+
+       /* undo effects of setting up yytext */
+       *yy_cp = (yy_hold_char);
+
+       if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+               { /* need to shift things up to make room */
+               /* +2 for EOB chars. */
+               int number_to_move = (yy_n_chars) + 2;
+               char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
+                                       YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
+               char *source =
+                               &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
+
+               while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+                       *--dest = *--source;
+
+               yy_cp += (int) (dest - source);
+               yy_bp += (int) (dest - source);
+               YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
+                       (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
+
+               if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
+                       YY_FATAL_ERROR( "flex scanner push-back overflow" );
+               }
+
+       *--yy_cp = (char) c;
+
+       (yytext_ptr) = yy_bp;
+       (yy_hold_char) = *yy_cp;
+       (yy_c_buf_p) = yy_cp;

 }
 
 #endif
 }
 
 #endif


@@ -1263,559 +1555,573 @@ static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
 #endif
 
 {
 #endif
 
 {

-  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. */
-          xbt_automaton_parser_restart(xbt_automaton_parser_in);
-
-          /*FALLTHROUGH*/
-
-        case EOB_ACT_END_OF_FILE: {
-          if (xbt_automaton_parser_wrap())
-            return 0;
-
-          if (!(yy_did_buffer_switch_on_eof))
-            YY_NEW_FILE;
+       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 = (int) ((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. */
+                                       yyrestart( yyin );
+
+                                       /*FALLTHROUGH*/
+
+                               case EOB_ACT_END_OF_FILE:
+                                       {
+                                       if ( yywrap(  ) )
+                                               return 0;
+
+                                       if ( ! (yy_did_buffer_switch_on_eof) )
+                                               YY_NEW_FILE;

 #ifdef __cplusplus
 #ifdef __cplusplus

-          return yyinput();
+                                       return yyinput();

 #else
 #else

-          return input();
+                                       return input();

 #endif
 #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 xbt_automaton_parser_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 yytext */
+       (yy_hold_char) = *++(yy_c_buf_p);

 
 

-  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.
 
 /** Immediately switch to a different input stream.
  * @param input_file A readable stream.

- *
+ * 

  * @note This function does not reset the start condition to @c INITIAL .
  */
  * @note This function does not reset the start condition to @c INITIAL .
  */

-void xbt_automaton_parser_restart(FILE* input_file)
+    void yyrestart  (FILE * input_file )

 {
 {

-
-  if (!YY_CURRENT_BUFFER) {
-    xbt_automaton_parser_ensure_buffer_stack();
-    YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);
-  }
-
-  xbt_automaton_parser__init_buffer(YY_CURRENT_BUFFER, input_file);
-  xbt_automaton_parser__load_buffer_state();
+    
+       if ( ! YY_CURRENT_BUFFER ){
+        yyensure_buffer_stack ();
+               YY_CURRENT_BUFFER_LVALUE =
+            yy_create_buffer( yyin, YY_BUF_SIZE );
+       }
+
+       yy_init_buffer( YY_CURRENT_BUFFER, input_file );
+       yy_load_buffer_state(  );

 }
 
 /** Switch to a different input buffer.
  * @param new_buffer The new input buffer.
 }
 
 /** Switch to a different input buffer.
  * @param new_buffer The new input buffer.

- *
+ * 

  */
  */

-void xbt_automaton_parser__switch_to_buffer(YY_BUFFER_STATE new_buffer)
+    void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )

 {
 {

-
-  /* TODO. We should be able to replace this entire function body
-   * with
-   *           xbt_automaton_parser_pop_buffer_state();
-   *           xbt_automaton_parser_push_buffer_state(new_buffer);
-   */
-  xbt_automaton_parser_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;
-  xbt_automaton_parser__load_buffer_state();
-
-  /* We don't actually know whether we did this switch during
-   * EOF (xbt_automaton_parser_wrap()) processing, but the only time this flag
-   * is looked at is after xbt_automaton_parser_wrap() is called, so it's safe
-   * to go ahead and always set it.
-   */
-  (yy_did_buffer_switch_on_eof) = 1;
+    
+       /* TODO. We should be able to replace this entire function body
+        * with
+        *              yypop_buffer_state();
+        *              yypush_buffer_state(new_buffer);
+     */
+       yyensure_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;
+       yy_load_buffer_state(  );
+
+       /* We don't actually know whether we did this switch during
+        * EOF (yywrap()) processing, but the only time this flag
+        * is looked at is after yywrap() is called, so it's safe
+        * to go ahead and always set it.
+        */
+       (yy_did_buffer_switch_on_eof) = 1;

 }
 
 }
 

-static void xbt_automaton_parser__load_buffer_state  (void)
+static void yy_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;
-  xbt_automaton_parser_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;
+       yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+       (yy_hold_char) = *(yy_c_buf_p);

 }
 
 /** Allocate and initialize an input buffer state.
  * @param file A readable stream.
  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
 }
 
 /** Allocate and initialize an input buffer state.
  * @param file A readable stream.
  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.

- *
+ * 

  * @return the allocated buffer state.
  */
  * @return the allocated buffer state.
  */

-YY_BUFFER_STATE xbt_automaton_parser__create_buffer(FILE* file, int size)
+    YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )

 {
 {

-  YY_BUFFER_STATE b;
+       YY_BUFFER_STATE b;
+    
+       b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

 
 

-  b = (YY_BUFFER_STATE)xbt_automaton_parser_alloc(sizeof(struct yy_buffer_state));
-  if (!b)
-    YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__create_buffer()");
+       b->yy_buf_size = size;

 
 

-  b->yy_buf_size = (yy_size_t)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 *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
+       if ( ! b->yy_ch_buf )
+               YY_FATAL_ERROR( "out of dynamic memory in yy_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*)xbt_automaton_parser_alloc(b->yy_buf_size + 2);
-  if (!b->yy_ch_buf)
-    YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__create_buffer()");
+       b->yy_is_our_buffer = 1;

 
 

-  b->yy_is_our_buffer = 1;
+       yy_init_buffer( b, file );

 
 

-  xbt_automaton_parser__init_buffer(b, file);
-
-  return b;
+       return b;

 }
 
 /** Destroy the buffer.
 }
 
 /** Destroy the buffer.

- * @param b a buffer created with xbt_automaton_parser__create_buffer()
- *
+ * @param b a buffer created with yy_create_buffer()
+ * 

  */
  */

-void xbt_automaton_parser__delete_buffer(YY_BUFFER_STATE b)
+    void yy_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)
-    xbt_automaton_parser_free((void*)b->yy_ch_buf);
+       if ( b->yy_is_our_buffer )
+               yyfree( (void *) b->yy_ch_buf  );

 
 

-  xbt_automaton_parser_free((void*)b);
+       yyfree( (void *) b  );

 }
 
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,
 }
 
 /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,

- * such as during a xbt_automaton_parser_restart() or at EOF.
+ * such as during a yyrestart() or at EOF.

  */
  */

-    static void xbt_automaton_parser__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
+    static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )

 
 {
 
 {

-  int oerrno = errno;
+       int oerrno = errno;
+    
+       yy_flush_buffer( b );

 
 

-  xbt_automaton_parser__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 xbt_automaton_parser__init_buffer was _probably_
-   * called from xbt_automaton_parser_restart() or through yy_get_next_buffer.
-   * In that case, we don't want to reset the lineno or column.
-   */
-  if (b != YY_CURRENT_BUFFER) {
-    b->yy_bs_lineno = 1;
-    b->yy_bs_column = 0;
+    /* If b is the current buffer, then yy_init_buffer was _probably_
+     * called from yyrestart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;

     }
 
         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
     }
 
         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.
  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
 }
 
 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.

- *
+ * 

  */
  */

-void xbt_automaton_parser__flush_buffer(YY_BUFFER_STATE b)
+    void yy_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)
-    xbt_automaton_parser__load_buffer_state();
+       if ( b == YY_CURRENT_BUFFER )
+               yy_load_buffer_state(  );

 }
 
 /** Pushes the new state onto the stack. The new state becomes
  *  the current state. This function will allocate the stack
  *  if necessary.
  *  @param new_buffer The new state.
 }
 
 /** Pushes the new state onto the stack. The new state becomes
  *  the current state. This function will allocate the stack
  *  if necessary.
  *  @param new_buffer The new state.

- *
+ *  

  */
  */

-void xbt_automaton_parser_push_buffer_state (YY_BUFFER_STATE new_buffer )
+void yypush_buffer_state (YY_BUFFER_STATE new_buffer )

 {
 {

-  if (new_buffer == NULL)
-    return;
-
-  xbt_automaton_parser_ensure_buffer_stack();
-
-  /* This block is copied from xbt_automaton_parser__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;
-
-  /* copied from xbt_automaton_parser__switch_to_buffer. */
-  xbt_automaton_parser__load_buffer_state();
-  (yy_did_buffer_switch_on_eof) = 1;
+       if (new_buffer == NULL)
+               return;
+
+       yyensure_buffer_stack();
+
+       /* This block is copied from yy_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;
+
+       /* copied from yy_switch_to_buffer. */
+       yy_load_buffer_state(  );
+       (yy_did_buffer_switch_on_eof) = 1;

 }
 
 /** Removes and deletes the top of the stack, if present.
  *  The next element becomes the new top.
 }
 
 /** Removes and deletes the top of the stack, if present.
  *  The next element becomes the new top.

- *
+ *  

  */
  */

-void xbt_automaton_parser_pop_buffer_state (void)
+void yypop_buffer_state (void)

 {
 {

-  if (!YY_CURRENT_BUFFER)
-    return;
-
-  xbt_automaton_parser__delete_buffer(YY_CURRENT_BUFFER);
-  YY_CURRENT_BUFFER_LVALUE = NULL;
-  if ((yy_buffer_stack_top) > 0)
-    --(yy_buffer_stack_top);
-
-  if (YY_CURRENT_BUFFER) {
-    xbt_automaton_parser__load_buffer_state();
-    (yy_did_buffer_switch_on_eof) = 1;
-  }
+       if (!YY_CURRENT_BUFFER)
+               return;
+
+       yy_delete_buffer(YY_CURRENT_BUFFER );
+       YY_CURRENT_BUFFER_LVALUE = NULL;
+       if ((yy_buffer_stack_top) > 0)
+               --(yy_buffer_stack_top);
+
+       if (YY_CURRENT_BUFFER) {
+               yy_load_buffer_state(  );
+               (yy_did_buffer_switch_on_eof) = 1;
+       }

 }
 
 /* Allocates the stack if it does not exist.
  *  Guarantees space for at least one push.
  */
 }
 
 /* Allocates the stack if it does not exist.
  *  Guarantees space for at least one push.
  */

-static void xbt_automaton_parser_ensure_buffer_stack (void)
+static void yyensure_buffer_stack (void)

 {
 {

-  int num_to_alloc;
-
-  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.
-     */
-    num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
-    (yy_buffer_stack) =
-        (struct yy_buffer_state**)xbt_automaton_parser_alloc(num_to_alloc * sizeof(struct yy_buffer_state*));
-    if (!(yy_buffer_stack))
-      YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser_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. */
-    yy_size_t grow_size = 8 /* arbitrary grow size */;
-
-    num_to_alloc      = (yy_buffer_stack_max) + grow_size;
-    (yy_buffer_stack) = (struct yy_buffer_state**)xbt_automaton_parser_realloc(
-        (yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*));
-    if (!(yy_buffer_stack))
-      YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser_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;
-  }
+       yy_size_t num_to_alloc;
+    
+       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.
+         */
+      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+               (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
+                                                               (num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_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. */
+               yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+               num_to_alloc = (yy_buffer_stack_max) + grow_size;
+               (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
+                                                               ((yy_buffer_stack),
+                                                               num_to_alloc * sizeof(struct yy_buffer_state*)
+                                                               );
+               if ( ! (yy_buffer_stack) )
+                       YY_FATAL_ERROR( "out of dynamic memory in yyensure_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.
  * @param base the character buffer
  * @param size the size in bytes of the character buffer
 }
 
 /** Setup the input buffer state to scan directly from a user-specified character buffer.
  * @param base the character buffer
  * @param size the size in bytes of the character buffer

- *
+ * 

  * @return the newly allocated buffer state object.
  */
  * @return the newly allocated buffer state object.
  */

-YY_BUFFER_STATE xbt_automaton_parser__scan_buffer  (char * base, yy_size_t  size )
+YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )

 {
 {

-  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 NULL;
-
-  b = (YY_BUFFER_STATE)xbt_automaton_parser_alloc(sizeof(struct yy_buffer_state));
-  if (!b)
-    YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__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             = NULL;
-  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;
-
-  xbt_automaton_parser__switch_to_buffer(b);
-
-  return 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 NULL;
+
+       b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
+       if ( ! b )
+               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+       b->yy_buf_size = (int) (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 = NULL;
+       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;
+
+       yy_switch_to_buffer( b  );
+
+       return b;

 }
 
 }
 

-/** Setup the input buffer state to scan a string. The next call to xbt_automaton_parser_lex() will
+/** Setup the input buffer state to scan a string. The next call to yylex() will

  * scan from a @e copy of @a str.
  * @param yystr a NUL-terminated string to scan
  * scan from a @e copy of @a str.
  * @param yystr a NUL-terminated string to scan

- *
+ * 

  * @return the newly allocated buffer state object.
  * @note If you want to scan bytes that may contain NUL values, then use
  * @return the newly allocated buffer state object.
  * @note If you want to scan bytes that may contain NUL values, then use

- *       xbt_automaton_parser__scan_bytes() instead.
+ *       yy_scan_bytes() instead.

  */
  */

-YY_BUFFER_STATE xbt_automaton_parser__scan_string (yyconst char * yystr )
+YY_BUFFER_STATE yy_scan_string (const char * yystr )

 {
 {

-
-  return xbt_automaton_parser__scan_bytes(yystr, (int)strlen(yystr));
+    
+       return yy_scan_bytes( yystr, (int) strlen(yystr) );

 }
 
 }
 

-/** Setup the input buffer state to scan the given bytes. The next call to xbt_automaton_parser_lex() will
+/** Setup the input buffer state to scan the given bytes. The next call to yylex() will

  * scan from a @e copy of @a bytes.
  * @param yybytes the byte buffer to scan
  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
  * scan from a @e copy of @a bytes.
  * @param yybytes the byte buffer to scan
  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.

- *
+ * 

  * @return the newly allocated buffer state object.
  */
  * @return the newly allocated buffer state object.
  */

-YY_BUFFER_STATE xbt_automaton_parser__scan_bytes(yyconst char* yybytes, int _yybytes_len)
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )

 {
 {

-  YY_BUFFER_STATE b;
-  char* buf;
-  yy_size_t n;
-  int i;
-
-  /* Get memory for full buffer, including space for trailing EOB's. */
-  n   = (yy_size_t)(_yybytes_len + 2);
-  buf = (char*)xbt_automaton_parser_alloc(n);
-  if (!buf)
-    YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__scan_bytes()");
-
-  for (i = 0; i < _yybytes_len; ++i)
-    buf[i] = yybytes[i];
-
-  buf[_yybytes_len] = buf[_yybytes_len + 1] = YY_END_OF_BUFFER_CHAR;
-
-  b = xbt_automaton_parser__scan_buffer(buf, n);
-  if (!b)
-    YY_FATAL_ERROR("bad buffer in xbt_automaton_parser__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;
-
-  return b;
+       YY_BUFFER_STATE b;
+       char *buf;
+       yy_size_t n;
+       int i;
+    
+       /* Get memory for full buffer, including space for trailing EOB's. */
+       n = (yy_size_t) (_yybytes_len + 2);
+       buf = (char *) yyalloc( n  );
+       if ( ! buf )
+               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+       for ( i = 0; i < _yybytes_len; ++i )
+               buf[i] = yybytes[i];
+
+       buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+       b = yy_scan_buffer( buf, n );
+       if ( ! b )
+               YY_FATAL_ERROR( "bad buffer in yy_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;
+
+       return b;

 }
 
 #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2
 #endif
 
 }
 
 #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2
 #endif
 

-static void yynoreturn yy_fatal_error(yyconst char* msg)
+static void yynoreturn yy_fatal_error (const char* msg )

 {
 {

-  (void)fprintf(stderr, "%s\n", msg);
-  exit(YY_EXIT_FAILURE);
+                       fprintf( stderr, "%s\n", msg );
+       exit( YY_EXIT_FAILURE );

 }
 
 /* Redefine yyless() so it works in section 3 code. */
 
 #undef yyless
 }
 
 /* Redefine yyless() so it works in section 3 code. */
 
 #undef yyless

-#define yyless(n)                                                                                                      \
-  do {                                                                                                                 \
-    /* Undo effects of setting up xbt_automaton_parser_text. */                                                        \
-    int yyless_macro_arg = (n);                                                                                        \
-    YY_LESS_LINENO(yyless_macro_arg);                                                                                  \
-    xbt_automaton_parser_text[xbt_automaton_parser_leng] = (yy_hold_char);                                             \
-    (yy_c_buf_p)                                         = xbt_automaton_parser_text + yyless_macro_arg;               \
-    (yy_hold_char)                                       = *(yy_c_buf_p);                                              \
-    *(yy_c_buf_p)                                        = '\0';                                                       \
-    xbt_automaton_parser_leng                            = yyless_macro_arg;                                           \
-  } while (0)
+#define yyless(n) \
+       do \
+               { \
+               /* Undo effects of setting up yytext. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+               yytext[yyleng] = (yy_hold_char); \
+               (yy_c_buf_p) = yytext + yyless_macro_arg; \
+               (yy_hold_char) = *(yy_c_buf_p); \
+               *(yy_c_buf_p) = '\0'; \
+               yyleng = yyless_macro_arg; \
+               } \
+       while ( 0 )

 
 /* Accessor  methods (get/set functions) to struct members. */
 
 /** Get the current line number.
 
 /* Accessor  methods (get/set functions) to struct members. */
 
 /** Get the current line number.

- *
+ * 

  */
  */

-int xbt_automaton_parser_get_lineno  (void)
+int yyget_lineno  (void)

 {
 {

-
-    return xbt_automaton_parser_lineno;
+    
+    return yylineno;

 }
 
 /** Get the input stream.
 }
 
 /** Get the input stream.

- *
+ * 

  */
  */

-FILE *xbt_automaton_parser_get_in  (void)
+FILE *yyget_in  (void)

 {
 {

-        return xbt_automaton_parser_in;
+        return yyin;

 }
 
 /** Get the output stream.
 }
 
 /** Get the output stream.

- *
+ * 

  */
  */

-FILE *xbt_automaton_parser_get_out  (void)
+FILE *yyget_out  (void)

 {
 {

-        return xbt_automaton_parser_out;
+        return yyout;

 }
 
 /** Get the length of the current token.
 }
 
 /** Get the length of the current token.

- *
+ * 

  */
  */

-int xbt_automaton_parser_get_leng(void)
+int yyget_leng  (void)

 {
 {

-        return xbt_automaton_parser_leng;
+        return yyleng;

 }
 
 /** Get the current token.
 }
 
 /** Get the current token.

- *
+ * 

  */
 
  */
 

-char *xbt_automaton_parser_get_text  (void)
+char *yyget_text  (void)

 {
 {

-        return xbt_automaton_parser_text;
+        return yytext;

 }
 
 /** Set the current line number.
  * @param _line_number line number
 }
 
 /** Set the current line number.
  * @param _line_number line number

- *
+ * 

  */
  */

-void xbt_automaton_parser_set_lineno (int  _line_number )
+void yyset_lineno (int  _line_number )

 {
 {

-
-    xbt_automaton_parser_lineno = _line_number;
+    
+    yylineno = _line_number;

 }
 
 /** Set the input stream. This does not discard the current
  * input buffer.
  * @param _in_str A readable stream.
 }
 
 /** Set the input stream. This does not discard the current
  * input buffer.
  * @param _in_str A readable stream.

- *
- * @see xbt_automaton_parser__switch_to_buffer
+ * 
+ * @see yy_switch_to_buffer

  */
  */

-void xbt_automaton_parser_set_in (FILE *  _in_str )
+void yyset_in (FILE *  _in_str )

 {
 {

-        xbt_automaton_parser_in = _in_str ;
+        yyin = _in_str ;

 }
 
 }
 

-void xbt_automaton_parser_set_out (FILE *  _out_str )
+void yyset_out (FILE *  _out_str )

 {
 {

-        xbt_automaton_parser_out = _out_str ;
+        yyout = _out_str ;

 }
 
 }
 

-int xbt_automaton_parser_get_debug  (void)
+int yyget_debug  (void)

 {
 {

-        return xbt_automaton_parser__flex_debug;
+        return yy_flex_debug;

 }
 
 }
 

-void xbt_automaton_parser_set_debug (int  _bdebug )
+void yyset_debug (int  _bdebug )

 {
 {

-        xbt_automaton_parser__flex_debug = _bdebug ;
+        yy_flex_debug = _bdebug ;

 }
 
 static int yy_init_globals (void)
 {
         /* Initialization is the same as for the non-reentrant scanner.
 }
 
 static int yy_init_globals (void)
 {
         /* Initialization is the same as for the non-reentrant scanner.

-     * This function is called from xbt_automaton_parser_lex_destroy(), so don't allocate here.
+     * This function is called from yylex_destroy(), so don't allocate here.

      */
 
      */
 

-        (yy_buffer_stack)     = NULL;
-        (yy_buffer_stack_top) = 0;
-        (yy_buffer_stack_max) = 0;
-        (yy_c_buf_p)          = NULL;
-        (yy_init)             = 0;
-        (yy_start)            = 0;
+    (yy_buffer_stack) = NULL;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = NULL;
+    (yy_init) = 0;
+    (yy_start) = 0;

 
 /* Defined in main.c */
 #ifdef YY_STDINIT
 
 /* Defined in main.c */
 #ifdef YY_STDINIT

-    xbt_automaton_parser_in = stdin;
-    xbt_automaton_parser_out = stdout;
+    yyin = stdin;
+    yyout = stdout;

 #else
 #else

-  xbt_automaton_parser_in  = NULL;
-  xbt_automaton_parser_out = NULL;
+    yyin = NULL;
+    yyout = NULL;

 #endif
 
     /* For future reference: Set errno on error, since we are called by
 #endif
 
     /* For future reference: Set errno on error, since we are called by

-     * xbt_automaton_parser_lex_init()
+     * yylex_init()

      */
     return 0;
 }
 
      */
     return 0;
 }
 

-/* xbt_automaton_parser_lex_destroy is for both reentrant and non-reentrant scanners. */
-int xbt_automaton_parser_lex_destroy  (void)
+/* yylex_destroy is for both reentrant and non-reentrant scanners. */
+int yylex_destroy  (void)

 {
 {

-
+    

     /* Pop the buffer stack, destroying each element. */
     /* Pop the buffer stack, destroying each element. */

-    while (YY_CURRENT_BUFFER) {
-      xbt_automaton_parser__delete_buffer(YY_CURRENT_BUFFER);
-      YY_CURRENT_BUFFER_LVALUE = NULL;
-      xbt_automaton_parser_pop_buffer_state();
-    }
+       while(YY_CURRENT_BUFFER){
+               yy_delete_buffer( YY_CURRENT_BUFFER  );
+               YY_CURRENT_BUFFER_LVALUE = NULL;
+               yypop_buffer_state();
+       }

 
 

-    /* Destroy the stack itself. */
-    xbt_automaton_parser_free((yy_buffer_stack));
-    (yy_buffer_stack) = NULL;
+       /* Destroy the stack itself. */
+       yyfree((yy_buffer_stack) );
+       (yy_buffer_stack) = NULL;

 
     /* Reset the globals. This is important in a non-reentrant scanner so the next time
 
     /* Reset the globals. This is important in a non-reentrant scanner so the next time

-     * xbt_automaton_parser_lex() is called, initialization will occur. */
+     * yylex() is called, initialization will occur. */

     yy_init_globals( );
 
     return 0;
     yy_init_globals( );
 
     return 0;


@@ -1826,47 +2132,47 @@ int xbt_automaton_parser_lex_destroy  (void)
  */
 
 #ifndef yytext_ptr
  */
 
 #ifndef yytext_ptr

-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+static void yy_flex_strncpy (char* s1, const char * s2, int n )

 {
 {

-
-  int i;
-  for (i = 0; i < n; ++i)
-    s1[i] = s2[i];
+               
+       int i;
+       for ( i = 0; i < n; ++i )
+               s1[i] = s2[i];

 }
 #endif
 
 #ifdef YY_NEED_STRLEN
 }
 #endif
 
 #ifdef YY_NEED_STRLEN

-static int yy_flex_strlen (yyconst char * s )
+static int yy_flex_strlen (const char * s )

 {
 {

-  int n;
-  for (n = 0; s[n]; ++n)
-    ;
+       int n;
+       for ( n = 0; s[n]; ++n )
+               ;

 
 

-  return n;
+       return n;

 }
 #endif
 
 }
 #endif
 

-void *xbt_automaton_parser_alloc (yy_size_t  size )
+void *yyalloc (yy_size_t  size )

 {
 {

-  return malloc(size);
+                       return malloc(size);

 }
 
 }
 

-void *xbt_automaton_parser_realloc  (void * ptr, yy_size_t  size )
+void *yyrealloc  (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 realloc(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 realloc(ptr, size);

 }
 
 }
 

-void xbt_automaton_parser_free (void * ptr )
+void yyfree (void * ptr )

 {
 {

-  free((char*)ptr); /* see xbt_automaton_parser_realloc() for (char *) cast */
+                       free( (char *) ptr );   /* see yyrealloc() for (char *) cast */

 }
 
 #define YYTABLES_NAME "yytables"
 }
 
 #define YYTABLES_NAME "yytables"


@@ -1876,4 +2182,3 @@ void xbt_automaton_parser_free (void * ptr )
 
 
 
 
 
 

-

diff --git a/src/xbt/automaton/parserPromela.tab.cacc b/src/xbt/automaton/parserPromela.tab.cacc
index 65c9e06..480e0c2 100644 (file)
--- a/src/xbt/automaton/parserPromela.tab.cacc
+++ b/src/xbt/automaton/parserPromela.tab.cacc
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.0.4.  */
+/* A Bison parser, made by GNU Bison 3.2.2.  */

 
 /* Bison implementation for Yacc-like parsers in C
 
 
 /* Bison implementation for Yacc-like parsers in C
 

-   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.

 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by


@@ -40,11 +40,14 @@
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 

+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
+

 /* Identify Bison output.  */
 #define YYBISON 1
 
 /* Bison version.  */
 /* Identify Bison output.  */
 #define YYBISON 1
 
 /* Bison version.  */

-#define YYBISON_VERSION "3.0.4"
+#define YYBISON_VERSION "3.2.2"

 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"


@@ -69,8 +72,8 @@
 #define yylval          xbt_automaton_parser_lval
 #define yychar          xbt_automaton_parser_char
 
 #define yylval          xbt_automaton_parser_lval
 #define yychar          xbt_automaton_parser_char
 

-/* Copy the first part of user declarations.  */
-#line 7 "parserPromela.yacc" /* yacc.c:339  */
+/* First part of user prologue.  */
+#line 7 "parserPromela.yacc" /* yacc.c:338  */

 
 #include "simgrid/config.h"
 #if !HAVE_UNISTD_H
 
 #include "simgrid/config.h"
 #if !HAVE_UNISTD_H


@@ -83,13 +86,16 @@
 void yyerror(const char *s);
 
 
 void yyerror(const char *s);
 
 

-#line 87 "parserPromela.tab.cacc" /* yacc.c:339  */
-
+#line 90 "parserPromela.tab.cacc" /* yacc.c:338  */

 # ifndef YY_NULLPTR
 # ifndef YY_NULLPTR

-#  if defined __cplusplus && 201103L <= __cplusplus
-#   define YY_NULLPTR nullptr
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif

 #  else
 #  else

-#   define YY_NULLPTR 0
+#   define YY_NULLPTR ((void*)0)

 #  endif
 # endif
 
 #  endif
 # endif
 


@@ -146,14 +152,14 @@ extern int xbt_automaton_parser_debug;
 
 union YYSTYPE
 {
 
 union YYSTYPE
 {

-#line 20 "parserPromela.yacc" /* yacc.c:355  */
+#line 20 "parserPromela.yacc" /* yacc.c:353  */

 
   double real;
   int integer;
   char* string;
   xbt_automaton_exp_label_t label;
 
 
   double real;
   int integer;
   char* string;
   xbt_automaton_exp_label_t label;
 

-#line 157 "parserPromela.tab.cacc" /* yacc.c:355  */
+#line 163 "parserPromela.tab.cacc" /* yacc.c:353  */

 };
 
 typedef union YYSTYPE YYSTYPE;
 };
 
 typedef union YYSTYPE YYSTYPE;


@@ -168,9 +174,7 @@ int xbt_automaton_parser_parse (void);
 
 #endif /* !YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED  */
 
 
 #endif /* !YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED  */
 

-/* Copy the second part of user declarations.  */

 
 

-#line 174 "parserPromela.tab.cacc" /* yacc.c:358  */

 
 #ifdef short
 # undef short
 
 #ifdef short
 # undef short


@@ -191,13 +195,13 @@ typedef signed char yytype_int8;
 #ifdef YYTYPE_UINT16
 typedef YYTYPE_UINT16 yytype_uint16;
 #else
 #ifdef YYTYPE_UINT16
 typedef YYTYPE_UINT16 yytype_uint16;
 #else

-typedef unsigned short int yytype_uint16;
+typedef unsigned short yytype_uint16;

 #endif
 
 #ifdef YYTYPE_INT16
 typedef YYTYPE_INT16 yytype_int16;
 #else
 #endif
 
 #ifdef YYTYPE_INT16
 typedef YYTYPE_INT16 yytype_int16;
 #else

-typedef short int yytype_int16;
+typedef short yytype_int16;

 #endif
 
 #ifndef YYSIZE_T
 #endif
 
 #ifndef YYSIZE_T


@@ -209,7 +213,7 @@ typedef short int yytype_int16;
 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYSIZE_T size_t
 # else
 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 #  define YYSIZE_T size_t
 # else

-#  define YYSIZE_T unsigned int
+#  define YYSIZE_T unsigned

 # endif
 #endif
 
 # endif
 #endif
 


@@ -245,15 +249,6 @@ typedef short int yytype_int16;
 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
 #endif
 
 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
 #endif
 

-#if !defined _Noreturn \
-     && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
-# if defined _MSC_VER && 1200 <= _MSC_VER
-#  define _Noreturn __declspec (noreturn)
-# else
-#  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
-# endif
-#endif
-

 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))
 /* Suppress unused-variable warnings by "using" E.  */
 #if ! defined lint || defined __GNUC__
 # define YYUSE(E) ((void) (E))


@@ -261,7 +256,7 @@ typedef short int yytype_int16;
 # define YYUSE(E) /* empty */
 #endif
 
 # define YYUSE(E) /* empty */
 #endif
 

-#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__

 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \
 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
     _Pragma ("GCC diagnostic push") \


@@ -429,7 +424,7 @@ union yyalloc
 #define YYMAXUTOK   277
 
 #define YYTRANSLATE(YYX)                                                \
 #define YYMAXUTOK   277
 
 #define YYTRANSLATE(YYX)                                                \

-  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+  ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

 
 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
    as returned by yylex, without out-of-bounds checking.  */
 
 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
    as returned by yylex, without out-of-bounds checking.  */


@@ -650,37 +645,37 @@ do {                                                                      \
 } while (0)
 
 
 } while (0)
 
 

-/*----------------------------------------.
-| Print this symbol's value on YYOUTPUT.  |
-`----------------------------------------*/
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/

 
 static void
 
 static void

-yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)

 {
 {

-  FILE *yyo = yyoutput;
-  YYUSE (yyo);
+  FILE *yyoutput = yyo;
+  YYUSE (yyoutput);

   if (!yyvaluep)
     return;
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)
   if (!yyvaluep)
     return;
 # ifdef YYPRINT
   if (yytype < YYNTOKENS)

-    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);

 # endif
   YYUSE (yytype);
 }
 
 
 # endif
   YYUSE (yytype);
 }
 
 

-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/

 
 static void
 
 static void

-yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)

 {
 {

-  YYFPRINTF (yyoutput, "%s %s (",
+  YYFPRINTF (yyo, "%s %s (",

              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 
              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 

-  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
-  YYFPRINTF (yyoutput, ")");
+  yy_symbol_value_print (yyo, yytype, yyvaluep);
+  YYFPRINTF (yyo, ")");

 }
 
 /*------------------------------------------------------------------.
 }
 
 /*------------------------------------------------------------------.


@@ -714,7 +709,7 @@ do {                                                            \
 static void
 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
 {
 static void
 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
 {

-  unsigned long int yylno = yyrline[yyrule];
+  unsigned long yylno = yyrline[yyrule];

   int yynrhs = yyr2[yyrule];
   int yyi;
   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
   int yynrhs = yyr2[yyrule];
   int yyi;
   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",


@@ -847,7 +842,7 @@ yytnamerr (char *yyres, const char *yystr)
   if (! yyres)
     return yystrlen (yystr);
 
   if (! yyres)
     return yystrlen (yystr);
 

-  return yystpcpy (yyres, yystr) - yyres;
+  return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);

 }
 # endif
 
 }
 # endif
 


@@ -940,6 +935,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
       case N:                               \
         yyformat = S;                       \
       break
       case N:                               \
         yyformat = S;                       \
       break

+    default: /* Avoid compiler warnings. */

       YYCASE_(0, YY_("syntax error"));
       YYCASE_(1, YY_("syntax error, unexpected %s"));
       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
       YYCASE_(0, YY_("syntax error"));
       YYCASE_(1, YY_("syntax error, unexpected %s"));
       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));


@@ -1088,12 +1084,12 @@ yyparse (void)
   yyssp++;
 
  yysetstate:
   yyssp++;
 
  yysetstate:

-  *yyssp = yystate;
+  *yyssp = (yytype_int16) yystate;

 
   if (yyss + yystacksize - 1 <= yyssp)
     {
       /* Get the current used size of the three stacks, in elements.  */
 
   if (yyss + yystacksize - 1 <= yyssp)
     {
       /* Get the current used size of the three stacks, in elements.  */

-      YYSIZE_T yysize = yyssp - yyss + 1;
+      YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);

 
 #ifdef yyoverflow
       {
 
 #ifdef yyoverflow
       {


@@ -1111,7 +1107,6 @@ yyparse (void)
                     &yyss1, yysize * sizeof (*yyssp),
                     &yyvs1, yysize * sizeof (*yyvsp),
                     &yystacksize);
                     &yyss1, yysize * sizeof (*yyssp),
                     &yyvs1, yysize * sizeof (*yyvsp),
                     &yystacksize);

-

         yyss = yyss1;
         yyvs = yyvs1;
       }
         yyss = yyss1;
         yyvs = yyvs1;
       }


@@ -1145,7 +1140,7 @@ yyparse (void)
       yyvsp = yyvs + yysize - 1;
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
       yyvsp = yyvs + yysize - 1;
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",

-                  (unsigned long int) yystacksize));
+                  (unsigned long) yystacksize));

 
       if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;
 
       if (yyss + yystacksize - 1 <= yyssp)
         YYABORT;


@@ -1256,55 +1251,55 @@ yyreduce:
   switch (yyn)
     {
         case 4:
   switch (yyn)
     {
         case 4:

-#line 61 "parserPromela.yacc" /* yacc.c:1646  */
+#line 61 "parserPromela.yacc" /* yacc.c:1645  */

     { new_state((yyvsp[-1].string), 1);}
     { new_state((yyvsp[-1].string), 1);}

-#line 1262 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1257 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
   case 7:
     break;
 
   case 7:

-#line 65 "parserPromela.yacc" /* yacc.c:1646  */
+#line 65 "parserPromela.yacc" /* yacc.c:1645  */

     { new_transition((yyvsp[-1].string), (yyvsp[-4].label));}
     { new_transition((yyvsp[-1].string), (yyvsp[-4].label));}

-#line 1268 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1263 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
   case 8:
     break;
 
   case 8:

-#line 68 "parserPromela.yacc" /* yacc.c:1646  */
+#line 68 "parserPromela.yacc" /* yacc.c:1645  */

     { (yyval.label) = (yyvsp[-1].label); }
     { (yyval.label) = (yyvsp[-1].label); }

-#line 1274 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1269 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
   case 9:
     break;
 
   case 9:

-#line 69 "parserPromela.yacc" /* yacc.c:1646  */
+#line 69 "parserPromela.yacc" /* yacc.c:1645  */

     { (yyval.label) = xbt_automaton_exp_label_new_or((yyvsp[-2].label), (yyvsp[0].label)); }
     { (yyval.label) = xbt_automaton_exp_label_new_or((yyvsp[-2].label), (yyvsp[0].label)); }

-#line 1280 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1275 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
   case 10:
     break;
 
   case 10:

-#line 70 "parserPromela.yacc" /* yacc.c:1646  */
+#line 70 "parserPromela.yacc" /* yacc.c:1645  */

     { (yyval.label) = xbt_automaton_exp_label_new_and((yyvsp[-2].label), (yyvsp[0].label)); }
     { (yyval.label) = xbt_automaton_exp_label_new_and((yyvsp[-2].label), (yyvsp[0].label)); }

-#line 1286 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1281 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
   case 11:
     break;
 
   case 11:

-#line 71 "parserPromela.yacc" /* yacc.c:1646  */
+#line 71 "parserPromela.yacc" /* yacc.c:1645  */

     { (yyval.label) = xbt_automaton_exp_label_new_not((yyvsp[0].label)); }
     { (yyval.label) = xbt_automaton_exp_label_new_not((yyvsp[0].label)); }

-#line 1292 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1287 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
   case 12:
     break;
 
   case 12:

-#line 72 "parserPromela.yacc" /* yacc.c:1646  */
+#line 72 "parserPromela.yacc" /* yacc.c:1645  */

     { (yyval.label) = xbt_automaton_exp_label_new_one(); }
     { (yyval.label) = xbt_automaton_exp_label_new_one(); }

-#line 1298 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1293 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
   case 13:
     break;
 
   case 13:

-#line 73 "parserPromela.yacc" /* yacc.c:1646  */
+#line 73 "parserPromela.yacc" /* yacc.c:1645  */

     { (yyval.label) = xbt_automaton_exp_label_new_predicat((yyvsp[0].string)); }
     { (yyval.label) = xbt_automaton_exp_label_new_predicat((yyvsp[0].string)); }

-#line 1304 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1299 "parserPromela.tab.cacc" /* yacc.c:1645  */

     break;
 
 
     break;
 
 

-#line 1308 "parserPromela.tab.cacc" /* yacc.c:1646  */
+#line 1303 "parserPromela.tab.cacc" /* yacc.c:1645  */

       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires


@@ -1329,14 +1324,13 @@ yyreduce:
   /* Now 'shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */
   /* Now 'shift' the result of the reduction.  Determine what state
      that goes to, based on the state we popped back to and the rule
      number reduced by.  */

-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
-  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTOKENS];
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }

 
   goto yynewstate;
 
 
   goto yynewstate;
 


@@ -1532,7 +1526,7 @@ yyreturn:
 #endif
   return yyresult;
 }
 #endif
   return yyresult;
 }

-#line 76 "parserPromela.yacc" /* yacc.c:1906  */
+#line 76 "parserPromela.yacc" /* yacc.c:1903  */

 
 
 
 
 
 

diff --git a/src/xbt/automaton/parserPromela.tab.hacc b/src/xbt/automaton/parserPromela.tab.hacc
index f2e24d9..d159c90 100644 (file)
--- a/src/xbt/automaton/parserPromela.tab.hacc
+++ b/src/xbt/automaton/parserPromela.tab.hacc
@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.0.4.  */
+/* A Bison parser, made by GNU Bison 3.2.2.  */

 
 /* Bison interface for Yacc-like parsers in C
 
 
 /* Bison interface for Yacc-like parsers in C
 

-   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc.

 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by


@@ -30,6 +30,9 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 

+/* Undocumented macros, especially those whose name start with YY_,
+   are private implementation details.  Do not rely on them.  */
+

 #ifndef YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED
 # define YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED
 /* Debug traces.  */
 #ifndef YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED
 # define YY_XBT_AUTOMATON_PARSER_PARSERPROMELA_TAB_HACC_INCLUDED
 /* Debug traces.  */


@@ -73,14 +76,14 @@ extern int xbt_automaton_parser_debug;
 
 union YYSTYPE
 {
 
 union YYSTYPE
 {

-#line 20 "parserPromela.yacc" /* yacc.c:1909  */
+#line 20 "parserPromela.yacc" /* yacc.c:1906  */

 
   double real;
   int integer;
   char* string;
   xbt_automaton_exp_label_t label;
 
 
   double real;
   int integer;
   char* string;
   xbt_automaton_exp_label_t label;
 

-#line 84 "parserPromela.tab.hacc" /* yacc.c:1909  */
+#line 87 "parserPromela.tab.hacc" /* yacc.c:1906  */

 };
 
 typedef union YYSTYPE YYSTYPE;
 };
 
 typedef union YYSTYPE YYSTYPE;