src/xbt/automaton/automaton_lexer.yy.c

   1 #line 2 "automaton_lexer.yy.c"
   2
   3 #line 4 "automaton_lexer.yy.c"
   4
   5 #define  YY_INT_ALIGNED short int
   6
   7 /* A lexical scanner generated by flex */
   8
   9 #define yy_create_buffer xbt_automaton_parser__create_buffer
  10 #define yy_delete_buffer xbt_automaton_parser__delete_buffer
  11 #define yy_flex_debug xbt_automaton_parser__flex_debug
  12 #define yy_init_buffer xbt_automaton_parser__init_buffer
  13 #define yy_flush_buffer xbt_automaton_parser__flush_buffer
  14 #define yy_load_buffer_state xbt_automaton_parser__load_buffer_state
  15 #define yy_switch_to_buffer xbt_automaton_parser__switch_to_buffer
  16 #define yyin xbt_automaton_parser_in
  17 #define yyleng xbt_automaton_parser_leng
  18 #define yylex xbt_automaton_parser_lex
  19 #define yylineno xbt_automaton_parser_lineno
  20 #define yyout xbt_automaton_parser_out
  21 #define yyrestart xbt_automaton_parser_restart
  22 #define yytext xbt_automaton_parser_text
  23 #define yywrap xbt_automaton_parser_wrap
  24 #define yyalloc xbt_automaton_parser_alloc
  25 #define yyrealloc xbt_automaton_parser_realloc
  26 #define yyfree xbt_automaton_parser_free
  27
  28 #define FLEX_SCANNER
  29 #define YY_FLEX_MAJOR_VERSION 2
  30 #define YY_FLEX_MINOR_VERSION 6
  31 #define YY_FLEX_SUBMINOR_VERSION 1
  32 #if YY_FLEX_SUBMINOR_VERSION > 0
  33 #define FLEX_BETA
  34 #endif
  35
  36 /* First, we deal with  platform-specific or compiler-specific issues. */
  37
  38 /* begin standard C headers. */
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <errno.h>
  42 #include <stdlib.h>
  43
  44 /* end standard C headers. */
  45
  46 /* flex integer type definitions */
  47
  48 #ifndef FLEXINT_H
  49 #define FLEXINT_H
  50
  51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  52
  53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  54
  55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  56  * if you want the limit (max/min) macros for int types.
  57  */
  58 #ifndef __STDC_LIMIT_MACROS
  59 #define __STDC_LIMIT_MACROS 1
  60 #endif
  61
  62 #include <inttypes.h>
  63 typedef int8_t flex_int8_t;
  64 typedef uint8_t flex_uint8_t;
  65 typedef int16_t flex_int16_t;
  66 typedef uint16_t flex_uint16_t;
  67 typedef int32_t flex_int32_t;
  68 typedef uint32_t flex_uint32_t;
  69 #else
  70 typedef signed char flex_int8_t;
  71 typedef short int flex_int16_t;
  72 typedef int flex_int32_t;
  73 typedef unsigned char flex_uint8_t;
  74 typedef unsigned short int flex_uint16_t;
  75 typedef unsigned int flex_uint32_t;
  76
  77 /* Limits of integral types. */
  78 #ifndef INT8_MIN
  79 #define INT8_MIN               (-128)
  80 #endif
  81 #ifndef INT16_MIN
  82 #define INT16_MIN              (-32767-1)
  83 #endif
  84 #ifndef INT32_MIN
  85 #define INT32_MIN              (-2147483647-1)
  86 #endif
  87 #ifndef INT8_MAX
  88 #define INT8_MAX               (127)
  89 #endif
  90 #ifndef INT16_MAX
  91 #define INT16_MAX              (32767)
  92 #endif
  93 #ifndef INT32_MAX
  94 #define INT32_MAX              (2147483647)
  95 #endif
  96 #ifndef UINT8_MAX
  97 #define UINT8_MAX              (255U)
  98 #endif
  99 #ifndef UINT16_MAX
 100 #define UINT16_MAX             (65535U)
 101 #endif
 102 #ifndef UINT32_MAX
 103 #define UINT32_MAX             (4294967295U)
 104 #endif
 105
 106 #endif /* ! C99 */
 107
 108 #endif /* ! FLEXINT_H */
 109
 110 /* TODO: this is always defined, so inline it */
 111 #define yyconst const
 112
 113 #if defined(__GNUC__) && __GNUC__ >= 3
 114 #define yynoreturn __attribute__((__noreturn__))
 115 #else
 116 #define yynoreturn
 117 #endif
 118
 119 /* Returned upon end-of-file. */
 120 #define YY_NULL 0
 121
 122 /* Promotes a possibly negative, possibly signed char to an unsigned
 123  * integer for use as an array index.  If the signed char is negative,
 124  * we want to instead treat it as an 8-bit unsigned char, hence the
 125  * double cast.
 126  */
 127 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 128
 129 /* Enter a start condition.  This macro really ought to take a parameter,
 130  * but we do it the disgusting crufty way forced on us by the ()-less
 131  * definition of BEGIN.
 132  */
 133 #define BEGIN (yy_start) = 1 + 2 *
 134
 135 /* Translate the current start state into a value that can be later handed
 136  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 137  * compatibility.
 138  */
 139 #define YY_START (((yy_start) - 1) / 2)
 140 #define YYSTATE YY_START
 141
 142 /* Action number for EOF rule of a given start state. */
 143 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 144
 145 /* Special action meaning "start processing a new file". */
 146 #define YY_NEW_FILE xbt_automaton_parser_restart(xbt_automaton_parser_in  )
 147
 148 #define YY_END_OF_BUFFER_CHAR 0
 149
 150 /* Size of default input buffer. */
 151 #ifndef YY_BUF_SIZE
 152 #ifdef __ia64__
 153 /* On IA-64, the buffer size is 16k, not 8k.
 154  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
 155  * Ditto for the __ia64__ case accordingly.
 156  */
 157 #define YY_BUF_SIZE 32768
 158 #else
 159 #define YY_BUF_SIZE 16384
 160 #endif /* __ia64__ */
 161 #endif
 162
 163 /* The state buf must be large enough to hold one state per character in the main buffer.
 164  */
 165 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 166
 167 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 168 #define YY_TYPEDEF_YY_BUFFER_STATE
 169 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 170 #endif
 171
 172 #ifndef YY_TYPEDEF_YY_SIZE_T
 173 #define YY_TYPEDEF_YY_SIZE_T
 174 typedef size_t yy_size_t;
 175 #endif
 176
 177 extern int xbt_automaton_parser_leng;
 178
 179 extern FILE *xbt_automaton_parser_in, *xbt_automaton_parser_out;
 180
 181 #define EOB_ACT_CONTINUE_SCAN 0
 182 #define EOB_ACT_END_OF_FILE 1
 183 #define EOB_ACT_LAST_MATCH 2
 184
 185     #define YY_LESS_LINENO(n)
 186     #define YY_LINENO_REWIND_TO(ptr)
 187
 188 /* Return all but the first "n" matched characters back to the input stream. */
 189 #define yyless(n)                                                                                                      \
 190   do {                                                                                                                 \
 191     /* Undo effects of setting up xbt_automaton_parser_text. */                                                        \
 192     int yyless_macro_arg = (n);                                                                                        \
 193     YY_LESS_LINENO(yyless_macro_arg);                                                                                  \
 194     *yy_cp                                = (yy_hold_char);                                                            \
 195     YY_RESTORE_YY_MORE_OFFSET(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ;                            \
 196     YY_DO_BEFORE_ACTION; /* set up xbt_automaton_parser_text again */                                                  \
 197   } while (0)
 198
 199 #define unput(c) yyunput( c, (yytext_ptr)  )
 200
 201 #ifndef YY_STRUCT_YY_BUFFER_STATE
 202 #define YY_STRUCT_YY_BUFFER_STATE
 203 struct yy_buffer_state {
 204   FILE* yy_input_file;
 205
 206   char* yy_ch_buf;  /* input buffer */
 207   char* yy_buf_pos; /* current position in input buffer */
 208
 209   /* Size of input buffer in bytes, not including room for EOB
 210    * characters.
 211    */
 212   int yy_buf_size;
 213
 214   /* Number of characters read into yy_ch_buf, not including EOB
 215    * characters.
 216    */
 217   int yy_n_chars;
 218
 219   /* Whether we "own" the buffer - i.e., we know we created it,
 220    * and can realloc() it to grow it, and should free() it to
 221    * delete it.
 222    */
 223   int yy_is_our_buffer;
 224
 225   /* Whether this is an "interactive" input source; if so, and
 226    * if we're using stdio for input, then we want to use getc()
 227    * instead of fread(), to make sure we stop fetching input after
 228    * each newline.
 229    */
 230   int yy_is_interactive;
 231
 232   /* Whether we're considered to be at the beginning of a line.
 233    * If so, '^' rules will be active on the next match, otherwise
 234    * not.
 235    */
 236   int yy_at_bol;
 237
 238   int yy_bs_lineno; /**< The line count. */
 239   int yy_bs_column; /**< The column count. */
 240
 241   /* Whether to try to fill the input buffer when we reach the
 242    * end of it.
 243    */
 244   int yy_fill_buffer;
 245
 246   int yy_buffer_status;
 247
 248 #define YY_BUFFER_NEW 0
 249 #define YY_BUFFER_NORMAL 1
 250   /* When an EOF's been seen but there's still some text to process
 251    * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 252    * shouldn't try reading from the input source any more.  We might
 253    * still have a bunch of tokens to match, though, because of
 254    * possible backing-up.
 255    *
 256    * When we actually see the EOF, we change the status to "new"
 257    * (via xbt_automaton_parser_restart()), so that the user can continue scanning by
 258    * just pointing xbt_automaton_parser_in at a new input file.
 259    */
 260 #define YY_BUFFER_EOF_PENDING 2
 261 };
 262 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 263
 264 /* Stack of input buffers. */
 265 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 266 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 267 static YY_BUFFER_STATE* yy_buffer_stack = NULL; /**< Stack as an array. */
 268
 269 /* We provide macros for accessing buffer states in case in the
 270  * future we want to put the buffer states in a more general
 271  * "scanner state".
 272  *
 273  * Returns the top of the stack, or NULL.
 274  */
 275 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 276                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 277                           : NULL)
 278
 279 /* Same as previous macro, but useful when we know that the buffer stack is not
 280  * NULL or when we need an lvalue. For internal use only.
 281  */
 282 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 283
 284 /* yy_hold_char holds the character lost when xbt_automaton_parser_text is formed. */
 285 static char yy_hold_char;
 286 static int yy_n_chars; /* number of characters read into yy_ch_buf */
 287 int xbt_automaton_parser_leng;
 288
 289 /* Points to current character in buffer. */
 290 static char* yy_c_buf_p = NULL;
 291 static int yy_init      = 0; /* whether we need to initialize */
 292 static int yy_start     = 0; /* start state number */
 293
 294 /* Flag which is used to allow xbt_automaton_parser_wrap()'s to do buffer switches
 295  * instead of setting up a fresh xbt_automaton_parser_in.  A bit of a hack ...
 296  */
 297 static int yy_did_buffer_switch_on_eof;
 298
 299 void xbt_automaton_parser_restart (FILE *input_file  );
 300 void xbt_automaton_parser__switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 301 YY_BUFFER_STATE xbt_automaton_parser__create_buffer (FILE *file,int size  );
 302 void xbt_automaton_parser__delete_buffer (YY_BUFFER_STATE b  );
 303 void xbt_automaton_parser__flush_buffer (YY_BUFFER_STATE b  );
 304 void xbt_automaton_parser_push_buffer_state (YY_BUFFER_STATE new_buffer  );
 305 void xbt_automaton_parser_pop_buffer_state (void );
 306
 307 static void xbt_automaton_parser_ensure_buffer_stack (void );
 308 static void xbt_automaton_parser__load_buffer_state (void );
 309 static void xbt_automaton_parser__init_buffer (YY_BUFFER_STATE b,FILE *file  );
 310
 311 #define YY_FLUSH_BUFFER xbt_automaton_parser__flush_buffer(YY_CURRENT_BUFFER )
 312
 313 YY_BUFFER_STATE xbt_automaton_parser__scan_buffer (char *base,yy_size_t size  );
 314 YY_BUFFER_STATE xbt_automaton_parser__scan_string (yyconst char *yy_str  );
 315 YY_BUFFER_STATE xbt_automaton_parser__scan_bytes(yyconst char* bytes, int len);
 316
 317 void *xbt_automaton_parser_alloc (yy_size_t  );
 318 void *xbt_automaton_parser_realloc (void *,yy_size_t  );
 319 void xbt_automaton_parser_free (void *  );
 320
 321 #define yy_new_buffer xbt_automaton_parser__create_buffer
 322
 323 #define yy_set_interactive(is_interactive)                                                                             \
 324   {                                                                                                                    \
 325     if (!YY_CURRENT_BUFFER) {                                                                                          \
 326       xbt_automaton_parser_ensure_buffer_stack();                                                                      \
 327       YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);            \
 328     }                                                                                                                  \
 329     YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive;                                                      \
 330   }
 331
 332 #define yy_set_bol(at_bol)                                                                                             \
 333   {                                                                                                                    \
 334     if (!YY_CURRENT_BUFFER) {                                                                                          \
 335       xbt_automaton_parser_ensure_buffer_stack();                                                                      \
 336       YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);            \
 337     }                                                                                                                  \
 338     YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol;                                                                      \
 339   }
 340
 341 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 342
 343 /* Begin user sect3 */
 344
 345 #define xbt_automaton_parser_wrap() (/*CONSTCOND*/1)
 346 #define YY_SKIP_YYWRAP
 347
 348 typedef unsigned char YY_CHAR;
 349
 350 FILE *xbt_automaton_parser_in = NULL, *xbt_automaton_parser_out = NULL;
 351
 352 typedef int yy_state_type;
 353
 354 extern int xbt_automaton_parser_lineno;
 355
 356 int xbt_automaton_parser_lineno = 1;
 357
 358 extern char *xbt_automaton_parser_text;
 359 #ifdef yytext_ptr
 360 #undef yytext_ptr
 361 #endif
 362 #define yytext_ptr xbt_automaton_parser_text
 363
 364 static yy_state_type yy_get_previous_state (void );
 365 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 366 static int yy_get_next_buffer (void );
 367 static void yynoreturn yy_fatal_error(yyconst char* msg);
 368
 369 /* Done after the current pattern has been matched and before the
 370  * corresponding action - sets up xbt_automaton_parser_text.
 371  */
 372 #define YY_DO_BEFORE_ACTION                                                                                            \
 373   (yytext_ptr)              = yy_bp;                                                                                   \
 374   xbt_automaton_parser_leng = (int)(yy_cp - yy_bp);                                                                    \
 375   (yy_hold_char)            = *yy_cp;                                                                                  \
 376   *yy_cp                    = '\0';                                                                                    \
 377   (yy_c_buf_p)              = yy_cp;
 378
 379 #define YY_NUM_RULES 25
 380 #define YY_END_OF_BUFFER 26
 381 /* This struct is not used in this scanner,
 382    but its presence is necessary. */
 383 struct yy_trans_info {
 384   flex_int32_t yy_verify;
 385   flex_int32_t yy_nxt;
 386 };
 387 static yyconst flex_int16_t yy_accept[54] =
 388     {   0,
 389         0,    0,   26,   24,   18,   23,    8,   24,   24,    9,
 390        10,   24,   24,   20,   14,   12,   13,   22,   22,   22,
 391        22,   22,   15,   24,   16,   18,    0,    0,   21,    0,
 392         6,    4,    0,    0,   20,   11,   22,    3,   22,    2,
 393        22,    7,    0,    0,    0,   19,   22,   22,   17,    5,
 394        22,    1,    0
 395     } ;
 396
 397 static yyconst YY_CHAR yy_ec[256] =
 398     {   0,
 399         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 402         1,    4,    5,    6,    1,    1,    1,    7,    1,    8,
 403         9,   10,    1,    1,   11,   12,   13,   14,   15,   14,
 404        14,   14,   14,   14,   14,   14,   14,   16,   17,    1,
 405         1,   18,    1,    1,   19,   19,   19,   19,   19,   19,
 406        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
 407        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
 408         1,   20,    1,    1,   21,    1,   19,   19,   19,   19,
 409
 410        22,   23,   24,   19,   25,   19,   19,   19,   19,   26,
 411        27,   19,   19,   28,   19,   29,   19,   30,   19,   19,
 412        19,   19,   31,   32,   33,    1,    1,    1,    1,    1,
 413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 415         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 416         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 417         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 418         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 419         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 420
 421         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 422         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 423         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 424         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 425         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 426         1,    1,    1,    1,    1
 427     } ;
 428
 429 static yyconst YY_CHAR yy_meta[34] =
 430     {   0,
 431         1,    1,    2,    2,    1,    2,    1,    1,    1,    1,
 432         1,    1,    3,    4,    4,    1,    1,    1,    4,    2,
 433         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 434         1,    1,    1
 435     } ;
 436
 437 static yyconst flex_uint16_t yy_base[57] =
 438     {   0,
 439         0,    0,   89,   90,   32,   90,   90,   34,   81,   90,
 440        90,   69,   76,   27,   31,   69,   90,    0,   59,   56,
 441        58,   55,   90,   42,   90,   45,   47,    0,    0,    0,
 442        90,   90,   52,   43,   49,   90,    0,    0,   44,    0,
 443        42,   90,   56,   65,   52,   56,   25,   26,   90,    0,
 444        16,    0,   90,   74,   31,   78
 445     } ;
 446
 447 static yyconst flex_int16_t yy_def[57] =
 448     {   0,
 449        53,    1,   53,   53,   53,   53,   53,   54,   53,   53,
 450        53,   53,   53,   53,   53,   53,   53,   55,   55,   55,
 451        55,   55,   53,   53,   53,   53,   54,   27,   27,   27,
 452        53,   53,   56,   53,   53,   53,   55,   55,   55,   55,
 453        55,   53,   56,   56,   53,   53,   55,   55,   53,   55,
 454        55,   55,    0,   53,   53,   53
 455     } ;
 456
 457 static yyconst flex_uint16_t yy_nxt[124] =
 458     {   0,
 459         4,    5,    6,    5,    7,    8,    9,   10,   11,    4,
 460        12,    4,   13,   14,   15,   16,   17,    4,   18,    4,
 461         4,   18,   19,   20,   21,   22,   18,   18,   18,   18,
 462        23,   24,   25,   26,   37,   26,   27,   28,   34,   29,
 463        35,   35,   34,   52,   35,   35,   26,   51,   26,   27,
 464        28,   50,   29,   27,   44,   44,   46,   46,   44,   44,
 465        34,   45,   35,   35,   49,   45,   27,   44,   44,   46,
 466        46,   48,   47,   42,   45,   30,   41,   30,   43,   43,
 467        40,   43,   39,   38,   36,   33,   32,   31,   53,    3,
 468        53,   53,   53,   53,   53,   53,   53,   53,   53,   53,
 469
 470        53,   53,   53,   53,   53,   53,   53,   53,   53,   53,
 471        53,   53,   53,   53,   53,   53,   53,   53,   53,   53,
 472        53,   53,   53
 473     } ;
 474
 475 static yyconst flex_int16_t yy_chk[124] =
 476     {   0,
 477         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 478         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 479         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 480         1,    1,    1,    5,   55,    5,    8,    8,   14,    8,
 481        14,   14,   15,   51,   15,   15,   26,   48,   26,   27,
 482        27,   47,   27,    8,   33,   33,   34,   34,   43,   43,
 483        35,   33,   35,   35,   45,   43,   27,   44,   44,   46,
 484        46,   41,   39,   24,   44,   54,   22,   54,   56,   56,
 485        21,   56,   20,   19,   16,   13,   12,    9,    3,   53,
 486        53,   53,   53,   53,   53,   53,   53,   53,   53,   53,
 487
 488        53,   53,   53,   53,   53,   53,   53,   53,   53,   53,
 489        53,   53,   53,   53,   53,   53,   53,   53,   53,   53,
 490        53,   53,   53
 491     } ;
 492
 493 static yy_state_type yy_last_accepting_state;
 494 static char *yy_last_accepting_cpos;
 495
 496 extern int xbt_automaton_parser__flex_debug;
 497 int xbt_automaton_parser__flex_debug = 0;
 498
 499 /* The intent behind this definition is that it'll catch
 500  * any uses of REJECT which flex missed.
 501  */
 502 #define REJECT reject_used_but_not_detected
 503 #define yymore() yymore_used_but_not_detected
 504 #define YY_MORE_ADJ 0
 505 #define YY_RESTORE_YY_MORE_OFFSET
 506 char *xbt_automaton_parser_text;
 507 #line 1 "parserPromela.lex"
 508 /* Copyright (c) 2012-2019. The SimGrid Team.
 509  * All rights reserved.                                                     */
 510 /* This program is free software; you can redistribute it and/or modify it
 511  * under the terms of the license (GNU LGPL) which comes with this package. */
 512 #line 10 "parserPromela.lex"
 513
 514 #include "simgrid/config.h"
 515 #if !HAVE_UNISTD_H
 516 #define YY_NO_UNISTD_H /* hello Windows */
 517 #endif
 518
 519 #include <stdio.h>
 520 #include "parserPromela.tab.hacc"
 521
 522   extern YYSTYPE yylval;
 523
 524 #line 533 "automaton_lexer.yy.c"
 525
 526 #define INITIAL 0
 527
 528 #ifndef YY_NO_UNISTD_H
 529 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 530  * down here because we want the user's section 1 to have been scanned first.
 531  * The user has a chance to override it with an option.
 532  */
 533 #include <unistd.h>
 534 #endif
 535
 536 #ifndef YY_EXTRA_TYPE
 537 #define YY_EXTRA_TYPE void *
 538 #endif
 539
 540 static int yy_init_globals (void );
 541
 542 /* Accessor methods to globals.
 543    These are made visible to non-reentrant scanners for convenience. */
 544
 545 int xbt_automaton_parser_lex_destroy (void );
 546
 547 int xbt_automaton_parser_get_debug (void );
 548
 549 void xbt_automaton_parser_set_debug (int debug_flag  );
 550
 551 YY_EXTRA_TYPE xbt_automaton_parser_get_extra (void );
 552
 553 void xbt_automaton_parser_set_extra (YY_EXTRA_TYPE user_defined  );
 554
 555 FILE *xbt_automaton_parser_get_in (void );
 556
 557 void xbt_automaton_parser_set_in  (FILE * _in_str  );
 558
 559 FILE *xbt_automaton_parser_get_out (void );
 560
 561 void xbt_automaton_parser_set_out  (FILE * _out_str  );
 562
 563 int xbt_automaton_parser_get_leng(void);
 564
 565 char *xbt_automaton_parser_get_text (void );
 566
 567 int xbt_automaton_parser_get_lineno (void );
 568
 569 void xbt_automaton_parser_set_lineno (int _line_number  );
 570
 571 /* Macros after this point can all be overridden by user definitions in
 572  * section 1.
 573  */
 574
 575 #ifndef YY_SKIP_YYWRAP
 576 #ifdef __cplusplus
 577 extern "C" int xbt_automaton_parser_wrap (void );
 578 #else
 579 extern int xbt_automaton_parser_wrap (void );
 580 #endif
 581 #endif
 582
 583 #ifndef YY_NO_UNPUT
 584
 585     static void yyunput (int c,char *buf_ptr  );
 586
 587 #endif
 588
 589 #ifndef yytext_ptr
 590 static void yy_flex_strncpy (char *,yyconst char *,int );
 591 #endif
 592
 593 #ifdef YY_NEED_STRLEN
 594 static int yy_flex_strlen (yyconst char * );
 595 #endif
 596
 597 #ifndef YY_NO_INPUT
 598
 599 #ifdef __cplusplus
 600 static int yyinput (void );
 601 #else
 602 static int input (void );
 603 #endif
 604
 605 #endif
 606
 607 /* Amount of stuff to slurp up with each read. */
 608 #ifndef YY_READ_BUF_SIZE
 609 #ifdef __ia64__
 610 /* On IA-64, the buffer size is 16k, not 8k */
 611 #define YY_READ_BUF_SIZE 16384
 612 #else
 613 #define YY_READ_BUF_SIZE 8192
 614 #endif /* __ia64__ */
 615 #endif
 616
 617 /* Copy whatever the last rule matched to the standard output. */
 618 #ifndef ECHO
 619 /* This used to be an fputs(), but since the string might contain NUL's,
 620  * we now use fwrite().
 621  */
 622 #define ECHO                                                                                                           \
 623   do {                                                                                                                 \
 624     if (fwrite(xbt_automaton_parser_text, (size_t)xbt_automaton_parser_leng, 1, xbt_automaton_parser_out)) {           \
 625     }                                                                                                                  \
 626   } while (0)
 627 #endif
 628
 629 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 630  * is returned in "result".
 631  */
 632 #ifndef YY_INPUT
 633 #define YY_INPUT(buf, result, max_size)                                                                                \
 634   if (YY_CURRENT_BUFFER_LVALUE->yy_is_interactive) {                                                                   \
 635     int c = '*';                                                                                                       \
 636     size_t n;                                                                                                          \
 637     for (n = 0; n < max_size && (c = getc(xbt_automaton_parser_in)) != EOF && c != '\n'; ++n)                          \
 638       buf[n] = (char)c;                                                                                                \
 639     if (c == '\n')                                                                                                     \
 640       buf[n++] = (char)c;                                                                                              \
 641     if (c == EOF && ferror(xbt_automaton_parser_in))                                                                   \
 642       YY_FATAL_ERROR("input in flex scanner failed");                                                                  \
 643     result = n;                                                                                                        \
 644   } else {                                                                                                             \
 645     errno = 0;                                                                                                         \
 646     while ((result = (int)fread(buf, 1, max_size, xbt_automaton_parser_in)) == 0 && ferror(xbt_automaton_parser_in)) { \
 647       if (errno != EINTR) {                                                                                            \
 648         YY_FATAL_ERROR("input in flex scanner failed");                                                                \
 649         break;                                                                                                         \
 650       }                                                                                                                \
 651       errno = 0;                                                                                                       \
 652       clearerr(xbt_automaton_parser_in);                                                                               \
 653     }                                                                                                                  \
 654   }
 655
 656 #endif
 657
 658 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 659  * we don't want an extra ';' after the "return" because that will cause
 660  * some compilers to complain about unreachable statements.
 661  */
 662 #ifndef yyterminate
 663 #define yyterminate() return YY_NULL
 664 #endif
 665
 666 /* Number of entries by which start-condition stack grows. */
 667 #ifndef YY_START_STACK_INCR
 668 #define YY_START_STACK_INCR 25
 669 #endif
 670
 671 /* Report a fatal error. */
 672 #ifndef YY_FATAL_ERROR
 673 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 674 #endif
 675
 676 /* end tables serialization structures and prototypes */
 677
 678 /* Default declaration of generated scanner - a define so the user can
 679  * easily add parameters.
 680  */
 681 #ifndef YY_DECL
 682 #define YY_DECL_IS_OURS 1
 683
 684 extern int xbt_automaton_parser_lex (void);
 685
 686 #define YY_DECL int xbt_automaton_parser_lex (void)
 687 #endif /* !YY_DECL */
 688
 689 /* Code executed at the beginning of each rule, after xbt_automaton_parser_text and xbt_automaton_parser_leng
 690  * have been set up.
 691  */
 692 #ifndef YY_USER_ACTION
 693 #define YY_USER_ACTION
 694 #endif
 695
 696 /* Code executed at the end of each rule. */
 697 #ifndef YY_BREAK
 698 #define YY_BREAK /*LINTED*/break;
 699 #endif
 700
 701 #define YY_RULE_SETUP YY_USER_ACTION
 702
 703 /** The main scanner function which does all the work.
 704  */
 705 YY_DECL
 706 {
 707   yy_state_type yy_current_state;
 708   char *yy_cp, *yy_bp;
 709   int yy_act;
 710
 711   if (!(yy_init)) {
 712     (yy_init) = 1;
 713
 714 #ifdef YY_USER_INIT
 715     YY_USER_INIT;
 716 #endif
 717
 718     if (!(yy_start))
 719       (yy_start) = 1; /* first start state */
 720
 721     if (!xbt_automaton_parser_in)
 722       xbt_automaton_parser_in = stdin;
 723
 724     if (!xbt_automaton_parser_out)
 725       xbt_automaton_parser_out = stdout;
 726
 727     if (!YY_CURRENT_BUFFER) {
 728       xbt_automaton_parser_ensure_buffer_stack();
 729       YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);
 730     }
 731
 732     xbt_automaton_parser__load_buffer_state();
 733   }
 734
 735   {
 736 #line 38 "parserPromela.lex"
 737
 738 #line 754 "automaton_lexer.yy.c"
 739
 740     while (/*CONSTCOND*/ 1) /* loops until end-of-file is reached */
 741     {
 742       yy_cp = (yy_c_buf_p);
 743
 744       /* Support of xbt_automaton_parser_text. */
 745       *yy_cp = (yy_hold_char);
 746
 747       /* yy_bp points to the position in yy_ch_buf of the start of
 748        * the current run.
 749        */
 750       yy_bp = yy_cp;
 751
 752       yy_current_state = (yy_start);
 753     yy_match:
 754       do {
 755         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 756         if (yy_accept[yy_current_state]) {
 757           (yy_last_accepting_state) = yy_current_state;
 758           (yy_last_accepting_cpos)  = yy_cp;
 759         }
 760         while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
 761           yy_current_state = (int)yy_def[yy_current_state];
 762           if (yy_current_state >= 54)
 763             yy_c = yy_meta[(unsigned int)yy_c];
 764         }
 765         yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t)yy_c];
 766         ++yy_cp;
 767       } while (yy_base[yy_current_state] != 90);
 768
 769     yy_find_action:
 770       yy_act = yy_accept[yy_current_state];
 771       if (yy_act == 0) { /* have to back up */
 772         yy_cp            = (yy_last_accepting_cpos);
 773         yy_current_state = (yy_last_accepting_state);
 774         yy_act           = yy_accept[yy_current_state];
 775       }
 776
 777       YY_DO_BEFORE_ACTION;
 778
 779     do_action: /* This label is used only to access EOF actions. */
 780
 781       switch (yy_act) { /* beginning of action switch */
 782         case 0:         /* must back up */
 783           /* undo the effects of YY_DO_BEFORE_ACTION */
 784           *yy_cp           = (yy_hold_char);
 785           yy_cp            = (yy_last_accepting_cpos);
 786           yy_current_state = (yy_last_accepting_state);
 787           goto yy_find_action;
 788
 789         case 1:
 790           YY_RULE_SETUP
 791 #line 40 "parserPromela.lex"
 792 { return (NEVER); }
 793 YY_BREAK
 794 case 2:
 795 YY_RULE_SETUP
 796 #line 41 "parserPromela.lex"
 797 { return (IF); }
 798 YY_BREAK
 799 case 3:
 800 YY_RULE_SETUP
 801 #line 42 "parserPromela.lex"
 802 { return (FI); }
 803 YY_BREAK
 804 case 4:
 805 YY_RULE_SETUP
 806 #line 43 "parserPromela.lex"
 807 { return (IMPLIES); }
 808 YY_BREAK
 809 case 5:
 810 YY_RULE_SETUP
 811 #line 44 "parserPromela.lex"
 812 { return (GOTO); }
 813 YY_BREAK
 814 case 6:
 815 YY_RULE_SETUP
 816 #line 45 "parserPromela.lex"
 817 { return (AND); }
 818 YY_BREAK
 819 case 7:
 820 YY_RULE_SETUP
 821 #line 46 "parserPromela.lex"
 822 { return (OR); }
 823 YY_BREAK
 824 case 8:
 825 YY_RULE_SETUP
 826 #line 47 "parserPromela.lex"
 827 { return (NOT); }
 828 YY_BREAK
 829 case 9:
 830 YY_RULE_SETUP
 831 #line 48 "parserPromela.lex"
 832 { return (LEFT_PAR); }
 833 YY_BREAK
 834 case 10:
 835 YY_RULE_SETUP
 836 #line 49 "parserPromela.lex"
 837 { return (RIGHT_PAR); }
 838 YY_BREAK
 839 case 11:
 840 YY_RULE_SETUP
 841 #line 50 "parserPromela.lex"
 842 { return (CASE); }
 843 YY_BREAK
 844 case 12:
 845 YY_RULE_SETUP
 846 #line 51 "parserPromela.lex"
 847 { return (COLON); }
 848 YY_BREAK
 849 case 13:
 850 YY_RULE_SETUP
 851 #line 52 "parserPromela.lex"
 852 { return (SEMI_COLON); }
 853 YY_BREAK
 854 case 14:
 855 YY_RULE_SETUP
 856 #line 53 "parserPromela.lex"
 857 { return (CASE_TRUE); }
 858 YY_BREAK
 859 case 15:
 860 YY_RULE_SETUP
 861 #line 54 "parserPromela.lex"
 862 { return (LEFT_BRACE); }
 863 YY_BREAK
 864 case 16:
 865 YY_RULE_SETUP
 866 #line 55 "parserPromela.lex"
 867 { return (RIGHT_BRACE); }
 868 YY_BREAK
 869 case 17:
 870 /* rule 17 can match eol */
 871 YY_RULE_SETUP
 872 #line 58 "parserPromela.lex"
 873 { }
 874 YY_BREAK
 875 case 18:
 876 YY_RULE_SETUP
 877 #line 60 "parserPromela.lex"
 878 { }
 879 YY_BREAK
 880 case 19:
 881 YY_RULE_SETUP
 882 #line 63 "parserPromela.lex"
 883 { sscanf(xbt_automaton_parser_text,"%lf",&yylval.real);
 884                             return (LITT_REEL); }
 885 YY_BREAK
 886 case 20:
 887 YY_RULE_SETUP
 888 #line 66 "parserPromela.lex"
 889 { sscanf(xbt_automaton_parser_text,"%d",&yylval.integer);
 890                             return (LITT_ENT); }
 891 YY_BREAK
 892 case 21:
 893 /* rule 21 can match eol */
 894 YY_RULE_SETUP
 895 #line 69 "parserPromela.lex"
 896 { yylval.string=(char *)malloc(strlen(xbt_automaton_parser_text)+1);
 897                             sscanf(xbt_automaton_parser_text,"%s",yylval.string);
 898                             return (LITT_CHAINE); }
 899 YY_BREAK
 900 case 22:
 901 YY_RULE_SETUP
 902 #line 73 "parserPromela.lex"
 903 { yylval.string=(char *)malloc(strlen(xbt_automaton_parser_text)+1);
 904                             sscanf(xbt_automaton_parser_text,"%s",yylval.string);
 905                             return (ID);
 906 }
 907 YY_BREAK
 908 case 23:
 909 /* rule 23 can match eol */
 910 YY_RULE_SETUP
 911 #line 77 "parserPromela.lex"
 912 { }
 913 YY_BREAK
 914 case 24:
 915 YY_RULE_SETUP
 916 #line 79 "parserPromela.lex"
 917 { }
 918 YY_BREAK
 919 case 25:
 920 YY_RULE_SETUP
 921 #line 81 "parserPromela.lex"
 922 ECHO;
 923 YY_BREAK
 924 #line 945 "automaton_lexer.yy.c"
 925 case YY_STATE_EOF(INITIAL):
 926   yyterminate();
 927
 928 case YY_END_OF_BUFFER: {
 929   /* Amount of text matched not including the EOB char. */
 930   int yy_amount_of_matched_text = (int)(yy_cp - (yytext_ptr)) - 1;
 931
 932   /* Undo the effects of YY_DO_BEFORE_ACTION. */
 933   *yy_cp = (yy_hold_char);
 934   YY_RESTORE_YY_MORE_OFFSET
 935
 936   if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW) {
 937     /* We're scanning a new file or input source.  It's
 938      * possible that this happened because the user
 939      * just pointed xbt_automaton_parser_in at a new source and called
 940      * xbt_automaton_parser_lex().  If so, then we have to assure
 941      * consistency between YY_CURRENT_BUFFER and our
 942      * globals.  Here is the right place to do so, because
 943      * this is the first action (other than possibly a
 944      * back-up) that will match for the new input source.
 945      */
 946     (yy_n_chars)                               = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 947     YY_CURRENT_BUFFER_LVALUE->yy_input_file    = xbt_automaton_parser_in;
 948     YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 949   }
 950
 951   /* Note that here we test for yy_c_buf_p "<=" to the position
 952    * of the first EOB in the buffer, since yy_c_buf_p will
 953    * already have been incremented past the NUL character
 954    * (since all states make transitions on EOB to the
 955    * end-of-buffer state).  Contrast this with the test
 956    * in input().
 957    */
 958   if ((yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]) { /* This was really a NUL. */
 959     yy_state_type yy_next_state;
 960
 961     (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 962
 963     yy_current_state = yy_get_previous_state();
 964
 965     /* Okay, we're now positioned to make the NUL
 966      * transition.  We couldn't have
 967      * yy_get_previous_state() go ahead and do it
 968      * for us because it doesn't know how to deal
 969      * with the possibility of jamming (and we don't
 970      * want to build jamming into it because then it
 971      * will run more slowly).
 972      */
 973
 974     yy_next_state = yy_try_NUL_trans(yy_current_state);
 975
 976     yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 977
 978     if (yy_next_state) {
 979       /* Consume the NUL. */
 980       yy_cp            = ++(yy_c_buf_p);
 981       yy_current_state = yy_next_state;
 982       goto yy_match;
 983     }
 984
 985     else {
 986       yy_cp = (yy_c_buf_p);
 987       goto yy_find_action;
 988     }
 989   }
 990
 991   else
 992     switch (yy_get_next_buffer()) {
 993       case EOB_ACT_END_OF_FILE: {
 994         (yy_did_buffer_switch_on_eof) = 0;
 995
 996         if (xbt_automaton_parser_wrap()) {
 997           /* Note: because we've taken care in
 998            * yy_get_next_buffer() to have set up
 999            * xbt_automaton_parser_text, we can now set up
1000            * yy_c_buf_p so that if some total
1001            * hoser (like flex itself) wants to
1002            * call the scanner after we return the
1003            * YY_NULL, it'll still work - another
1004            * YY_NULL will get returned.
1005            */
1006           (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1007
1008           yy_act = YY_STATE_EOF(YY_START);
1009           goto do_action;
1010         }
1011
1012         else {
1013           if (!(yy_did_buffer_switch_on_eof))
1014             YY_NEW_FILE;
1015         }
1016         break;
1017       }
1018
1019       case EOB_ACT_CONTINUE_SCAN:
1020         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1021
1022         yy_current_state = yy_get_previous_state();
1023
1024         yy_cp = (yy_c_buf_p);
1025         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1026         goto yy_match;
1027
1028       case EOB_ACT_LAST_MATCH:
1029         (yy_c_buf_p) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1030
1031         yy_current_state = yy_get_previous_state();
1032
1033         yy_cp = (yy_c_buf_p);
1034         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1035         goto yy_find_action;
1036     }
1037   break;
1038 }
1039
1040 default:
1041   YY_FATAL_ERROR("fatal flex scanner internal error--no action found");
1042       } /* end of action switch */
1043     }   /* end of scanning one token */
1044   }     /* end of user's declarations */
1045 } /* end of xbt_automaton_parser_lex */
1046
1047 /* yy_get_next_buffer - try to read in a new buffer
1048  *
1049  * Returns a code representing an action:
1050  *      EOB_ACT_LAST_MATCH -
1051  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1052  *      EOB_ACT_END_OF_FILE - end of file
1053  */
1054 static int yy_get_next_buffer (void)
1055 {
1056   char* dest   = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1057   char* source = (yytext_ptr);
1058   int number_to_move, i;
1059   int ret_val;
1060
1061   if ((yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1])
1062     YY_FATAL_ERROR("fatal flex scanner internal error--end of buffer missed");
1063
1064   if (YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0) { /* Don't try to fill the buffer, so this is an EOF. */
1065     if ((yy_c_buf_p) - (yytext_ptr)-YY_MORE_ADJ == 1) {
1066       /* We matched a single character, the EOB, so
1067        * treat this as a final EOF.
1068        */
1069       return EOB_ACT_END_OF_FILE;
1070     }
1071
1072     else {
1073       /* We matched some text prior to the EOB, first
1074        * process it.
1075        */
1076       return EOB_ACT_LAST_MATCH;
1077     }
1078   }
1079
1080   /* Try to read more data. */
1081
1082   /* First move last chars to start of buffer. */
1083   number_to_move = (int)((yy_c_buf_p) - (yytext_ptr)-1);
1084
1085   for (i = 0; i < number_to_move; ++i)
1086     *(dest++) = *(source++);
1087
1088   if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING)
1089     /* don't do the read, it's not guaranteed to return an EOF,
1090      * just force an EOF
1091      */
1092     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1093
1094   else {
1095     int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1096
1097     while (num_to_read <= 0) { /* Not enough room in the buffer - grow it. */
1098
1099       /* just a shorter name for the current buffer */
1100       YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1101
1102       int yy_c_buf_p_offset = (int)((yy_c_buf_p)-b->yy_ch_buf);
1103
1104       if (b->yy_is_our_buffer) {
1105         int new_size = b->yy_buf_size * 2;
1106
1107         if (new_size <= 0)
1108           b->yy_buf_size += b->yy_buf_size / 8;
1109         else
1110           b->yy_buf_size *= 2;
1111
1112         b->yy_ch_buf = (char*)
1113             /* Include room in for 2 EOB chars. */
1114             xbt_automaton_parser_realloc((void*)b->yy_ch_buf, b->yy_buf_size + 2);
1115       } else
1116         /* Can't grow it, we don't own it. */
1117         b->yy_ch_buf = NULL;
1118
1119       if (!b->yy_ch_buf)
1120         YY_FATAL_ERROR("fatal error - scanner input buffer overflow");
1121
1122       (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1123
1124       num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1125     }
1126
1127     if (num_to_read > YY_READ_BUF_SIZE)
1128       num_to_read = YY_READ_BUF_SIZE;
1129
1130     /* Read in more data. */
1131     YY_INPUT((&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), (yy_n_chars), num_to_read);
1132
1133     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1134   }
1135
1136   if ((yy_n_chars) == 0) {
1137     if (number_to_move == YY_MORE_ADJ) {
1138       ret_val = EOB_ACT_END_OF_FILE;
1139       xbt_automaton_parser_restart(xbt_automaton_parser_in);
1140     }
1141
1142     else {
1143       ret_val                                    = EOB_ACT_LAST_MATCH;
1144       YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING;
1145     }
1146   }
1147
1148   else
1149     ret_val = EOB_ACT_CONTINUE_SCAN;
1150
1151   if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1152     /* Extend the array by 50%, plus the number we really need. */
1153     int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1154     YY_CURRENT_BUFFER_LVALUE->yy_ch_buf =
1155         (char*)xbt_automaton_parser_realloc((void*)YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, new_size);
1156     if (!YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
1157       YY_FATAL_ERROR("out of dynamic memory in yy_get_next_buffer()");
1158   }
1159
1160   (yy_n_chars) += number_to_move;
1161   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]     = YY_END_OF_BUFFER_CHAR;
1162   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1163
1164   (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1165
1166   return ret_val;
1167 }
1168
1169 /* yy_get_previous_state - get the state just before the EOB char was reached */
1170
1171     static yy_state_type yy_get_previous_state (void)
1172 {
1173   yy_state_type yy_current_state;
1174   char* yy_cp;
1175
1176   yy_current_state = (yy_start);
1177
1178   for (yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp) {
1179     YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1180     if (yy_accept[yy_current_state]) {
1181       (yy_last_accepting_state) = yy_current_state;
1182       (yy_last_accepting_cpos)  = yy_cp;
1183     }
1184     while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
1185       yy_current_state = (int)yy_def[yy_current_state];
1186       if (yy_current_state >= 54)
1187         yy_c = yy_meta[(unsigned int)yy_c];
1188     }
1189     yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t)yy_c];
1190   }
1191
1192   return yy_current_state;
1193 }
1194
1195 /* yy_try_NUL_trans - try to make a transition on the NUL character
1196  *
1197  * synopsis
1198  *      next_state = yy_try_NUL_trans( current_state );
1199  */
1200 static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
1201 {
1202   int yy_is_jam;
1203   char* yy_cp = (yy_c_buf_p);
1204
1205   YY_CHAR yy_c = 1;
1206   if (yy_accept[yy_current_state]) {
1207     (yy_last_accepting_state) = yy_current_state;
1208     (yy_last_accepting_cpos)  = yy_cp;
1209   }
1210   while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {
1211     yy_current_state = (int)yy_def[yy_current_state];
1212     if (yy_current_state >= 54)
1213       yy_c = yy_meta[(unsigned int)yy_c];
1214   }
1215   yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t)yy_c];
1216   yy_is_jam        = (yy_current_state == 53);
1217
1218   return yy_is_jam ? 0 : yy_current_state;
1219 }
1220
1221 #ifndef YY_NO_UNPUT
1222
1223     static void yyunput (int c, char * yy_bp )
1224 {
1225   char* yy_cp;
1226
1227   yy_cp = (yy_c_buf_p);
1228
1229   /* undo effects of setting up xbt_automaton_parser_text */
1230   *yy_cp = (yy_hold_char);
1231
1232   if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2) { /* need to shift things up to make room */
1233     /* +2 for EOB chars. */
1234     int number_to_move = (yy_n_chars) + 2;
1235     char* dest         = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1236     char* source       = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1237
1238     while (source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf)
1239       *--dest = *--source;
1240
1241     yy_cp += (int)(dest - source);
1242     yy_bp += (int)(dest - source);
1243     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = (int)YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1244
1245     if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2)
1246       YY_FATAL_ERROR("flex scanner push-back overflow");
1247   }
1248
1249   *--yy_cp = (char)c;
1250
1251   (yytext_ptr)   = yy_bp;
1252   (yy_hold_char) = *yy_cp;
1253   (yy_c_buf_p)   = yy_cp;
1254 }
1255
1256 #endif
1257
1258 #ifndef YY_NO_INPUT
1259 #ifdef __cplusplus
1260     static int yyinput (void)
1261 #else
1262     static int input  (void)
1263 #endif
1264
1265 {
1266   int c;
1267
1268   *(yy_c_buf_p) = (yy_hold_char);
1269
1270   if (*(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR) {
1271     /* yy_c_buf_p now points to the character we want to return.
1272      * If this occurs *before* the EOB characters, then it's a
1273      * valid NUL; if not, then we've hit the end of the buffer.
1274      */
1275     if ((yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)])
1276       /* This was really a NUL. */
1277       *(yy_c_buf_p) = '\0';
1278
1279     else { /* need more input */
1280       int offset = (yy_c_buf_p) - (yytext_ptr);
1281       ++(yy_c_buf_p);
1282
1283       switch (yy_get_next_buffer()) {
1284         case EOB_ACT_LAST_MATCH:
1285           /* This happens because yy_g_n_b()
1286            * sees that we've accumulated a
1287            * token and flags that we need to
1288            * try matching the token before
1289            * proceeding.  But for input(),
1290            * there's no matching to consider.
1291            * So convert the EOB_ACT_LAST_MATCH
1292            * to EOB_ACT_END_OF_FILE.
1293            */
1294
1295           /* Reset buffer status. */
1296           xbt_automaton_parser_restart(xbt_automaton_parser_in);
1297
1298           /*FALLTHROUGH*/
1299
1300         case EOB_ACT_END_OF_FILE: {
1301           if (xbt_automaton_parser_wrap())
1302             return 0;
1303
1304           if (!(yy_did_buffer_switch_on_eof))
1305             YY_NEW_FILE;
1306 #ifdef __cplusplus
1307           return yyinput();
1308 #else
1309           return input();
1310 #endif
1311         }
1312
1313         case EOB_ACT_CONTINUE_SCAN:
1314           (yy_c_buf_p) = (yytext_ptr) + offset;
1315           break;
1316       }
1317     }
1318   }
1319
1320   c              = *(unsigned char*)(yy_c_buf_p); /* cast for 8-bit char's */
1321   *(yy_c_buf_p)  = '\0';                          /* preserve xbt_automaton_parser_text */
1322   (yy_hold_char) = *++(yy_c_buf_p);
1323
1324   return c;
1325 }
1326 #endif /* ifndef YY_NO_INPUT */
1327
1328 /** Immediately switch to a different input stream.
1329  * @param input_file A readable stream.
1330  *
1331  * @note This function does not reset the start condition to @c INITIAL .
1332  */
1333 void xbt_automaton_parser_restart(FILE* input_file)
1334 {
1335
1336   if (!YY_CURRENT_BUFFER) {
1337     xbt_automaton_parser_ensure_buffer_stack();
1338     YY_CURRENT_BUFFER_LVALUE = xbt_automaton_parser__create_buffer(xbt_automaton_parser_in, YY_BUF_SIZE);
1339   }
1340
1341   xbt_automaton_parser__init_buffer(YY_CURRENT_BUFFER, input_file);
1342   xbt_automaton_parser__load_buffer_state();
1343 }
1344
1345 /** Switch to a different input buffer.
1346  * @param new_buffer The new input buffer.
1347  *
1348  */
1349 void xbt_automaton_parser__switch_to_buffer(YY_BUFFER_STATE new_buffer)
1350 {
1351
1352   /* TODO. We should be able to replace this entire function body
1353    * with
1354    *            xbt_automaton_parser_pop_buffer_state();
1355    *            xbt_automaton_parser_push_buffer_state(new_buffer);
1356    */
1357   xbt_automaton_parser_ensure_buffer_stack();
1358   if (YY_CURRENT_BUFFER == new_buffer)
1359     return;
1360
1361   if (YY_CURRENT_BUFFER) {
1362     /* Flush out information for old buffer. */
1363     *(yy_c_buf_p)                        = (yy_hold_char);
1364     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1365     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1366   }
1367
1368   YY_CURRENT_BUFFER_LVALUE = new_buffer;
1369   xbt_automaton_parser__load_buffer_state();
1370
1371   /* We don't actually know whether we did this switch during
1372    * EOF (xbt_automaton_parser_wrap()) processing, but the only time this flag
1373    * is looked at is after xbt_automaton_parser_wrap() is called, so it's safe
1374    * to go ahead and always set it.
1375    */
1376   (yy_did_buffer_switch_on_eof) = 1;
1377 }
1378
1379 static void xbt_automaton_parser__load_buffer_state  (void)
1380 {
1381   (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1382   (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1383   xbt_automaton_parser_in     = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1384   (yy_hold_char)              = *(yy_c_buf_p);
1385 }
1386
1387 /** Allocate and initialize an input buffer state.
1388  * @param file A readable stream.
1389  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1390  *
1391  * @return the allocated buffer state.
1392  */
1393 YY_BUFFER_STATE xbt_automaton_parser__create_buffer(FILE* file, int size)
1394 {
1395   YY_BUFFER_STATE b;
1396
1397   b = (YY_BUFFER_STATE)xbt_automaton_parser_alloc(sizeof(struct yy_buffer_state));
1398   if (!b)
1399     YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__create_buffer()");
1400
1401   b->yy_buf_size = (yy_size_t)size;
1402
1403   /* yy_ch_buf has to be 2 characters longer than the size given because
1404    * we need to put in 2 end-of-buffer characters.
1405    */
1406   b->yy_ch_buf = (char*)xbt_automaton_parser_alloc(b->yy_buf_size + 2);
1407   if (!b->yy_ch_buf)
1408     YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__create_buffer()");
1409
1410   b->yy_is_our_buffer = 1;
1411
1412   xbt_automaton_parser__init_buffer(b, file);
1413
1414   return b;
1415 }
1416
1417 /** Destroy the buffer.
1418  * @param b a buffer created with xbt_automaton_parser__create_buffer()
1419  *
1420  */
1421 void xbt_automaton_parser__delete_buffer(YY_BUFFER_STATE b)
1422 {
1423
1424   if (!b)
1425     return;
1426
1427   if (b == YY_CURRENT_BUFFER) /* Not sure if we should pop here. */
1428     YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE)0;
1429
1430   if (b->yy_is_our_buffer)
1431     xbt_automaton_parser_free((void*)b->yy_ch_buf);
1432
1433   xbt_automaton_parser_free((void*)b);
1434 }
1435
1436 /* Initializes or reinitializes a buffer.
1437  * This function is sometimes called more than once on the same buffer,
1438  * such as during a xbt_automaton_parser_restart() or at EOF.
1439  */
1440     static void xbt_automaton_parser__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1441
1442 {
1443   int oerrno = errno;
1444
1445   xbt_automaton_parser__flush_buffer(b);
1446
1447   b->yy_input_file  = file;
1448   b->yy_fill_buffer = 1;
1449
1450   /* If b is the current buffer, then xbt_automaton_parser__init_buffer was _probably_
1451    * called from xbt_automaton_parser_restart() or through yy_get_next_buffer.
1452    * In that case, we don't want to reset the lineno or column.
1453    */
1454   if (b != YY_CURRENT_BUFFER) {
1455     b->yy_bs_lineno = 1;
1456     b->yy_bs_column = 0;
1457     }
1458
1459         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1460
1461         errno = oerrno;
1462 }
1463
1464 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1465  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1466  *
1467  */
1468 void xbt_automaton_parser__flush_buffer(YY_BUFFER_STATE b)
1469 {
1470   if (!b)
1471     return;
1472
1473   b->yy_n_chars = 0;
1474
1475   /* We always need two end-of-buffer characters.  The first causes
1476    * a transition to the end-of-buffer state.  The second causes
1477    * a jam in that state.
1478    */
1479   b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1480   b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1481
1482   b->yy_buf_pos = &b->yy_ch_buf[0];
1483
1484   b->yy_at_bol        = 1;
1485   b->yy_buffer_status = YY_BUFFER_NEW;
1486
1487   if (b == YY_CURRENT_BUFFER)
1488     xbt_automaton_parser__load_buffer_state();
1489 }
1490
1491 /** Pushes the new state onto the stack. The new state becomes
1492  *  the current state. This function will allocate the stack
1493  *  if necessary.
1494  *  @param new_buffer The new state.
1495  *
1496  */
1497 void xbt_automaton_parser_push_buffer_state (YY_BUFFER_STATE new_buffer )
1498 {
1499   if (new_buffer == NULL)
1500     return;
1501
1502   xbt_automaton_parser_ensure_buffer_stack();
1503
1504   /* This block is copied from xbt_automaton_parser__switch_to_buffer. */
1505   if (YY_CURRENT_BUFFER) {
1506     /* Flush out information for old buffer. */
1507     *(yy_c_buf_p)                        = (yy_hold_char);
1508     YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1509     YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1510   }
1511
1512   /* Only push if top exists. Otherwise, replace top. */
1513   if (YY_CURRENT_BUFFER)
1514     (yy_buffer_stack_top)++;
1515   YY_CURRENT_BUFFER_LVALUE = new_buffer;
1516
1517   /* copied from xbt_automaton_parser__switch_to_buffer. */
1518   xbt_automaton_parser__load_buffer_state();
1519   (yy_did_buffer_switch_on_eof) = 1;
1520 }
1521
1522 /** Removes and deletes the top of the stack, if present.
1523  *  The next element becomes the new top.
1524  *
1525  */
1526 void xbt_automaton_parser_pop_buffer_state (void)
1527 {
1528   if (!YY_CURRENT_BUFFER)
1529     return;
1530
1531   xbt_automaton_parser__delete_buffer(YY_CURRENT_BUFFER);
1532   YY_CURRENT_BUFFER_LVALUE = NULL;
1533   if ((yy_buffer_stack_top) > 0)
1534     --(yy_buffer_stack_top);
1535
1536   if (YY_CURRENT_BUFFER) {
1537     xbt_automaton_parser__load_buffer_state();
1538     (yy_did_buffer_switch_on_eof) = 1;
1539   }
1540 }
1541
1542 /* Allocates the stack if it does not exist.
1543  *  Guarantees space for at least one push.
1544  */
1545 static void xbt_automaton_parser_ensure_buffer_stack (void)
1546 {
1547   int num_to_alloc;
1548
1549   if (!(yy_buffer_stack)) {
1550
1551     /* First allocation is just for 2 elements, since we don't know if this
1552      * scanner will even need a stack. We use 2 instead of 1 to avoid an
1553      * immediate realloc on the next call.
1554      */
1555     num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1556     (yy_buffer_stack) =
1557         (struct yy_buffer_state**)xbt_automaton_parser_alloc(num_to_alloc * sizeof(struct yy_buffer_state*));
1558     if (!(yy_buffer_stack))
1559       YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser_ensure_buffer_stack()");
1560
1561     memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1562
1563     (yy_buffer_stack_max) = num_to_alloc;
1564     (yy_buffer_stack_top) = 0;
1565     return;
1566   }
1567
1568   if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1) {
1569
1570     /* Increase the buffer to prepare for a possible push. */
1571     yy_size_t grow_size = 8 /* arbitrary grow size */;
1572
1573     num_to_alloc      = (yy_buffer_stack_max) + grow_size;
1574     (yy_buffer_stack) = (struct yy_buffer_state**)xbt_automaton_parser_realloc(
1575         (yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*));
1576     if (!(yy_buffer_stack))
1577       YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser_ensure_buffer_stack()");
1578
1579     /* zero only the new slots.*/
1580     memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1581     (yy_buffer_stack_max) = num_to_alloc;
1582   }
1583 }
1584
1585 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1586  * @param base the character buffer
1587  * @param size the size in bytes of the character buffer
1588  *
1589  * @return the newly allocated buffer state object.
1590  */
1591 YY_BUFFER_STATE xbt_automaton_parser__scan_buffer  (char * base, yy_size_t  size )
1592 {
1593   YY_BUFFER_STATE b;
1594
1595   if (size < 2 || base[size - 2] != YY_END_OF_BUFFER_CHAR || base[size - 1] != YY_END_OF_BUFFER_CHAR)
1596     /* They forgot to leave room for the EOB's. */
1597     return NULL;
1598
1599   b = (YY_BUFFER_STATE)xbt_automaton_parser_alloc(sizeof(struct yy_buffer_state));
1600   if (!b)
1601     YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__scan_buffer()");
1602
1603   b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1604   b->yy_buf_pos = b->yy_ch_buf = base;
1605   b->yy_is_our_buffer          = 0;
1606   b->yy_input_file             = NULL;
1607   b->yy_n_chars                = b->yy_buf_size;
1608   b->yy_is_interactive         = 0;
1609   b->yy_at_bol                 = 1;
1610   b->yy_fill_buffer            = 0;
1611   b->yy_buffer_status          = YY_BUFFER_NEW;
1612
1613   xbt_automaton_parser__switch_to_buffer(b);
1614
1615   return b;
1616 }
1617
1618 /** Setup the input buffer state to scan a string. The next call to xbt_automaton_parser_lex() will
1619  * scan from a @e copy of @a str.
1620  * @param yystr a NUL-terminated string to scan
1621  *
1622  * @return the newly allocated buffer state object.
1623  * @note If you want to scan bytes that may contain NUL values, then use
1624  *       xbt_automaton_parser__scan_bytes() instead.
1625  */
1626 YY_BUFFER_STATE xbt_automaton_parser__scan_string (yyconst char * yystr )
1627 {
1628
1629   return xbt_automaton_parser__scan_bytes(yystr, (int)strlen(yystr));
1630 }
1631
1632 /** Setup the input buffer state to scan the given bytes. The next call to xbt_automaton_parser_lex() will
1633  * scan from a @e copy of @a bytes.
1634  * @param yybytes the byte buffer to scan
1635  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1636  *
1637  * @return the newly allocated buffer state object.
1638  */
1639 YY_BUFFER_STATE xbt_automaton_parser__scan_bytes(yyconst char* yybytes, int _yybytes_len)
1640 {
1641   YY_BUFFER_STATE b;
1642   char* buf;
1643   yy_size_t n;
1644   int i;
1645
1646   /* Get memory for full buffer, including space for trailing EOB's. */
1647   n   = (yy_size_t)(_yybytes_len + 2);
1648   buf = (char*)xbt_automaton_parser_alloc(n);
1649   if (!buf)
1650     YY_FATAL_ERROR("out of dynamic memory in xbt_automaton_parser__scan_bytes()");
1651
1652   for (i = 0; i < _yybytes_len; ++i)
1653     buf[i] = yybytes[i];
1654
1655   buf[_yybytes_len] = buf[_yybytes_len + 1] = YY_END_OF_BUFFER_CHAR;
1656
1657   b = xbt_automaton_parser__scan_buffer(buf, n);
1658   if (!b)
1659     YY_FATAL_ERROR("bad buffer in xbt_automaton_parser__scan_bytes()");
1660
1661   /* It's okay to grow etc. this buffer, and we should throw it
1662    * away when we're done.
1663    */
1664   b->yy_is_our_buffer = 1;
1665
1666   return b;
1667 }
1668
1669 #ifndef YY_EXIT_FAILURE
1670 #define YY_EXIT_FAILURE 2
1671 #endif
1672
1673 static void yynoreturn yy_fatal_error(yyconst char* msg)
1674 {
1675   (void)fprintf(stderr, "%s\n", msg);
1676   exit(YY_EXIT_FAILURE);
1677 }
1678
1679 /* Redefine yyless() so it works in section 3 code. */
1680
1681 #undef yyless
1682 #define yyless(n)                                                                                                      \
1683   do {                                                                                                                 \
1684     /* Undo effects of setting up xbt_automaton_parser_text. */                                                        \
1685     int yyless_macro_arg = (n);                                                                                        \
1686     YY_LESS_LINENO(yyless_macro_arg);                                                                                  \
1687     xbt_automaton_parser_text[xbt_automaton_parser_leng] = (yy_hold_char);                                             \
1688     (yy_c_buf_p)                                         = xbt_automaton_parser_text + yyless_macro_arg;               \
1689     (yy_hold_char)                                       = *(yy_c_buf_p);                                              \
1690     *(yy_c_buf_p)                                        = '\0';                                                       \
1691     xbt_automaton_parser_leng                            = yyless_macro_arg;                                           \
1692   } while (0)
1693
1694 /* Accessor  methods (get/set functions) to struct members. */
1695
1696 /** Get the current line number.
1697  *
1698  */
1699 int xbt_automaton_parser_get_lineno  (void)
1700 {
1701
1702     return xbt_automaton_parser_lineno;
1703 }
1704
1705 /** Get the input stream.
1706  *
1707  */
1708 FILE *xbt_automaton_parser_get_in  (void)
1709 {
1710         return xbt_automaton_parser_in;
1711 }
1712
1713 /** Get the output stream.
1714  *
1715  */
1716 FILE *xbt_automaton_parser_get_out  (void)
1717 {
1718         return xbt_automaton_parser_out;
1719 }
1720
1721 /** Get the length of the current token.
1722  *
1723  */
1724 int xbt_automaton_parser_get_leng(void)
1725 {
1726         return xbt_automaton_parser_leng;
1727 }
1728
1729 /** Get the current token.
1730  *
1731  */
1732
1733 char *xbt_automaton_parser_get_text  (void)
1734 {
1735         return xbt_automaton_parser_text;
1736 }
1737
1738 /** Set the current line number.
1739  * @param _line_number line number
1740  *
1741  */
1742 void xbt_automaton_parser_set_lineno (int  _line_number )
1743 {
1744
1745     xbt_automaton_parser_lineno = _line_number;
1746 }
1747
1748 /** Set the input stream. This does not discard the current
1749  * input buffer.
1750  * @param _in_str A readable stream.
1751  *
1752  * @see xbt_automaton_parser__switch_to_buffer
1753  */
1754 void xbt_automaton_parser_set_in (FILE *  _in_str )
1755 {
1756         xbt_automaton_parser_in = _in_str ;
1757 }
1758
1759 void xbt_automaton_parser_set_out (FILE *  _out_str )
1760 {
1761         xbt_automaton_parser_out = _out_str ;
1762 }
1763
1764 int xbt_automaton_parser_get_debug  (void)
1765 {
1766         return xbt_automaton_parser__flex_debug;
1767 }
1768
1769 void xbt_automaton_parser_set_debug (int  _bdebug )
1770 {
1771         xbt_automaton_parser__flex_debug = _bdebug ;
1772 }
1773
1774 static int yy_init_globals (void)
1775 {
1776         /* Initialization is the same as for the non-reentrant scanner.
1777      * This function is called from xbt_automaton_parser_lex_destroy(), so don't allocate here.
1778      */
1779
1780         (yy_buffer_stack)     = NULL;
1781         (yy_buffer_stack_top) = 0;
1782         (yy_buffer_stack_max) = 0;
1783         (yy_c_buf_p)          = NULL;
1784         (yy_init)             = 0;
1785         (yy_start)            = 0;
1786
1787 /* Defined in main.c */
1788 #ifdef YY_STDINIT
1789     xbt_automaton_parser_in = stdin;
1790     xbt_automaton_parser_out = stdout;
1791 #else
1792   xbt_automaton_parser_in  = NULL;
1793   xbt_automaton_parser_out = NULL;
1794 #endif
1795
1796     /* For future reference: Set errno on error, since we are called by
1797      * xbt_automaton_parser_lex_init()
1798      */
1799     return 0;
1800 }
1801
1802 /* xbt_automaton_parser_lex_destroy is for both reentrant and non-reentrant scanners. */
1803 int xbt_automaton_parser_lex_destroy  (void)
1804 {
1805
1806     /* Pop the buffer stack, destroying each element. */
1807     while (YY_CURRENT_BUFFER) {
1808       xbt_automaton_parser__delete_buffer(YY_CURRENT_BUFFER);
1809       YY_CURRENT_BUFFER_LVALUE = NULL;
1810       xbt_automaton_parser_pop_buffer_state();
1811     }
1812
1813     /* Destroy the stack itself. */
1814     xbt_automaton_parser_free((yy_buffer_stack));
1815     (yy_buffer_stack) = NULL;
1816
1817     /* Reset the globals. This is important in a non-reentrant scanner so the next time
1818      * xbt_automaton_parser_lex() is called, initialization will occur. */
1819     yy_init_globals( );
1820
1821     return 0;
1822 }
1823
1824 /*
1825  * Internal utility routines.
1826  */
1827
1828 #ifndef yytext_ptr
1829 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1830 {
1831
1832   int i;
1833   for (i = 0; i < n; ++i)
1834     s1[i] = s2[i];
1835 }
1836 #endif
1837
1838 #ifdef YY_NEED_STRLEN
1839 static int yy_flex_strlen (yyconst char * s )
1840 {
1841   int n;
1842   for (n = 0; s[n]; ++n)
1843     ;
1844
1845   return n;
1846 }
1847 #endif
1848
1849 void *xbt_automaton_parser_alloc (yy_size_t  size )
1850 {
1851   return malloc(size);
1852 }
1853
1854 void *xbt_automaton_parser_realloc  (void * ptr, yy_size_t  size )
1855 {
1856
1857   /* The cast to (char *) in the following accommodates both
1858    * implementations that use char* generic pointers, and those
1859    * that use void* generic pointers.  It works with the latter
1860    * because both ANSI C and C++ allow castless assignment from
1861    * any pointer type to void*, and deal with argument conversions
1862    * as though doing an assignment.
1863    */
1864   return realloc(ptr, size);
1865 }
1866
1867 void xbt_automaton_parser_free (void * ptr )
1868 {
1869   free((char*)ptr); /* see xbt_automaton_parser_realloc() for (char *) cast */
1870 }
1871
1872 #define YYTABLES_NAME "yytables"
1873
1874 #line 81 "parserPromela.lex"
1875
1876
1877
1878
1879