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
 541 #ifdef _MSC_VER
 542 # include <io.h>
 543 # include <process.h>
 544 # define _CRT_SECURE_NO_WARNINGS
 545 # define _CRT_NONSTDC_NO_WARNINGS
 546 #endif
 547 #endif
 548
 549 #include <stdio.h>
 550 #include "parserPromela.tab.hacc"
 551
 552   extern YYSTYPE yylval;
 553
 554 #line 555 "automaton_lexer.yy.c"
 555
 556 #define INITIAL 0
 557
 558 #ifndef YY_NO_UNISTD_H
 559 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 560  * down here because we want the user's section 1 to have been scanned first.
 561  * The user has a chance to override it with an option.
 562  */
 563 #include <unistd.h>
 564 #endif
 565
 566 #ifndef YY_EXTRA_TYPE
 567 #define YY_EXTRA_TYPE void *
 568 #endif
 569
 570 static int yy_init_globals (void );
 571
 572 /* Accessor methods to globals.
 573    These are made visible to non-reentrant scanners for convenience. */
 574
 575 int xbt_automaton_parser_lex_destroy (void );
 576
 577 int xbt_automaton_parser_get_debug (void );
 578
 579 void xbt_automaton_parser_set_debug (int debug_flag  );
 580
 581 YY_EXTRA_TYPE xbt_automaton_parser_get_extra (void );
 582
 583 void xbt_automaton_parser_set_extra (YY_EXTRA_TYPE user_defined  );
 584
 585 FILE *xbt_automaton_parser_get_in (void );
 586
 587 void xbt_automaton_parser_set_in  (FILE * _in_str  );
 588
 589 FILE *xbt_automaton_parser_get_out (void );
 590
 591 void xbt_automaton_parser_set_out  (FILE * _out_str  );
 592
 593 yy_size_t xbt_automaton_parser_get_leng (void );
 594
 595 char *xbt_automaton_parser_get_text (void );
 596
 597 int xbt_automaton_parser_get_lineno (void );
 598
 599 void xbt_automaton_parser_set_lineno (int _line_number  );
 600
 601 /* Macros after this point can all be overridden by user definitions in
 602  * section 1.
 603  */
 604
 605 #ifndef YY_SKIP_YYWRAP
 606 #ifdef __cplusplus
 607 extern "C" int xbt_automaton_parser_wrap (void );
 608 #else
 609 extern int xbt_automaton_parser_wrap (void );
 610 #endif
 611 #endif
 612
 613 #ifndef YY_NO_UNPUT
 614
 615     static void yyunput (int c,char *buf_ptr  );
 616
 617 #endif
 618
 619 #ifndef yytext_ptr
 620 static void yy_flex_strncpy (char *,yyconst char *,int );
 621 #endif
 622
 623 #ifdef YY_NEED_STRLEN
 624 static int yy_flex_strlen (yyconst char * );
 625 #endif
 626
 627 #ifndef YY_NO_INPUT
 628
 629 #ifdef __cplusplus
 630 static int yyinput (void );
 631 #else
 632 static int input (void );
 633 #endif
 634
 635 #endif
 636
 637 /* Amount of stuff to slurp up with each read. */
 638 #ifndef YY_READ_BUF_SIZE
 639 #ifdef __ia64__
 640 /* On IA-64, the buffer size is 16k, not 8k */
 641 #define YY_READ_BUF_SIZE 16384
 642 #else
 643 #define YY_READ_BUF_SIZE 8192
 644 #endif /* __ia64__ */
 645 #endif
 646
 647 /* Copy whatever the last rule matched to the standard output. */
 648 #ifndef ECHO
 649 /* This used to be an fputs(), but since the string might contain NUL's,
 650  * we now use fwrite().
 651  */
 652 #define ECHO do { if (fwrite( xbt_automaton_parser_text, xbt_automaton_parser_leng, 1, xbt_automaton_parser_out )) {} } while (0)
 653 #endif
 654
 655 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 656  * is returned in "result".
 657  */
 658 #ifndef YY_INPUT
 659 #define YY_INPUT(buf,result,max_size) \
 660         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 661                 { \
 662                 int c = '*'; \
 663                 size_t n; \
 664                 for ( n = 0; n < max_size && \
 665                              (c = getc( xbt_automaton_parser_in )) != EOF && c != '\n'; ++n ) \
 666                         buf[n] = (char) c; \
 667                 if ( c == '\n' ) \
 668                         buf[n++] = (char) c; \
 669                 if ( c == EOF && ferror( xbt_automaton_parser_in ) ) \
 670                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 671                 result = n; \
 672                 } \
 673         else \
 674                 { \
 675                 errno=0; \
 676                 while ( (result = fread(buf, 1, max_size, xbt_automaton_parser_in))==0 && ferror(xbt_automaton_parser_in)) \
 677                         { \
 678                         if( errno != EINTR) \
 679                                 { \
 680                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 681                                 break; \
 682                                 } \
 683                         errno=0; \
 684                         clearerr(xbt_automaton_parser_in); \
 685                         } \
 686                 }\
 687 \
 688
 689 #endif
 690
 691 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 692  * we don't want an extra ';' after the "return" because that will cause
 693  * some compilers to complain about unreachable statements.
 694  */
 695 #ifndef yyterminate
 696 #define yyterminate() return YY_NULL
 697 #endif
 698
 699 /* Number of entries by which start-condition stack grows. */
 700 #ifndef YY_START_STACK_INCR
 701 #define YY_START_STACK_INCR 25
 702 #endif
 703
 704 /* Report a fatal error. */
 705 #ifndef YY_FATAL_ERROR
 706 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 707 #endif
 708
 709 /* end tables serialization structures and prototypes */
 710
 711 /* Default declaration of generated scanner - a define so the user can
 712  * easily add parameters.
 713  */
 714 #ifndef YY_DECL
 715 #define YY_DECL_IS_OURS 1
 716
 717 extern int xbt_automaton_parser_lex (void);
 718
 719 #define YY_DECL int xbt_automaton_parser_lex (void)
 720 #endif /* !YY_DECL */
 721
 722 /* Code executed at the beginning of each rule, after xbt_automaton_parser_text and xbt_automaton_parser_leng
 723  * have been set up.
 724  */
 725 #ifndef YY_USER_ACTION
 726 #define YY_USER_ACTION
 727 #endif
 728
 729 /* Code executed at the end of each rule. */
 730 #ifndef YY_BREAK
 731 #define YY_BREAK /*LINTED*/break;
 732 #endif
 733
 734 #define YY_RULE_SETUP \
 735         YY_USER_ACTION
 736
 737 /** The main scanner function which does all the work.
 738  */
 739 YY_DECL
 740 {
 741         yy_state_type yy_current_state;
 742         char *yy_cp, *yy_bp;
 743         int yy_act;
 744
 745         if ( !(yy_init) )
 746                 {
 747                 (yy_init) = 1;
 748
 749 #ifdef YY_USER_INIT
 750                 YY_USER_INIT;
 751 #endif
 752
 753                 if ( ! (yy_start) )
 754                         (yy_start) = 1; /* first start state */
 755
 756                 if ( ! xbt_automaton_parser_in )
 757                         xbt_automaton_parser_in = stdin;
 758
 759                 if ( ! xbt_automaton_parser_out )
 760                         xbt_automaton_parser_out = stdout;
 761
 762                 if ( ! YY_CURRENT_BUFFER ) {
 763                         xbt_automaton_parser_ensure_buffer_stack ();
 764                         YY_CURRENT_BUFFER_LVALUE =
 765                                 xbt_automaton_parser__create_buffer(xbt_automaton_parser_in,YY_BUF_SIZE );
 766                 }
 767
 768                 xbt_automaton_parser__load_buffer_state( );
 769                 }
 770
 771         {
 772 #line 45 "parserPromela.lex"
 773
 774
 775 #line 776 "automaton_lexer.yy.c"
 776
 777         while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
 778                 {
 779                 yy_cp = (yy_c_buf_p);
 780
 781                 /* Support of xbt_automaton_parser_text. */
 782                 *yy_cp = (yy_hold_char);
 783
 784                 /* yy_bp points to the position in yy_ch_buf of the start of
 785                  * the current run.
 786                  */
 787                 yy_bp = yy_cp;
 788
 789                 yy_current_state = (yy_start);
 790 yy_match:
 791                 do
 792                         {
 793                         YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
 794                         if ( yy_accept[yy_current_state] )
 795                                 {
 796                                 (yy_last_accepting_state) = yy_current_state;
 797                                 (yy_last_accepting_cpos) = yy_cp;
 798                                 }
 799                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 800                                 {
 801                                 yy_current_state = (int) yy_def[yy_current_state];
 802                                 if ( yy_current_state >= 54 )
 803                                         yy_c = yy_meta[(unsigned int) yy_c];
 804                                 }
 805                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 806                         ++yy_cp;
 807                         }
 808                 while ( yy_base[yy_current_state] != 90 );
 809
 810 yy_find_action:
 811                 yy_act = yy_accept[yy_current_state];
 812                 if ( yy_act == 0 )
 813                         { /* have to back up */
 814                         yy_cp = (yy_last_accepting_cpos);
 815                         yy_current_state = (yy_last_accepting_state);
 816                         yy_act = yy_accept[yy_current_state];
 817                         }
 818
 819                 YY_DO_BEFORE_ACTION;
 820
 821 do_action:      /* This label is used only to access EOF actions. */
 822
 823                 switch ( yy_act )
 824         { /* beginning of action switch */
 825                         case 0: /* must back up */
 826                         /* undo the effects of YY_DO_BEFORE_ACTION */
 827                         *yy_cp = (yy_hold_char);
 828                         yy_cp = (yy_last_accepting_cpos);
 829                         yy_current_state = (yy_last_accepting_state);
 830                         goto yy_find_action;
 831
 832 case 1:
 833 YY_RULE_SETUP
 834 #line 47 "parserPromela.lex"
 835 { return (NEVER); }
 836         YY_BREAK
 837 case 2:
 838 YY_RULE_SETUP
 839 #line 48 "parserPromela.lex"
 840 { return (IF); }
 841         YY_BREAK
 842 case 3:
 843 YY_RULE_SETUP
 844 #line 49 "parserPromela.lex"
 845 { return (FI); }
 846         YY_BREAK
 847 case 4:
 848 YY_RULE_SETUP
 849 #line 50 "parserPromela.lex"
 850 { return (IMPLIES); }
 851         YY_BREAK
 852 case 5:
 853 YY_RULE_SETUP
 854 #line 51 "parserPromela.lex"
 855 { return (GOTO); }
 856         YY_BREAK
 857 case 6:
 858 YY_RULE_SETUP
 859 #line 52 "parserPromela.lex"
 860 { return (AND); }
 861         YY_BREAK
 862 case 7:
 863 YY_RULE_SETUP
 864 #line 53 "parserPromela.lex"
 865 { return (OR); }
 866         YY_BREAK
 867 case 8:
 868 YY_RULE_SETUP
 869 #line 54 "parserPromela.lex"
 870 { return (NOT); }
 871         YY_BREAK
 872 case 9:
 873 YY_RULE_SETUP
 874 #line 55 "parserPromela.lex"
 875 { return (LEFT_PAR); }
 876         YY_BREAK
 877 case 10:
 878 YY_RULE_SETUP
 879 #line 56 "parserPromela.lex"
 880 { return (RIGHT_PAR); }
 881         YY_BREAK
 882 case 11:
 883 YY_RULE_SETUP
 884 #line 57 "parserPromela.lex"
 885 { return (CASE); }
 886         YY_BREAK
 887 case 12:
 888 YY_RULE_SETUP
 889 #line 58 "parserPromela.lex"
 890 { return (COLON); }
 891         YY_BREAK
 892 case 13:
 893 YY_RULE_SETUP
 894 #line 59 "parserPromela.lex"
 895 { return (SEMI_COLON); }
 896         YY_BREAK
 897 case 14:
 898 YY_RULE_SETUP
 899 #line 60 "parserPromela.lex"
 900 { return (CASE_TRUE); }
 901         YY_BREAK
 902 case 15:
 903 YY_RULE_SETUP
 904 #line 61 "parserPromela.lex"
 905 { return (LEFT_BRACE); }
 906         YY_BREAK
 907 case 16:
 908 YY_RULE_SETUP
 909 #line 62 "parserPromela.lex"
 910 { return (RIGHT_BRACE); }
 911         YY_BREAK
 912 case 17:
 913 /* rule 17 can match eol */
 914 YY_RULE_SETUP
 915 #line 65 "parserPromela.lex"
 916 { }
 917         YY_BREAK
 918 case 18:
 919 YY_RULE_SETUP
 920 #line 67 "parserPromela.lex"
 921 { }
 922         YY_BREAK
 923 case 19:
 924 YY_RULE_SETUP
 925 #line 70 "parserPromela.lex"
 926 { sscanf(xbt_automaton_parser_text,"%lf",&yylval.real);
 927                             return (LITT_REEL); }
 928         YY_BREAK
 929 case 20:
 930 YY_RULE_SETUP
 931 #line 73 "parserPromela.lex"
 932 { sscanf(xbt_automaton_parser_text,"%d",&yylval.integer);
 933                             return (LITT_ENT); }
 934         YY_BREAK
 935 case 21:
 936 /* rule 21 can match eol */
 937 YY_RULE_SETUP
 938 #line 76 "parserPromela.lex"
 939 { yylval.string=(char *)malloc(strlen(xbt_automaton_parser_text)+1);
 940                             sscanf(xbt_automaton_parser_text,"%s",yylval.string);
 941                             return (LITT_CHAINE); }
 942         YY_BREAK
 943 case 22:
 944 YY_RULE_SETUP
 945 #line 80 "parserPromela.lex"
 946 { yylval.string=(char *)malloc(strlen(xbt_automaton_parser_text)+1);
 947                             sscanf(xbt_automaton_parser_text,"%s",yylval.string);
 948                                               return (ID); }
 949         YY_BREAK
 950 case 23:
 951 /* rule 23 can match eol */
 952 YY_RULE_SETUP
 953 #line 84 "parserPromela.lex"
 954 { }
 955         YY_BREAK
 956 case 24:
 957 YY_RULE_SETUP
 958 #line 86 "parserPromela.lex"
 959 { }
 960         YY_BREAK
 961 case 25:
 962 YY_RULE_SETUP
 963 #line 88 "parserPromela.lex"
 964 ECHO;
 965         YY_BREAK
 966 #line 967 "automaton_lexer.yy.c"
 967 case YY_STATE_EOF(INITIAL):
 968         yyterminate();
 969
 970         case YY_END_OF_BUFFER:
 971                 {
 972                 /* Amount of text matched not including the EOB char. */
 973                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 974
 975                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 976                 *yy_cp = (yy_hold_char);
 977                 YY_RESTORE_YY_MORE_OFFSET
 978
 979                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 980                         {
 981                         /* We're scanning a new file or input source.  It's
 982                          * possible that this happened because the user
 983                          * just pointed xbt_automaton_parser_in at a new source and called
 984                          * xbt_automaton_parser_lex().  If so, then we have to assure
 985                          * consistency between YY_CURRENT_BUFFER and our
 986                          * globals.  Here is the right place to do so, because
 987                          * this is the first action (other than possibly a
 988                          * back-up) that will match for the new input source.
 989                          */
 990                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 991                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = xbt_automaton_parser_in;
 992                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 993                         }
 994
 995                 /* Note that here we test for yy_c_buf_p "<=" to the position
 996                  * of the first EOB in the buffer, since yy_c_buf_p will
 997                  * already have been incremented past the NUL character
 998                  * (since all states make transitions on EOB to the
 999                  * end-of-buffer state).  Contrast this with the test
1000                  * in input().
1001                  */
1002                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1003                         { /* This was really a NUL. */
1004                         yy_state_type yy_next_state;
1005
1006                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1007
1008                         yy_current_state = yy_get_previous_state(  );
1009
1010                         /* Okay, we're now positioned to make the NUL
1011                          * transition.  We couldn't have
1012                          * yy_get_previous_state() go ahead and do it
1013                          * for us because it doesn't know how to deal
1014                          * with the possibility of jamming (and we don't
1015                          * want to build jamming into it because then it
1016                          * will run more slowly).
1017                          */
1018
1019                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1020
1021                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1022
1023                         if ( yy_next_state )
1024                                 {
1025                                 /* Consume the NUL. */
1026                                 yy_cp = ++(yy_c_buf_p);
1027                                 yy_current_state = yy_next_state;
1028                                 goto yy_match;
1029                                 }
1030
1031                         else
1032                                 {
1033                                 yy_cp = (yy_c_buf_p);
1034                                 goto yy_find_action;
1035                                 }
1036                         }
1037
1038                 else switch ( yy_get_next_buffer(  ) )
1039                         {
1040                         case EOB_ACT_END_OF_FILE:
1041                                 {
1042                                 (yy_did_buffer_switch_on_eof) = 0;
1043
1044                                 if ( xbt_automaton_parser_wrap( ) )
1045                                         {
1046                                         /* Note: because we've taken care in
1047                                          * yy_get_next_buffer() to have set up
1048                                          * xbt_automaton_parser_text, we can now set up
1049                                          * yy_c_buf_p so that if some total
1050                                          * hoser (like flex itself) wants to
1051                                          * call the scanner after we return the
1052                                          * YY_NULL, it'll still work - another
1053                                          * YY_NULL will get returned.
1054                                          */
1055                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1056
1057                                         yy_act = YY_STATE_EOF(YY_START);
1058                                         goto do_action;
1059                                         }
1060
1061                                 else
1062                                         {
1063                                         if ( ! (yy_did_buffer_switch_on_eof) )
1064                                                 YY_NEW_FILE;
1065                                         }
1066                                 break;
1067                                 }
1068
1069                         case EOB_ACT_CONTINUE_SCAN:
1070                                 (yy_c_buf_p) =
1071                                         (yytext_ptr) + yy_amount_of_matched_text;
1072
1073                                 yy_current_state = yy_get_previous_state(  );
1074
1075                                 yy_cp = (yy_c_buf_p);
1076                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1077                                 goto yy_match;
1078
1079                         case EOB_ACT_LAST_MATCH:
1080                                 (yy_c_buf_p) =
1081                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1082
1083                                 yy_current_state = yy_get_previous_state(  );
1084
1085                                 yy_cp = (yy_c_buf_p);
1086                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1087                                 goto yy_find_action;
1088                         }
1089                 break;
1090                 }
1091
1092         default:
1093                 YY_FATAL_ERROR(
1094                         "fatal flex scanner internal error--no action found" );
1095         } /* end of action switch */
1096                 } /* end of scanning one token */
1097         } /* end of user's declarations */
1098 } /* end of xbt_automaton_parser_lex */
1099
1100 /* yy_get_next_buffer - try to read in a new buffer
1101  *
1102  * Returns a code representing an action:
1103  *      EOB_ACT_LAST_MATCH -
1104  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1105  *      EOB_ACT_END_OF_FILE - end of file
1106  */
1107 static int yy_get_next_buffer (void)
1108 {
1109         char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1110         char *source = (yytext_ptr);
1111         yy_size_t number_to_move, i;
1112         int ret_val;
1113
1114         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1115                 YY_FATAL_ERROR(
1116                 "fatal flex scanner internal error--end of buffer missed" );
1117
1118         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1119                 { /* Don't try to fill the buffer, so this is an EOF. */
1120                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1121                         {
1122                         /* We matched a single character, the EOB, so
1123                          * treat this as a final EOF.
1124                          */
1125                         return EOB_ACT_END_OF_FILE;
1126                         }
1127
1128                 else
1129                         {
1130                         /* We matched some text prior to the EOB, first
1131                          * process it.
1132                          */
1133                         return EOB_ACT_LAST_MATCH;
1134                         }
1135                 }
1136
1137         /* Try to read more data. */
1138
1139         /* First move last chars to start of buffer. */
1140         number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1141
1142         for ( i = 0; i < number_to_move; ++i )
1143                 *(dest++) = *(source++);
1144
1145         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1146                 /* don't do the read, it's not guaranteed to return an EOF,
1147                  * just force an EOF
1148                  */
1149                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1150
1151         else
1152                 {
1153                         yy_size_t num_to_read =
1154                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1155
1156                 while ( num_to_read <= 0 )
1157                         { /* Not enough room in the buffer - grow it. */
1158
1159                         /* just a shorter name for the current buffer */
1160                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1161
1162                         int yy_c_buf_p_offset =
1163                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1164
1165                         if ( b->yy_is_our_buffer )
1166                                 {
1167                                 yy_size_t new_size = b->yy_buf_size * 2;
1168
1169                                 if ( new_size <= 0 )
1170                                         b->yy_buf_size += b->yy_buf_size / 8;
1171                                 else
1172                                         b->yy_buf_size *= 2;
1173
1174                                 b->yy_ch_buf = (char *)
1175                                         /* Include room in for 2 EOB chars. */
1176                                         xbt_automaton_parser_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1177                                 }
1178                         else
1179                                 /* Can't grow it, we don't own it. */
1180                                 b->yy_ch_buf = 0;
1181
1182                         if ( ! b->yy_ch_buf )
1183                                 YY_FATAL_ERROR(
1184                                 "fatal error - scanner input buffer overflow" );
1185
1186                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1187
1188                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1189                                                 number_to_move - 1;
1190
1191                         }
1192
1193                 if ( num_to_read > YY_READ_BUF_SIZE )
1194                         num_to_read = YY_READ_BUF_SIZE;
1195
1196                 /* Read in more data. */
1197                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1198                         (yy_n_chars), num_to_read );
1199
1200                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1201                 }
1202
1203         if ( (yy_n_chars) == 0 )
1204                 {
1205                 if ( number_to_move == YY_MORE_ADJ )
1206                         {
1207                         ret_val = EOB_ACT_END_OF_FILE;
1208                         xbt_automaton_parser_restart(xbt_automaton_parser_in  );
1209                         }
1210
1211                 else
1212                         {
1213                         ret_val = EOB_ACT_LAST_MATCH;
1214                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1215                                 YY_BUFFER_EOF_PENDING;
1216                         }
1217                 }
1218
1219         else
1220                 ret_val = EOB_ACT_CONTINUE_SCAN;
1221
1222         if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1223                 /* Extend the array by 50%, plus the number we really need. */
1224                 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1225                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) xbt_automaton_parser_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1226                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1227                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1228         }
1229
1230         (yy_n_chars) += number_to_move;
1231         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1232         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1233
1234         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1235
1236         return ret_val;
1237 }
1238
1239 /* yy_get_previous_state - get the state just before the EOB char was reached */
1240
1241     static yy_state_type yy_get_previous_state (void)
1242 {
1243         yy_state_type yy_current_state;
1244         char *yy_cp;
1245
1246         yy_current_state = (yy_start);
1247
1248         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1249                 {
1250                 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1251                 if ( yy_accept[yy_current_state] )
1252                         {
1253                         (yy_last_accepting_state) = yy_current_state;
1254                         (yy_last_accepting_cpos) = yy_cp;
1255                         }
1256                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1257                         {
1258                         yy_current_state = (int) yy_def[yy_current_state];
1259                         if ( yy_current_state >= 54 )
1260                                 yy_c = yy_meta[(unsigned int) yy_c];
1261                         }
1262                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1263                 }
1264
1265         return yy_current_state;
1266 }
1267
1268 /* yy_try_NUL_trans - try to make a transition on the NUL character
1269  *
1270  * synopsis
1271  *      next_state = yy_try_NUL_trans( current_state );
1272  */
1273     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1274 {
1275         int yy_is_jam;
1276         char *yy_cp = (yy_c_buf_p);
1277
1278         YY_CHAR yy_c = 1;
1279         if ( yy_accept[yy_current_state] )
1280                 {
1281                 (yy_last_accepting_state) = yy_current_state;
1282                 (yy_last_accepting_cpos) = yy_cp;
1283                 }
1284         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1285                 {
1286                 yy_current_state = (int) yy_def[yy_current_state];
1287                 if ( yy_current_state >= 54 )
1288                         yy_c = yy_meta[(unsigned int) yy_c];
1289                 }
1290         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1291         yy_is_jam = (yy_current_state == 53);
1292
1293                 return yy_is_jam ? 0 : yy_current_state;
1294 }
1295
1296 #ifndef YY_NO_UNPUT
1297
1298     static void yyunput (int c, char * yy_bp )
1299 {
1300         char *yy_cp;
1301
1302     yy_cp = (yy_c_buf_p);
1303
1304         /* undo effects of setting up xbt_automaton_parser_text */
1305         *yy_cp = (yy_hold_char);
1306
1307         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1308                 { /* need to shift things up to make room */
1309                 /* +2 for EOB chars. */
1310                 yy_size_t number_to_move = (yy_n_chars) + 2;
1311                 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1312                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1313                 char *source =
1314                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1315
1316                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1317                         *--dest = *--source;
1318
1319                 yy_cp += (int) (dest - source);
1320                 yy_bp += (int) (dest - source);
1321                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1322                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1323
1324                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1325                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1326                 }
1327
1328         *--yy_cp = (char) c;
1329
1330         (yytext_ptr) = yy_bp;
1331         (yy_hold_char) = *yy_cp;
1332         (yy_c_buf_p) = yy_cp;
1333 }
1334
1335 #endif
1336
1337 #ifndef YY_NO_INPUT
1338 #ifdef __cplusplus
1339     static int yyinput (void)
1340 #else
1341     static int input  (void)
1342 #endif
1343
1344 {
1345         int c;
1346
1347         *(yy_c_buf_p) = (yy_hold_char);
1348
1349         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1350                 {
1351                 /* yy_c_buf_p now points to the character we want to return.
1352                  * If this occurs *before* the EOB characters, then it's a
1353                  * valid NUL; if not, then we've hit the end of the buffer.
1354                  */
1355                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1356                         /* This was really a NUL. */
1357                         *(yy_c_buf_p) = '\0';
1358
1359                 else
1360                         { /* need more input */
1361                         yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1362                         ++(yy_c_buf_p);
1363
1364                         switch ( yy_get_next_buffer(  ) )
1365                                 {
1366                                 case EOB_ACT_LAST_MATCH:
1367                                         /* This happens because yy_g_n_b()
1368                                          * sees that we've accumulated a
1369                                          * token and flags that we need to
1370                                          * try matching the token before
1371                                          * proceeding.  But for input(),
1372                                          * there's no matching to consider.
1373                                          * So convert the EOB_ACT_LAST_MATCH
1374                                          * to EOB_ACT_END_OF_FILE.
1375                                          */
1376
1377                                         /* Reset buffer status. */
1378                                         xbt_automaton_parser_restart(xbt_automaton_parser_in );
1379
1380                                         /*FALLTHROUGH*/
1381
1382                                 case EOB_ACT_END_OF_FILE:
1383                                         {
1384                                         if ( xbt_automaton_parser_wrap( ) )
1385                                                 return EOF;
1386
1387                                         if ( ! (yy_did_buffer_switch_on_eof) )
1388                                                 YY_NEW_FILE;
1389 #ifdef __cplusplus
1390                                         return yyinput();
1391 #else
1392                                         return input();
1393 #endif
1394                                         }
1395
1396                                 case EOB_ACT_CONTINUE_SCAN:
1397                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1398                                         break;
1399                                 }
1400                         }
1401                 }
1402
1403         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1404         *(yy_c_buf_p) = '\0';   /* preserve xbt_automaton_parser_text */
1405         (yy_hold_char) = *++(yy_c_buf_p);
1406
1407         return c;
1408 }
1409 #endif  /* ifndef YY_NO_INPUT */
1410
1411 /** Immediately switch to a different input stream.
1412  * @param input_file A readable stream.
1413  *
1414  * @note This function does not reset the start condition to @c INITIAL .
1415  */
1416     void xbt_automaton_parser_restart  (FILE * input_file )
1417 {
1418
1419         if ( ! YY_CURRENT_BUFFER ){
1420         xbt_automaton_parser_ensure_buffer_stack ();
1421                 YY_CURRENT_BUFFER_LVALUE =
1422             xbt_automaton_parser__create_buffer(xbt_automaton_parser_in,YY_BUF_SIZE );
1423         }
1424
1425         xbt_automaton_parser__init_buffer(YY_CURRENT_BUFFER,input_file );
1426         xbt_automaton_parser__load_buffer_state( );
1427 }
1428
1429 /** Switch to a different input buffer.
1430  * @param new_buffer The new input buffer.
1431  *
1432  */
1433     void xbt_automaton_parser__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1434 {
1435
1436         /* TODO. We should be able to replace this entire function body
1437          * with
1438          *              xbt_automaton_parser_pop_buffer_state();
1439          *              xbt_automaton_parser_push_buffer_state(new_buffer);
1440      */
1441         xbt_automaton_parser_ensure_buffer_stack ();
1442         if ( YY_CURRENT_BUFFER == new_buffer )
1443                 return;
1444
1445         if ( YY_CURRENT_BUFFER )
1446                 {
1447                 /* Flush out information for old buffer. */
1448                 *(yy_c_buf_p) = (yy_hold_char);
1449                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1450                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1451                 }
1452
1453         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1454         xbt_automaton_parser__load_buffer_state( );
1455
1456         /* We don't actually know whether we did this switch during
1457          * EOF (xbt_automaton_parser_wrap()) processing, but the only time this flag
1458          * is looked at is after xbt_automaton_parser_wrap() is called, so it's safe
1459          * to go ahead and always set it.
1460          */
1461         (yy_did_buffer_switch_on_eof) = 1;
1462 }
1463
1464 static void xbt_automaton_parser__load_buffer_state  (void)
1465 {
1466         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1467         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1468         xbt_automaton_parser_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1469         (yy_hold_char) = *(yy_c_buf_p);
1470 }
1471
1472 /** Allocate and initialize an input buffer state.
1473  * @param file A readable stream.
1474  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1475  *
1476  * @return the allocated buffer state.
1477  */
1478     YY_BUFFER_STATE xbt_automaton_parser__create_buffer  (FILE * file, int  size )
1479 {
1480         YY_BUFFER_STATE b;
1481
1482         b = (YY_BUFFER_STATE) xbt_automaton_parser_alloc(sizeof( struct yy_buffer_state )  );
1483         if ( ! b )
1484                 YY_FATAL_ERROR( "out of dynamic memory in xbt_automaton_parser__create_buffer()" );
1485
1486         b->yy_buf_size = (yy_size_t)size;
1487
1488         /* yy_ch_buf has to be 2 characters longer than the size given because
1489          * we need to put in 2 end-of-buffer characters.
1490          */
1491         b->yy_ch_buf = (char *) xbt_automaton_parser_alloc(b->yy_buf_size + 2  );
1492         if ( ! b->yy_ch_buf )
1493                 YY_FATAL_ERROR( "out of dynamic memory in xbt_automaton_parser__create_buffer()" );
1494
1495         b->yy_is_our_buffer = 1;
1496
1497         xbt_automaton_parser__init_buffer(b,file );
1498
1499         return b;
1500 }
1501
1502 /** Destroy the buffer.
1503  * @param b a buffer created with xbt_automaton_parser__create_buffer()
1504  *
1505  */
1506     void xbt_automaton_parser__delete_buffer (YY_BUFFER_STATE  b )
1507 {
1508
1509         if ( ! b )
1510                 return;
1511
1512         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1513                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1514
1515         if ( b->yy_is_our_buffer )
1516                 xbt_automaton_parser_free((void *) b->yy_ch_buf  );
1517
1518         xbt_automaton_parser_free((void *) b  );
1519 }
1520
1521 /* Initializes or reinitializes a buffer.
1522  * This function is sometimes called more than once on the same buffer,
1523  * such as during a xbt_automaton_parser_restart() or at EOF.
1524  */
1525     static void xbt_automaton_parser__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1526
1527 {
1528         int oerrno = errno;
1529
1530         xbt_automaton_parser__flush_buffer(b );
1531
1532         b->yy_input_file = file;
1533         b->yy_fill_buffer = 1;
1534
1535     /* If b is the current buffer, then xbt_automaton_parser__init_buffer was _probably_
1536      * called from xbt_automaton_parser_restart() or through yy_get_next_buffer.
1537      * In that case, we don't want to reset the lineno or column.
1538      */
1539     if (b != YY_CURRENT_BUFFER){
1540         b->yy_bs_lineno = 1;
1541         b->yy_bs_column = 0;
1542     }
1543
1544         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1545
1546         errno = oerrno;
1547 }
1548
1549 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1550  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1551  *
1552  */
1553     void xbt_automaton_parser__flush_buffer (YY_BUFFER_STATE  b )
1554 {
1555         if ( ! b )
1556                 return;
1557
1558         b->yy_n_chars = 0;
1559
1560         /* We always need two end-of-buffer characters.  The first causes
1561          * a transition to the end-of-buffer state.  The second causes
1562          * a jam in that state.
1563          */
1564         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1565         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1566
1567         b->yy_buf_pos = &b->yy_ch_buf[0];
1568
1569         b->yy_at_bol = 1;
1570         b->yy_buffer_status = YY_BUFFER_NEW;
1571
1572         if ( b == YY_CURRENT_BUFFER )
1573                 xbt_automaton_parser__load_buffer_state( );
1574 }
1575
1576 /** Pushes the new state onto the stack. The new state becomes
1577  *  the current state. This function will allocate the stack
1578  *  if necessary.
1579  *  @param new_buffer The new state.
1580  *
1581  */
1582 void xbt_automaton_parser_push_buffer_state (YY_BUFFER_STATE new_buffer )
1583 {
1584         if (new_buffer == NULL)
1585                 return;
1586
1587         xbt_automaton_parser_ensure_buffer_stack();
1588
1589         /* This block is copied from xbt_automaton_parser__switch_to_buffer. */
1590         if ( YY_CURRENT_BUFFER )
1591                 {
1592                 /* Flush out information for old buffer. */
1593                 *(yy_c_buf_p) = (yy_hold_char);
1594                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1595                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1596                 }
1597
1598         /* Only push if top exists. Otherwise, replace top. */
1599         if (YY_CURRENT_BUFFER)
1600                 (yy_buffer_stack_top)++;
1601         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1602
1603         /* copied from xbt_automaton_parser__switch_to_buffer. */
1604         xbt_automaton_parser__load_buffer_state( );
1605         (yy_did_buffer_switch_on_eof) = 1;
1606 }
1607
1608 /** Removes and deletes the top of the stack, if present.
1609  *  The next element becomes the new top.
1610  *
1611  */
1612 void xbt_automaton_parser_pop_buffer_state (void)
1613 {
1614         if (!YY_CURRENT_BUFFER)
1615                 return;
1616
1617         xbt_automaton_parser__delete_buffer(YY_CURRENT_BUFFER );
1618         YY_CURRENT_BUFFER_LVALUE = NULL;
1619         if ((yy_buffer_stack_top) > 0)
1620                 --(yy_buffer_stack_top);
1621
1622         if (YY_CURRENT_BUFFER) {
1623                 xbt_automaton_parser__load_buffer_state( );
1624                 (yy_did_buffer_switch_on_eof) = 1;
1625         }
1626 }
1627
1628 /* Allocates the stack if it does not exist.
1629  *  Guarantees space for at least one push.
1630  */
1631 static void xbt_automaton_parser_ensure_buffer_stack (void)
1632 {
1633         yy_size_t num_to_alloc;
1634
1635         if (!(yy_buffer_stack)) {
1636
1637                 /* First allocation is just for 2 elements, since we don't know if this
1638                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1639                  * immediate realloc on the next call.
1640          */
1641                 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1642                 (yy_buffer_stack) = (struct yy_buffer_state**)xbt_automaton_parser_alloc
1643                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1644                                                                 );
1645                 if ( ! (yy_buffer_stack) )
1646                         YY_FATAL_ERROR( "out of dynamic memory in xbt_automaton_parser_ensure_buffer_stack()" );
1647
1648                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1649
1650                 (yy_buffer_stack_max) = num_to_alloc;
1651                 (yy_buffer_stack_top) = 0;
1652                 return;
1653         }
1654
1655         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1656
1657                 /* Increase the buffer to prepare for a possible push. */
1658                 yy_size_t grow_size = 8 /* arbitrary grow size */;
1659
1660                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1661                 (yy_buffer_stack) = (struct yy_buffer_state**)xbt_automaton_parser_realloc
1662                                                                 ((yy_buffer_stack),
1663                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1664                                                                 );
1665                 if ( ! (yy_buffer_stack) )
1666                         YY_FATAL_ERROR( "out of dynamic memory in xbt_automaton_parser_ensure_buffer_stack()" );
1667
1668                 /* zero only the new slots.*/
1669                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1670                 (yy_buffer_stack_max) = num_to_alloc;
1671         }
1672 }
1673
1674 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1675  * @param base the character buffer
1676  * @param size the size in bytes of the character buffer
1677  *
1678  * @return the newly allocated buffer state object.
1679  */
1680 YY_BUFFER_STATE xbt_automaton_parser__scan_buffer  (char * base, yy_size_t  size )
1681 {
1682         YY_BUFFER_STATE b;
1683
1684         if ( size < 2 ||
1685              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1686              base[size-1] != YY_END_OF_BUFFER_CHAR )
1687                 /* They forgot to leave room for the EOB's. */
1688                 return 0;
1689
1690         b = (YY_BUFFER_STATE) xbt_automaton_parser_alloc(sizeof( struct yy_buffer_state )  );
1691         if ( ! b )
1692                 YY_FATAL_ERROR( "out of dynamic memory in xbt_automaton_parser__scan_buffer()" );
1693
1694         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1695         b->yy_buf_pos = b->yy_ch_buf = base;
1696         b->yy_is_our_buffer = 0;
1697         b->yy_input_file = 0;
1698         b->yy_n_chars = b->yy_buf_size;
1699         b->yy_is_interactive = 0;
1700         b->yy_at_bol = 1;
1701         b->yy_fill_buffer = 0;
1702         b->yy_buffer_status = YY_BUFFER_NEW;
1703
1704         xbt_automaton_parser__switch_to_buffer(b  );
1705
1706         return b;
1707 }
1708
1709 /** Setup the input buffer state to scan a string. The next call to xbt_automaton_parser_lex() will
1710  * scan from a @e copy of @a str.
1711  * @param yystr a NUL-terminated string to scan
1712  *
1713  * @return the newly allocated buffer state object.
1714  * @note If you want to scan bytes that may contain NUL values, then use
1715  *       xbt_automaton_parser__scan_bytes() instead.
1716  */
1717 YY_BUFFER_STATE xbt_automaton_parser__scan_string (yyconst char * yystr )
1718 {
1719
1720         return xbt_automaton_parser__scan_bytes(yystr,strlen(yystr) );
1721 }
1722
1723 /** Setup the input buffer state to scan the given bytes. The next call to xbt_automaton_parser_lex() will
1724  * scan from a @e copy of @a bytes.
1725  * @param yybytes the byte buffer to scan
1726  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1727  *
1728  * @return the newly allocated buffer state object.
1729  */
1730 YY_BUFFER_STATE xbt_automaton_parser__scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
1731 {
1732         YY_BUFFER_STATE b;
1733         char *buf;
1734         yy_size_t n;
1735         yy_size_t i;
1736
1737         /* Get memory for full buffer, including space for trailing EOB's. */
1738         n = _yybytes_len + 2;
1739         buf = (char *) xbt_automaton_parser_alloc(n  );
1740         if ( ! buf )
1741                 YY_FATAL_ERROR( "out of dynamic memory in xbt_automaton_parser__scan_bytes()" );
1742
1743         for ( i = 0; i < _yybytes_len; ++i )
1744                 buf[i] = yybytes[i];
1745
1746         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1747
1748         b = xbt_automaton_parser__scan_buffer(buf,n );
1749         if ( ! b )
1750                 YY_FATAL_ERROR( "bad buffer in xbt_automaton_parser__scan_bytes()" );
1751
1752         /* It's okay to grow etc. this buffer, and we should throw it
1753          * away when we're done.
1754          */
1755         b->yy_is_our_buffer = 1;
1756
1757         return b;
1758 }
1759
1760 #ifndef YY_EXIT_FAILURE
1761 #define YY_EXIT_FAILURE 2
1762 #endif
1763
1764 static void yy_fatal_error (yyconst char* msg )
1765 {
1766                         (void) fprintf( stderr, "%s\n", msg );
1767         exit( YY_EXIT_FAILURE );
1768 }
1769
1770 /* Redefine yyless() so it works in section 3 code. */
1771
1772 #undef yyless
1773 #define yyless(n) \
1774         do \
1775                 { \
1776                 /* Undo effects of setting up xbt_automaton_parser_text. */ \
1777         int yyless_macro_arg = (n); \
1778         YY_LESS_LINENO(yyless_macro_arg);\
1779                 xbt_automaton_parser_text[xbt_automaton_parser_leng] = (yy_hold_char); \
1780                 (yy_c_buf_p) = xbt_automaton_parser_text + yyless_macro_arg; \
1781                 (yy_hold_char) = *(yy_c_buf_p); \
1782                 *(yy_c_buf_p) = '\0'; \
1783                 xbt_automaton_parser_leng = yyless_macro_arg; \
1784                 } \
1785         while ( 0 )
1786
1787 /* Accessor  methods (get/set functions) to struct members. */
1788
1789 /** Get the current line number.
1790  *
1791  */
1792 int xbt_automaton_parser_get_lineno  (void)
1793 {
1794
1795     return xbt_automaton_parser_lineno;
1796 }
1797
1798 /** Get the input stream.
1799  *
1800  */
1801 FILE *xbt_automaton_parser_get_in  (void)
1802 {
1803         return xbt_automaton_parser_in;
1804 }
1805
1806 /** Get the output stream.
1807  *
1808  */
1809 FILE *xbt_automaton_parser_get_out  (void)
1810 {
1811         return xbt_automaton_parser_out;
1812 }
1813
1814 /** Get the length of the current token.
1815  *
1816  */
1817 yy_size_t xbt_automaton_parser_get_leng  (void)
1818 {
1819         return xbt_automaton_parser_leng;
1820 }
1821
1822 /** Get the current token.
1823  *
1824  */
1825
1826 char *xbt_automaton_parser_get_text  (void)
1827 {
1828         return xbt_automaton_parser_text;
1829 }
1830
1831 /** Set the current line number.
1832  * @param _line_number line number
1833  *
1834  */
1835 void xbt_automaton_parser_set_lineno (int  _line_number )
1836 {
1837
1838     xbt_automaton_parser_lineno = _line_number;
1839 }
1840
1841 /** Set the input stream. This does not discard the current
1842  * input buffer.
1843  * @param _in_str A readable stream.
1844  *
1845  * @see xbt_automaton_parser__switch_to_buffer
1846  */
1847 void xbt_automaton_parser_set_in (FILE *  _in_str )
1848 {
1849         xbt_automaton_parser_in = _in_str ;
1850 }
1851
1852 void xbt_automaton_parser_set_out (FILE *  _out_str )
1853 {
1854         xbt_automaton_parser_out = _out_str ;
1855 }
1856
1857 int xbt_automaton_parser_get_debug  (void)
1858 {
1859         return xbt_automaton_parser__flex_debug;
1860 }
1861
1862 void xbt_automaton_parser_set_debug (int  _bdebug )
1863 {
1864         xbt_automaton_parser__flex_debug = _bdebug ;
1865 }
1866
1867 static int yy_init_globals (void)
1868 {
1869         /* Initialization is the same as for the non-reentrant scanner.
1870      * This function is called from xbt_automaton_parser_lex_destroy(), so don't allocate here.
1871      */
1872
1873     (yy_buffer_stack) = 0;
1874     (yy_buffer_stack_top) = 0;
1875     (yy_buffer_stack_max) = 0;
1876     (yy_c_buf_p) = (char *) 0;
1877     (yy_init) = 0;
1878     (yy_start) = 0;
1879
1880 /* Defined in main.c */
1881 #ifdef YY_STDINIT
1882     xbt_automaton_parser_in = stdin;
1883     xbt_automaton_parser_out = stdout;
1884 #else
1885     xbt_automaton_parser_in = (FILE *) 0;
1886     xbt_automaton_parser_out = (FILE *) 0;
1887 #endif
1888
1889     /* For future reference: Set errno on error, since we are called by
1890      * xbt_automaton_parser_lex_init()
1891      */
1892     return 0;
1893 }
1894
1895 /* xbt_automaton_parser_lex_destroy is for both reentrant and non-reentrant scanners. */
1896 int xbt_automaton_parser_lex_destroy  (void)
1897 {
1898
1899     /* Pop the buffer stack, destroying each element. */
1900         while(YY_CURRENT_BUFFER){
1901                 xbt_automaton_parser__delete_buffer(YY_CURRENT_BUFFER  );
1902                 YY_CURRENT_BUFFER_LVALUE = NULL;
1903                 xbt_automaton_parser_pop_buffer_state();
1904         }
1905
1906         /* Destroy the stack itself. */
1907         xbt_automaton_parser_free((yy_buffer_stack) );
1908         (yy_buffer_stack) = NULL;
1909
1910     /* Reset the globals. This is important in a non-reentrant scanner so the next time
1911      * xbt_automaton_parser_lex() is called, initialization will occur. */
1912     yy_init_globals( );
1913
1914     return 0;
1915 }
1916
1917 /*
1918  * Internal utility routines.
1919  */
1920
1921 #ifndef yytext_ptr
1922 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1923 {
1924
1925         int i;
1926         for ( i = 0; i < n; ++i )
1927                 s1[i] = s2[i];
1928 }
1929 #endif
1930
1931 #ifdef YY_NEED_STRLEN
1932 static int yy_flex_strlen (yyconst char * s )
1933 {
1934         int n;
1935         for ( n = 0; s[n]; ++n )
1936                 ;
1937
1938         return n;
1939 }
1940 #endif
1941
1942 void *xbt_automaton_parser_alloc (yy_size_t  size )
1943 {
1944                         return (void *) malloc( size );
1945 }
1946
1947 void *xbt_automaton_parser_realloc  (void * ptr, yy_size_t  size )
1948 {
1949
1950         /* The cast to (char *) in the following accommodates both
1951          * implementations that use char* generic pointers, and those
1952          * that use void* generic pointers.  It works with the latter
1953          * because both ANSI C and C++ allow castless assignment from
1954          * any pointer type to void*, and deal with argument conversions
1955          * as though doing an assignment.
1956          */
1957         return (void *) realloc( (char *) ptr, size );
1958 }
1959
1960 void xbt_automaton_parser_free (void * ptr )
1961 {
1962                         free( (char *) ptr );   /* see xbt_automaton_parser_realloc() for (char *) cast */
1963 }
1964
1965 #define YYTABLES_NAME "yytables"
1966
1967 #line 88 "parserPromela.lex"
1968
1969
1970
1971
1972