examples/msg/mc/lex.yy.c

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