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