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