1 #line 2 "automaton_lexer.yy.c"
3 #line 4 "automaton_lexer.yy.c"
5 #define YY_INT_ALIGNED short int
7 /* A lexical scanner generated by flex */
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
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
42 #ifdef yy_create_buffer
43 #define xbt_automaton_parser__create_buffer_ALREADY_DEFINED
45 #define yy_create_buffer xbt_automaton_parser__create_buffer
48 #ifdef yy_delete_buffer
49 #define xbt_automaton_parser__delete_buffer_ALREADY_DEFINED
51 #define yy_delete_buffer xbt_automaton_parser__delete_buffer
55 #define xbt_automaton_parser__scan_buffer_ALREADY_DEFINED
57 #define yy_scan_buffer xbt_automaton_parser__scan_buffer
61 #define xbt_automaton_parser__scan_string_ALREADY_DEFINED
63 #define yy_scan_string xbt_automaton_parser__scan_string
67 #define xbt_automaton_parser__scan_bytes_ALREADY_DEFINED
69 #define yy_scan_bytes xbt_automaton_parser__scan_bytes
73 #define xbt_automaton_parser__init_buffer_ALREADY_DEFINED
75 #define yy_init_buffer xbt_automaton_parser__init_buffer
78 #ifdef yy_flush_buffer
79 #define xbt_automaton_parser__flush_buffer_ALREADY_DEFINED
81 #define yy_flush_buffer xbt_automaton_parser__flush_buffer
84 #ifdef yy_load_buffer_state
85 #define xbt_automaton_parser__load_buffer_state_ALREADY_DEFINED
87 #define yy_load_buffer_state xbt_automaton_parser__load_buffer_state
90 #ifdef yy_switch_to_buffer
91 #define xbt_automaton_parser__switch_to_buffer_ALREADY_DEFINED
93 #define yy_switch_to_buffer xbt_automaton_parser__switch_to_buffer
96 #ifdef yypush_buffer_state
97 #define xbt_automaton_parser_push_buffer_state_ALREADY_DEFINED
99 #define yypush_buffer_state xbt_automaton_parser_push_buffer_state
102 #ifdef yypop_buffer_state
103 #define xbt_automaton_parser_pop_buffer_state_ALREADY_DEFINED
105 #define yypop_buffer_state xbt_automaton_parser_pop_buffer_state
108 #ifdef yyensure_buffer_stack
109 #define xbt_automaton_parser_ensure_buffer_stack_ALREADY_DEFINED
111 #define yyensure_buffer_stack xbt_automaton_parser_ensure_buffer_stack
115 #define xbt_automaton_parser_lex_ALREADY_DEFINED
117 #define yylex xbt_automaton_parser_lex
121 #define xbt_automaton_parser_restart_ALREADY_DEFINED
123 #define yyrestart xbt_automaton_parser_restart
127 #define xbt_automaton_parser_lex_init_ALREADY_DEFINED
129 #define yylex_init xbt_automaton_parser_lex_init
132 #ifdef yylex_init_extra
133 #define xbt_automaton_parser_lex_init_extra_ALREADY_DEFINED
135 #define yylex_init_extra xbt_automaton_parser_lex_init_extra
139 #define xbt_automaton_parser_lex_destroy_ALREADY_DEFINED
141 #define yylex_destroy xbt_automaton_parser_lex_destroy
145 #define xbt_automaton_parser_get_debug_ALREADY_DEFINED
147 #define yyget_debug xbt_automaton_parser_get_debug
151 #define xbt_automaton_parser_set_debug_ALREADY_DEFINED
153 #define yyset_debug xbt_automaton_parser_set_debug
157 #define xbt_automaton_parser_get_extra_ALREADY_DEFINED
159 #define yyget_extra xbt_automaton_parser_get_extra
163 #define xbt_automaton_parser_set_extra_ALREADY_DEFINED
165 #define yyset_extra xbt_automaton_parser_set_extra
169 #define xbt_automaton_parser_get_in_ALREADY_DEFINED
171 #define yyget_in xbt_automaton_parser_get_in
175 #define xbt_automaton_parser_set_in_ALREADY_DEFINED
177 #define yyset_in xbt_automaton_parser_set_in
181 #define xbt_automaton_parser_get_out_ALREADY_DEFINED
183 #define yyget_out xbt_automaton_parser_get_out
187 #define xbt_automaton_parser_set_out_ALREADY_DEFINED
189 #define yyset_out xbt_automaton_parser_set_out
193 #define xbt_automaton_parser_get_leng_ALREADY_DEFINED
195 #define yyget_leng xbt_automaton_parser_get_leng
199 #define xbt_automaton_parser_get_text_ALREADY_DEFINED
201 #define yyget_text xbt_automaton_parser_get_text
205 #define xbt_automaton_parser_get_lineno_ALREADY_DEFINED
207 #define yyget_lineno xbt_automaton_parser_get_lineno
211 #define xbt_automaton_parser_set_lineno_ALREADY_DEFINED
213 #define yyset_lineno xbt_automaton_parser_set_lineno
217 #define xbt_automaton_parser_wrap_ALREADY_DEFINED
219 #define yywrap xbt_automaton_parser_wrap
223 #define xbt_automaton_parser_alloc_ALREADY_DEFINED
225 #define yyalloc xbt_automaton_parser_alloc
229 #define xbt_automaton_parser_realloc_ALREADY_DEFINED
231 #define yyrealloc xbt_automaton_parser_realloc
235 #define xbt_automaton_parser_free_ALREADY_DEFINED
237 #define yyfree xbt_automaton_parser_free
241 #define xbt_automaton_parser_text_ALREADY_DEFINED
243 #define yytext xbt_automaton_parser_text
247 #define xbt_automaton_parser_leng_ALREADY_DEFINED
249 #define yyleng xbt_automaton_parser_leng
253 #define xbt_automaton_parser_in_ALREADY_DEFINED
255 #define yyin xbt_automaton_parser_in
259 #define xbt_automaton_parser_out_ALREADY_DEFINED
261 #define yyout xbt_automaton_parser_out
265 #define xbt_automaton_parser__flex_debug_ALREADY_DEFINED
267 #define yy_flex_debug xbt_automaton_parser__flex_debug
271 #define xbt_automaton_parser_lineno_ALREADY_DEFINED
273 #define yylineno xbt_automaton_parser_lineno
276 /* First, we deal with platform-specific or compiler-specific issues. */
278 /* begin standard C headers. */
284 /* end standard C headers. */
286 /* flex integer type definitions */
291 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
293 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
295 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
296 * if you want the limit (max/min) macros for int types.
298 #ifndef __STDC_LIMIT_MACROS
299 #define __STDC_LIMIT_MACROS 1
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;
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;
317 /* Limits of integral types. */
319 #define INT8_MIN (-128)
322 #define INT16_MIN (-32767-1)
325 #define INT32_MIN (-2147483647-1)
328 #define INT8_MAX (127)
331 #define INT16_MAX (32767)
334 #define INT32_MAX (2147483647)
337 #define UINT8_MAX (255U)
340 #define UINT16_MAX (65535U)
343 #define UINT32_MAX (4294967295U)
347 #define SIZE_MAX (~(size_t)0)
352 #endif /* ! FLEXINT_H */
354 /* begin standard C++ headers. */
356 /* TODO: this is always defined, so inline it */
357 #define yyconst const
359 #if defined(__GNUC__) && __GNUC__ >= 3
360 #define yynoreturn __attribute__((__noreturn__))
365 /* Returned upon end-of-file. */
368 /* Promotes a possibly negative, possibly signed char to an
369 * integer in range [0..255] for use as an array index.
371 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
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.
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
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
390 /* Size of default input buffer. */
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.
397 #define YY_BUF_SIZE 32768
399 #define YY_BUF_SIZE 16384
400 #endif /* __ia64__ */
403 /* The state buf must be large enough to hold one state per character in the main buffer.
405 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
407 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
408 #define YY_TYPEDEF_YY_BUFFER_STATE
409 typedef struct yy_buffer_state *YY_BUFFER_STATE;
412 #ifndef YY_TYPEDEF_YY_SIZE_T
413 #define YY_TYPEDEF_YY_SIZE_T
414 typedef size_t yy_size_t;
419 extern FILE *yyin, *yyout;
421 #define EOB_ACT_CONTINUE_SCAN 0
422 #define EOB_ACT_END_OF_FILE 1
423 #define EOB_ACT_LAST_MATCH 2
425 #define YY_LESS_LINENO(n)
426 #define YY_LINENO_REWIND_TO(ptr)
428 /* Return all but the first "n" matched characters back to the input stream. */
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 */ \
441 #define unput(c) yyunput( c, (yytext_ptr) )
443 #ifndef YY_STRUCT_YY_BUFFER_STATE
444 #define YY_STRUCT_YY_BUFFER_STATE
445 struct yy_buffer_state
449 char *yy_ch_buf; /* input buffer */
450 char *yy_buf_pos; /* current position in input buffer */
452 /* Size of input buffer in bytes, not including room for EOB
457 /* Number of characters read into yy_ch_buf, not including EOB
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
466 int yy_is_our_buffer;
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
473 int yy_is_interactive;
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
481 int yy_bs_lineno; /**< The line count. */
482 int yy_bs_column; /**< The column count. */
484 /* Whether to try to fill the input buffer when we reach the
489 int yy_buffer_status;
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.
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.
503 #define YY_BUFFER_EOF_PENDING 2
506 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
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. */
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
517 * Returns the top of the stack, or NULL.
519 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
520 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
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.
525 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
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 */
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 */
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 ...
540 static int yy_did_buffer_switch_on_eof;
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 );
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 )
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 );
559 void *yyalloc ( yy_size_t );
560 void *yyrealloc ( void *, yy_size_t );
561 void yyfree ( void * );
563 #define yy_new_buffer yy_create_buffer
564 #define yy_set_interactive(is_interactive) \
566 if ( ! YY_CURRENT_BUFFER ){ \
567 yyensure_buffer_stack (); \
568 YY_CURRENT_BUFFER_LVALUE = \
569 yy_create_buffer( yyin, YY_BUF_SIZE ); \
571 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
573 #define yy_set_bol(at_bol) \
575 if ( ! YY_CURRENT_BUFFER ){\
576 yyensure_buffer_stack (); \
577 YY_CURRENT_BUFFER_LVALUE = \
578 yy_create_buffer( yyin, YY_BUF_SIZE ); \
580 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
582 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
584 /* Begin user sect3 */
586 #define xbt_automaton_parser_wrap() (/*CONSTCOND*/1)
587 #define YY_SKIP_YYWRAP
588 typedef flex_uint8_t YY_CHAR;
590 FILE *yyin = NULL, *yyout = NULL;
592 typedef int yy_state_type;
601 #define yytext_ptr yytext
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 );
608 /* Done after the current pattern has been matched and before the
609 * corresponding action - sets up yytext.
611 #define YY_DO_BEFORE_ACTION \
612 (yytext_ptr) = yy_bp; \
613 yyleng = (int) (yy_cp - yy_bp); \
614 (yy_hold_char) = *yy_cp; \
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. */
623 flex_int32_t yy_verify;
626 static const flex_int16_t yy_accept[54] =
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,
636 static const YY_CHAR yy_ec[256] =
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,
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,
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,
668 static const YY_CHAR yy_meta[34] =
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,
676 static const flex_int16_t yy_base[57] =
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
686 static const flex_int16_t yy_def[57] =
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
696 static const flex_int16_t yy_nxt[124] =
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,
709 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
710 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
714 static const flex_int16_t yy_chk[124] =
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,
727 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
728 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
732 static yy_state_type yy_last_accepting_state;
733 static char *yy_last_accepting_cpos;
735 extern int yy_flex_debug;
736 int yy_flex_debug = 0;
738 /* The intent behind this definition is that it'll catch
739 * any uses of REJECT which flex missed.
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
746 #line 1 "parserPromela.lex"
747 /* Copyright (c) 2012-2022. 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"
753 #include "simgrid/config.h"
755 #define YY_NO_UNISTD_H /* hello Windows */
759 #include "parserPromela.tab.hacc"
761 extern YYSTYPE yylval;
763 #line 764 "automaton_lexer.yy.c"
764 #line 765 "automaton_lexer.yy.c"
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.
776 #ifndef YY_EXTRA_TYPE
777 #define YY_EXTRA_TYPE void *
780 static int yy_init_globals ( void );
782 /* Accessor methods to globals.
783 These are made visible to non-reentrant scanners for convenience. */
785 int yylex_destroy ( void );
787 int yyget_debug ( void );
789 void yyset_debug ( int debug_flag );
791 YY_EXTRA_TYPE yyget_extra ( void );
793 void yyset_extra ( YY_EXTRA_TYPE user_defined );
795 FILE *yyget_in ( void );
797 void yyset_in ( FILE * _in_str );
799 FILE *yyget_out ( void );
801 void yyset_out ( FILE * _out_str );
803 int yyget_leng ( void );
805 char *yyget_text ( void );
807 int yyget_lineno ( void );
809 void yyset_lineno ( int _line_number );
811 /* Macros after this point can all be overridden by user definitions in
815 #ifndef YY_SKIP_YYWRAP
817 extern "C" int yywrap ( void );
819 extern int yywrap ( void );
825 static void yyunput ( int c, char *buf_ptr );
830 static void yy_flex_strncpy ( char *, const char *, int );
833 #ifdef YY_NEED_STRLEN
834 static int yy_flex_strlen ( const char * );
839 static int yyinput ( void );
841 static int input ( void );
846 /* Amount of stuff to slurp up with each read. */
847 #ifndef YY_READ_BUF_SIZE
849 /* On IA-64, the buffer size is 16k, not 8k */
850 #define YY_READ_BUF_SIZE 16384
852 #define YY_READ_BUF_SIZE 8192
853 #endif /* __ia64__ */
856 /* Copy whatever the last rule matched to the standard output. */
858 /* This used to be an fputs(), but since the string might contain NUL's,
859 * we now use fwrite().
861 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
864 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
865 * is returned in "result".
868 #define YY_INPUT(buf,result,max_size) \
869 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
873 for ( n = 0; n < max_size && \
874 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
877 buf[n++] = (char) c; \
878 if ( c == EOF && ferror( yyin ) ) \
879 YY_FATAL_ERROR( "input in flex scanner failed" ); \
885 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
887 if( errno != EINTR) \
889 YY_FATAL_ERROR( "input in flex scanner failed" ); \
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.
905 #define yyterminate() return YY_NULL
908 /* Number of entries by which start-condition stack grows. */
909 #ifndef YY_START_STACK_INCR
910 #define YY_START_STACK_INCR 25
913 /* Report a fatal error. */
914 #ifndef YY_FATAL_ERROR
915 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
918 /* end tables serialization structures and prototypes */
920 /* Default declaration of generated scanner - a define so the user can
921 * easily add parameters.
924 #define YY_DECL_IS_OURS 1
926 extern int yylex (void);
928 #define YY_DECL int yylex (void)
929 #endif /* !YY_DECL */
931 /* Code executed at the beginning of each rule, after yytext and yyleng
934 #ifndef YY_USER_ACTION
935 #define YY_USER_ACTION
938 /* Code executed at the end of each rule. */
940 #define YY_BREAK /*LINTED*/break;
943 #define YY_RULE_SETUP \
946 /** The main scanner function which does all the work.
950 yy_state_type yy_current_state;
963 (yy_start) = 1; /* first start state */
971 if ( ! YY_CURRENT_BUFFER ) {
972 yyensure_buffer_stack ();
973 YY_CURRENT_BUFFER_LVALUE =
974 yy_create_buffer( yyin, YY_BUF_SIZE );
977 yy_load_buffer_state( );
981 #line 38 "parserPromela.lex"
984 #line 985 "automaton_lexer.yy.c"
986 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
988 yy_cp = (yy_c_buf_p);
990 /* Support of yytext. */
991 *yy_cp = (yy_hold_char);
993 /* yy_bp points to the position in yy_ch_buf of the start of
998 yy_current_state = (yy_start);
1002 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1003 if ( yy_accept[yy_current_state] )
1005 (yy_last_accepting_state) = yy_current_state;
1006 (yy_last_accepting_cpos) = yy_cp;
1008 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1010 yy_current_state = (int) yy_def[yy_current_state];
1011 if ( yy_current_state >= 54 )
1012 yy_c = yy_meta[yy_c];
1014 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1017 while ( yy_base[yy_current_state] != 90 );
1020 yy_act = yy_accept[yy_current_state];
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];
1028 YY_DO_BEFORE_ACTION;
1030 do_action: /* This label is used only to access EOF actions. */
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;
1043 #line 40 "parserPromela.lex"
1048 #line 41 "parserPromela.lex"
1053 #line 42 "parserPromela.lex"
1058 #line 43 "parserPromela.lex"
1059 { return (IMPLIES); }
1063 #line 44 "parserPromela.lex"
1068 #line 45 "parserPromela.lex"
1073 #line 46 "parserPromela.lex"
1078 #line 47 "parserPromela.lex"
1083 #line 48 "parserPromela.lex"
1084 { return (LEFT_PAR); }
1088 #line 49 "parserPromela.lex"
1089 { return (RIGHT_PAR); }
1093 #line 50 "parserPromela.lex"
1098 #line 51 "parserPromela.lex"
1103 #line 52 "parserPromela.lex"
1104 { return (SEMI_COLON); }
1108 #line 53 "parserPromela.lex"
1109 { return (CASE_TRUE); }
1113 #line 54 "parserPromela.lex"
1114 { return (LEFT_BRACE); }
1118 #line 55 "parserPromela.lex"
1119 { return (RIGHT_BRACE); }
1122 /* rule 17 can match eol */
1124 #line 58 "parserPromela.lex"
1129 #line 60 "parserPromela.lex"
1134 #line 63 "parserPromela.lex"
1135 { sscanf(yytext,"%lf",&yylval.real);
1136 return (LITT_REEL); }
1140 #line 66 "parserPromela.lex"
1141 { sscanf(yytext,"%d",&yylval.integer);
1142 return (LITT_ENT); }
1145 /* rule 21 can match eol */
1147 #line 69 "parserPromela.lex"
1148 { yylval.string=(char *)malloc(strlen(yytext)+1);
1149 sscanf(yytext,"%s",yylval.string);
1150 return (LITT_CHAINE); }
1154 #line 73 "parserPromela.lex"
1155 { yylval.string=(char *)malloc(strlen(yytext)+1);
1156 sscanf(yytext,"%s",yylval.string);
1160 /* rule 23 can match eol */
1162 #line 77 "parserPromela.lex"
1167 #line 79 "parserPromela.lex"
1172 #line 81 "parserPromela.lex"
1175 #line 1176 "automaton_lexer.yy.c"
1176 case YY_STATE_EOF(INITIAL):
1179 case YY_END_OF_BUFFER:
1181 /* Amount of text matched not including the EOB char. */
1182 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1184 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1185 *yy_cp = (yy_hold_char);
1186 YY_RESTORE_YY_MORE_OFFSET
1188 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
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.
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;
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
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;
1215 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1217 yy_current_state = yy_get_previous_state( );
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).
1228 yy_next_state = yy_try_NUL_trans( yy_current_state );
1230 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1232 if ( yy_next_state )
1234 /* Consume the NUL. */
1235 yy_cp = ++(yy_c_buf_p);
1236 yy_current_state = yy_next_state;
1242 yy_cp = (yy_c_buf_p);
1243 goto yy_find_action;
1247 else switch ( yy_get_next_buffer( ) )
1249 case EOB_ACT_END_OF_FILE:
1251 (yy_did_buffer_switch_on_eof) = 0;
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.
1264 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1266 yy_act = YY_STATE_EOF(YY_START);
1272 if ( ! (yy_did_buffer_switch_on_eof) )
1278 case EOB_ACT_CONTINUE_SCAN:
1280 (yytext_ptr) + yy_amount_of_matched_text;
1282 yy_current_state = yy_get_previous_state( );
1284 yy_cp = (yy_c_buf_p);
1285 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1288 case EOB_ACT_LAST_MATCH:
1290 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1292 yy_current_state = yy_get_previous_state( );
1294 yy_cp = (yy_c_buf_p);
1295 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1296 goto yy_find_action;
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 */
1309 /* yy_get_next_buffer - try to read in a new buffer
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
1316 static int yy_get_next_buffer (void)
1318 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1319 char *source = (yytext_ptr);
1320 int number_to_move, i;
1323 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1325 "fatal flex scanner internal error--end of buffer missed" );
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 )
1331 /* We matched a single character, the EOB, so
1332 * treat this as a final EOF.
1334 return EOB_ACT_END_OF_FILE;
1339 /* We matched some text prior to the EOB, first
1342 return EOB_ACT_LAST_MATCH;
1346 /* Try to read more data. */
1348 /* First move last chars to start of buffer. */
1349 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1351 for ( i = 0; i < number_to_move; ++i )
1352 *(dest++) = *(source++);
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,
1358 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1363 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1365 while ( num_to_read <= 0 )
1366 { /* Not enough room in the buffer - grow it. */
1368 /* just a shorter name for the current buffer */
1369 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1371 int yy_c_buf_p_offset =
1372 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1374 if ( b->yy_is_our_buffer )
1376 int new_size = b->yy_buf_size * 2;
1378 if ( new_size <= 0 )
1379 b->yy_buf_size += b->yy_buf_size / 8;
1381 b->yy_buf_size *= 2;
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) );
1389 /* Can't grow it, we don't own it. */
1390 b->yy_ch_buf = NULL;
1392 if ( ! b->yy_ch_buf )
1394 "fatal error - scanner input buffer overflow" );
1396 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1398 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1403 if ( num_to_read > YY_READ_BUF_SIZE )
1404 num_to_read = YY_READ_BUF_SIZE;
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 );
1410 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1413 if ( (yy_n_chars) == 0 )
1415 if ( number_to_move == YY_MORE_ADJ )
1417 ret_val = EOB_ACT_END_OF_FILE;
1423 ret_val = EOB_ACT_LAST_MATCH;
1424 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1425 YY_BUFFER_EOF_PENDING;
1430 ret_val = EOB_ACT_CONTINUE_SCAN;
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);
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;
1447 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1452 /* yy_get_previous_state - get the state just before the EOB char was reached */
1454 static yy_state_type yy_get_previous_state (void)
1456 yy_state_type yy_current_state;
1459 yy_current_state = (yy_start);
1461 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1463 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1464 if ( yy_accept[yy_current_state] )
1466 (yy_last_accepting_state) = yy_current_state;
1467 (yy_last_accepting_cpos) = yy_cp;
1469 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1471 yy_current_state = (int) yy_def[yy_current_state];
1472 if ( yy_current_state >= 54 )
1473 yy_c = yy_meta[yy_c];
1475 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1478 return yy_current_state;
1481 /* yy_try_NUL_trans - try to make a transition on the NUL character
1484 * next_state = yy_try_NUL_trans( current_state );
1486 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1489 char *yy_cp = (yy_c_buf_p);
1492 if ( yy_accept[yy_current_state] )
1494 (yy_last_accepting_state) = yy_current_state;
1495 (yy_last_accepting_cpos) = yy_cp;
1497 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1499 yy_current_state = (int) yy_def[yy_current_state];
1500 if ( yy_current_state >= 54 )
1501 yy_c = yy_meta[yy_c];
1503 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1504 yy_is_jam = (yy_current_state == 53);
1506 return yy_is_jam ? 0 : yy_current_state;
1511 static void yyunput (int c, char * yy_bp )
1515 yy_cp = (yy_c_buf_p);
1517 /* undo effects of setting up yytext */
1518 *yy_cp = (yy_hold_char);
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];
1527 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1529 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1530 *--dest = *--source;
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;
1537 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1538 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1541 *--yy_cp = (char) c;
1543 (yytext_ptr) = yy_bp;
1544 (yy_hold_char) = *yy_cp;
1545 (yy_c_buf_p) = yy_cp;
1552 static int yyinput (void)
1554 static int input (void)
1560 *(yy_c_buf_p) = (yy_hold_char);
1562 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
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.
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';
1573 { /* need more input */
1574 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1577 switch ( yy_get_next_buffer( ) )
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.
1590 /* Reset buffer status. */
1595 case EOB_ACT_END_OF_FILE:
1600 if ( ! (yy_did_buffer_switch_on_eof) )
1609 case EOB_ACT_CONTINUE_SCAN:
1610 (yy_c_buf_p) = (yytext_ptr) + offset;
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);
1622 #endif /* ifndef YY_NO_INPUT */
1624 /** Immediately switch to a different input stream.
1625 * @param input_file A readable stream.
1627 * @note This function does not reset the start condition to @c INITIAL .
1629 void yyrestart (FILE * input_file )
1632 if ( ! YY_CURRENT_BUFFER ){
1633 yyensure_buffer_stack ();
1634 YY_CURRENT_BUFFER_LVALUE =
1635 yy_create_buffer( yyin, YY_BUF_SIZE );
1638 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1639 yy_load_buffer_state( );
1642 /** Switch to a different input buffer.
1643 * @param new_buffer The new input buffer.
1646 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1649 /* TODO. We should be able to replace this entire function body
1651 * yypop_buffer_state();
1652 * yypush_buffer_state(new_buffer);
1654 yyensure_buffer_stack ();
1655 if ( YY_CURRENT_BUFFER == new_buffer )
1658 if ( YY_CURRENT_BUFFER )
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);
1666 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1667 yy_load_buffer_state( );
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.
1674 (yy_did_buffer_switch_on_eof) = 1;
1677 static void yy_load_buffer_state (void)
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);
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.
1689 * @return the allocated buffer state.
1691 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1695 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1697 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1699 b->yy_buf_size = size;
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.
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()" );
1708 b->yy_is_our_buffer = 1;
1710 yy_init_buffer( b, file );
1715 /** Destroy the buffer.
1716 * @param b a buffer created with yy_create_buffer()
1719 void yy_delete_buffer (YY_BUFFER_STATE b )
1725 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1726 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1728 if ( b->yy_is_our_buffer )
1729 yyfree( (void *) b->yy_ch_buf );
1731 yyfree( (void *) b );
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.
1738 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1743 yy_flush_buffer( b );
1745 b->yy_input_file = file;
1746 b->yy_fill_buffer = 1;
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.
1752 if (b != YY_CURRENT_BUFFER){
1753 b->yy_bs_lineno = 1;
1754 b->yy_bs_column = 0;
1757 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
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.
1766 void yy_flush_buffer (YY_BUFFER_STATE b )
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.
1777 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1778 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1780 b->yy_buf_pos = &b->yy_ch_buf[0];
1783 b->yy_buffer_status = YY_BUFFER_NEW;
1785 if ( b == YY_CURRENT_BUFFER )
1786 yy_load_buffer_state( );
1789 /** Pushes the new state onto the stack. The new state becomes
1790 * the current state. This function will allocate the stack
1792 * @param new_buffer The new state.
1795 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1797 if (new_buffer == NULL)
1800 yyensure_buffer_stack();
1802 /* This block is copied from yy_switch_to_buffer. */
1803 if ( YY_CURRENT_BUFFER )
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);
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;
1816 /* copied from yy_switch_to_buffer. */
1817 yy_load_buffer_state( );
1818 (yy_did_buffer_switch_on_eof) = 1;
1821 /** Removes and deletes the top of the stack, if present.
1822 * The next element becomes the new top.
1825 void yypop_buffer_state (void)
1827 if (!YY_CURRENT_BUFFER)
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);
1835 if (YY_CURRENT_BUFFER) {
1836 yy_load_buffer_state( );
1837 (yy_did_buffer_switch_on_eof) = 1;
1841 /* Allocates the stack if it does not exist.
1842 * Guarantees space for at least one push.
1844 static void yyensure_buffer_stack (void)
1846 yy_size_t num_to_alloc;
1848 if (!(yy_buffer_stack)) {
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.
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*)
1858 if ( ! (yy_buffer_stack) )
1859 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1861 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1863 (yy_buffer_stack_max) = num_to_alloc;
1864 (yy_buffer_stack_top) = 0;
1868 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1870 /* Increase the buffer to prepare for a possible push. */
1871 yy_size_t grow_size = 8 /* arbitrary grow size */;
1873 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1874 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1876 num_to_alloc * sizeof(struct yy_buffer_state*)
1878 if ( ! (yy_buffer_stack) )
1879 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
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;
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
1891 * @return the newly allocated buffer state object.
1893 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
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. */
1903 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1905 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
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;
1914 b->yy_fill_buffer = 0;
1915 b->yy_buffer_status = YY_BUFFER_NEW;
1917 yy_switch_to_buffer( b );
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
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.
1930 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1933 return yy_scan_bytes( yystr, (int) strlen(yystr) );
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.
1941 * @return the newly allocated buffer state object.
1943 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
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 );
1954 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1956 for ( i = 0; i < _yybytes_len; ++i )
1957 buf[i] = yybytes[i];
1959 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1961 b = yy_scan_buffer( buf, n );
1963 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1965 /* It's okay to grow etc. this buffer, and we should throw it
1966 * away when we're done.
1968 b->yy_is_our_buffer = 1;
1973 #ifndef YY_EXIT_FAILURE
1974 #define YY_EXIT_FAILURE 2
1977 static void yynoreturn yy_fatal_error (const char* msg )
1979 fprintf( stderr, "%s\n", msg );
1980 exit( YY_EXIT_FAILURE );
1983 /* Redefine yyless() so it works in section 3 code. */
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; \
2000 /* Accessor methods (get/set functions) to struct members. */
2002 /** Get the current line number.
2005 int yyget_lineno (void)
2011 /** Get the input stream.
2014 FILE *yyget_in (void)
2019 /** Get the output stream.
2022 FILE *yyget_out (void)
2027 /** Get the length of the current token.
2030 int yyget_leng (void)
2035 /** Get the current token.
2039 char *yyget_text (void)
2044 /** Set the current line number.
2045 * @param _line_number line number
2048 void yyset_lineno (int _line_number )
2051 yylineno = _line_number;
2054 /** Set the input stream. This does not discard the current
2056 * @param _in_str A readable stream.
2058 * @see yy_switch_to_buffer
2060 void yyset_in (FILE * _in_str )
2065 void yyset_out (FILE * _out_str )
2070 int yyget_debug (void)
2072 return yy_flex_debug;
2075 void yyset_debug (int _bdebug )
2077 yy_flex_debug = _bdebug ;
2080 static int yy_init_globals (void)
2082 /* Initialization is the same as for the non-reentrant scanner.
2083 * This function is called from yylex_destroy(), so don't allocate here.
2086 (yy_buffer_stack) = NULL;
2087 (yy_buffer_stack_top) = 0;
2088 (yy_buffer_stack_max) = 0;
2089 (yy_c_buf_p) = NULL;
2093 /* Defined in main.c */
2102 /* For future reference: Set errno on error, since we are called by
2108 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2109 int yylex_destroy (void)
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();
2119 /* Destroy the stack itself. */
2120 yyfree((yy_buffer_stack) );
2121 (yy_buffer_stack) = NULL;
2123 /* Reset the globals. This is important in a non-reentrant scanner so the next time
2124 * yylex() is called, initialization will occur. */
2131 * Internal utility routines.
2135 static void yy_flex_strncpy (char* s1, const char * s2, int n )
2139 for ( i = 0; i < n; ++i )
2144 #ifdef YY_NEED_STRLEN
2145 static int yy_flex_strlen (const char * s )
2148 for ( n = 0; s[n]; ++n )
2155 void *yyalloc (yy_size_t size )
2157 return malloc(size);
2160 void *yyrealloc (void * ptr, yy_size_t size )
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.
2170 return realloc(ptr, size);
2173 void yyfree (void * ptr )
2175 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2178 #define YYTABLES_NAME "yytables"
2180 #line 81 "parserPromela.lex"