util/epist/lex.yy.c

   1 /* A lexical scanner generated by flex */
   2
   3 /* Scanner skeleton version:
   4  * $Header$
   5  */
   6
   7 #define FLEX_SCANNER
   8 #define YY_FLEX_MAJOR_VERSION 2
   9 #define YY_FLEX_MINOR_VERSION 5
  10
  11 #include <stdio.h>
  12
  13
  14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15 #ifdef c_plusplus
  16 #ifndef __cplusplus
  17 #define __cplusplus
  18 #endif
  19 #endif
  20
  21
  22 #ifdef __cplusplus
  23
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26
  27 /* Use prototypes in function declarations. */
  28 #define YY_USE_PROTOS
  29
  30 /* The "const" storage-class-modifier is valid. */
  31 #define YY_USE_CONST
  32
  33 #else   /* ! __cplusplus */
  34
  35 #if __STDC__
  36
  37 #define YY_USE_PROTOS
  38 #define YY_USE_CONST
  39
  40 #endif  /* __STDC__ */
  41 #endif  /* ! __cplusplus */
  42
  43 #ifdef __TURBOC__
  44  #pragma warn -rch
  45  #pragma warn -use
  46 #include <io.h>
  47 #include <stdlib.h>
  48 #define YY_USE_CONST
  49 #define YY_USE_PROTOS
  50 #endif
  51
  52 #ifdef YY_USE_CONST
  53 #define yyconst const
  54 #else
  55 #define yyconst
  56 #endif
  57
  58
  59 #ifdef YY_USE_PROTOS
  60 #define YY_PROTO(proto) proto
  61 #else
  62 #define YY_PROTO(proto) ()
  63 #endif
  64
  65 /* Returned upon end-of-file. */
  66 #define YY_NULL 0
  67
  68 /* Promotes a possibly negative, possibly signed char to an unsigned
  69  * integer for use as an array index.  If the signed char is negative,
  70  * we want to instead treat it as an 8-bit unsigned char, hence the
  71  * double cast.
  72  */
  73 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74
  75 /* Enter a start condition.  This macro really ought to take a parameter,
  76  * but we do it the disgusting crufty way forced on us by the ()-less
  77  * definition of BEGIN.
  78  */
  79 #define BEGIN yy_start = 1 + 2 *
  80
  81 /* Translate the current start state into a value that can be later handed
  82  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83  * compatibility.
  84  */
  85 #define YY_START ((yy_start - 1) / 2)
  86 #define YYSTATE YY_START
  87
  88 /* Action number for EOF rule of a given start state. */
  89 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90
  91 /* Special action meaning "start processing a new file". */
  92 #define YY_NEW_FILE yyrestart( yyin )
  93
  94 #define YY_END_OF_BUFFER_CHAR 0
  95
  96 /* Size of default input buffer. */
  97 #define YY_BUF_SIZE 16384
  98
  99 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 100
 101 extern int yyleng;
 102 extern FILE *yyin, *yyout;
 103
 104 #define EOB_ACT_CONTINUE_SCAN 0
 105 #define EOB_ACT_END_OF_FILE 1
 106 #define EOB_ACT_LAST_MATCH 2
 107
 108 /* The funky do-while in the following #define is used to turn the definition
 109  * int a single C statement (which needs a semi-colon terminator).  This
 110  * avoids problems with code like:
 111  *
 112  *      if ( condition_holds )
 113  *              yyless( 5 );
 114  *      else
 115  *              do_something_else();
 116  *
 117  * Prior to using the do-while the compiler would get upset at the
 118  * "else" because it interpreted the "if" statement as being all
 119  * done when it reached the ';' after the yyless() call.
 120  */
 121
 122 /* Return all but the first 'n' matched characters back to the input stream. */
 123
 124 #define yyless(n) \
 125         do \
 126                 { \
 127                 /* Undo effects of setting up yytext. */ \
 128                 *yy_cp = yy_hold_char; \
 129                 YY_RESTORE_YY_MORE_OFFSET \
 130                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 131                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 132                 } \
 133         while ( 0 )
 134
 135 #define unput(c) yyunput( c, yytext_ptr )
 136
 137 /* The following is because we cannot portably get our hands on size_t
 138  * (without autoconf's help, which isn't available because we want
 139  * flex-generated scanners to compile on their own).
 140  */
 141 typedef unsigned int yy_size_t;
 142
 143
 144 struct yy_buffer_state
 145         {
 146         FILE *yy_input_file;
 147
 148         char *yy_ch_buf;                /* input buffer */
 149         char *yy_buf_pos;               /* current position in input buffer */
 150
 151         /* Size of input buffer in bytes, not including room for EOB
 152          * characters.
 153          */
 154         yy_size_t yy_buf_size;
 155
 156         /* Number of characters read into yy_ch_buf, not including EOB
 157          * characters.
 158          */
 159         int yy_n_chars;
 160
 161         /* Whether we "own" the buffer - i.e., we know we created it,
 162          * and can realloc() it to grow it, and should free() it to
 163          * delete it.
 164          */
 165         int yy_is_our_buffer;
 166
 167         /* Whether this is an "interactive" input source; if so, and
 168          * if we're using stdio for input, then we want to use getc()
 169          * instead of fread(), to make sure we stop fetching input after
 170          * each newline.
 171          */
 172         int yy_is_interactive;
 173
 174         /* Whether we're considered to be at the beginning of a line.
 175          * If so, '^' rules will be active on the next match, otherwise
 176          * not.
 177          */
 178         int yy_at_bol;
 179
 180         /* Whether to try to fill the input buffer when we reach the
 181          * end of it.
 182          */
 183         int yy_fill_buffer;
 184
 185         int yy_buffer_status;
 186 #define YY_BUFFER_NEW 0
 187 #define YY_BUFFER_NORMAL 1
 188         /* When an EOF's been seen but there's still some text to process
 189          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 190          * shouldn't try reading from the input source any more.  We might
 191          * still have a bunch of tokens to match, though, because of
 192          * possible backing-up.
 193          *
 194          * When we actually see the EOF, we change the status to "new"
 195          * (via yyrestart()), so that the user can continue scanning by
 196          * just pointing yyin at a new input file.
 197          */
 198 #define YY_BUFFER_EOF_PENDING 2
 199         };
 200
 201 static YY_BUFFER_STATE yy_current_buffer = 0;
 202
 203 /* We provide macros for accessing buffer states in case in the
 204  * future we want to put the buffer states in a more general
 205  * "scanner state".
 206  */
 207 #define YY_CURRENT_BUFFER yy_current_buffer
 208
 209
 210 /* yy_hold_char holds the character lost when yytext is formed. */
 211 static char yy_hold_char;
 212
 213 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 214
 215
 216 int yyleng;
 217
 218 /* Points to current character in buffer. */
 219 static char *yy_c_buf_p = (char *) 0;
 220 static int yy_init = 1;         /* whether we need to initialize */
 221 static int yy_start = 0;        /* start state number */
 222
 223 /* Flag which is used to allow yywrap()'s to do buffer switches
 224  * instead of setting up a fresh yyin.  A bit of a hack ...
 225  */
 226 static int yy_did_buffer_switch_on_eof;
 227
 228 void yyrestart YY_PROTO(( FILE *input_file ));
 229
 230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 231 void yy_load_buffer_state YY_PROTO(( void ));
 232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 237
 238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 241
 242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 244 static void yy_flex_free YY_PROTO(( void * ));
 245
 246 #define yy_new_buffer yy_create_buffer
 247
 248 #define yy_set_interactive(is_interactive) \
 249         { \
 250         if ( ! yy_current_buffer ) \
 251                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 252         yy_current_buffer->yy_is_interactive = is_interactive; \
 253         }
 254
 255 #define yy_set_bol(at_bol) \
 256         { \
 257         if ( ! yy_current_buffer ) \
 258                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 259         yy_current_buffer->yy_at_bol = at_bol; \
 260         }
 261
 262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 263
 264 typedef unsigned char YY_CHAR;
 265 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 266 typedef int yy_state_type;
 267 extern char *yytext;
 268 #define yytext_ptr yytext
 269
 270 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 271 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 272 static int yy_get_next_buffer YY_PROTO(( void ));
 273 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 274
 275 /* Done after the current pattern has been matched and before the
 276  * corresponding action - sets up yytext.
 277  */
 278 #define YY_DO_BEFORE_ACTION \
 279         yytext_ptr = yy_bp; \
 280         yyleng = (int) (yy_cp - yy_bp); \
 281         yy_hold_char = *yy_cp; \
 282         *yy_cp = '\0'; \
 283         yy_c_buf_p = yy_cp;
 284
 285 #define YY_NUM_RULES 29
 286 #define YY_END_OF_BUFFER 30
 287 static yyconst short int yy_accept[93] =
 288     {   0,
 289         0,    0,   30,   29,   28,   27,   29,   29,    4,   23,
 290         3,   25,   25,   25,   25,   25,   25,   25,   25,   25,
 291        25,   25,   25,   25,    1,    2,   28,    0,    0,   23,
 292        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
 293        25,   25,   25,   24,   26,   25,   25,   25,   25,   25,
 294        25,   25,   25,   25,   25,   25,   25,   25,   25,    7,
 295         9,   11,   13,   25,   25,   20,   25,   25,    8,   10,
 296        12,   14,   25,   25,   19,   25,   22,   25,   18,   25,
 297        21,   25,   17,   25,   25,   25,   25,   15,    5,   16,
 298         6,    0
 299
 300     } ;
 301
 302 static yyconst int yy_ec[256] =
 303     {   0,
 304         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 305         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 306         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 307         1,    2,    1,    4,    5,    1,    1,    1,    1,    1,
 308         1,    1,    1,    1,    6,    1,    1,    7,    8,    9,
 309        10,   11,    7,    7,    7,    7,    7,    1,   12,    1,
 310         1,    1,    1,    1,   13,   13,   14,   13,   13,   15,
 311        13,   13,   13,   13,   13,   13,   16,   13,   17,   13,
 312        13,   13,   18,   19,   13,   13,   13,   13,   13,   13,
 313         1,    1,    1,    1,   13,    1,   20,   13,   21,   22,
 314
 315        23,   24,   13,   25,   26,   13,   13,   27,   28,   29,
 316        30,   31,   13,   32,   33,   34,   35,   13,   13,   13,
 317        13,   13,   36,    1,   37,    1,    1,    1,    1,    1,
 318         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 319         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 320         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 321         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 322         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 323         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 325
 326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 331         1,    1,    1,    1,    1
 332     } ;
 333
 334 static yyconst int yy_meta[38] =
 335     {   0,
 336         1,    1,    2,    1,    1,    1,    3,    3,    3,    3,
 337         3,    1,    3,    3,    3,    3,    3,    3,    3,    3,
 338         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 339         3,    3,    3,    3,    3,    1,    1
 340     } ;
 341
 342 static yyconst short int yy_base[96] =
 343     {   0,
 344         0,    0,  116,  117,  113,  117,    0,    0,  117,   31,
 345       117,    0,   84,   93,   82,   80,   85,   77,   78,   87,
 346        76,   74,   79,   71,  117,  117,  100,   97,   97,   36,
 347         0,   70,   71,   75,   62,   69,   59,   64,   65,   69,
 348        56,   63,   53,   83,  117,   52,   52,   40,   58,   59,
 349        59,   47,   47,   44,   53,   54,   54,   44,   52,    0,
 350         0,    0,    0,   44,   39,    0,   40,   48,    0,    0,
 351         0,    0,   40,   35,    0,   38,    0,   38,    0,   36,
 352         0,   36,    0,   37,   30,   35,   27,    0,    0,    0,
 353         0,  117,   55,   58,   54
 354
 355     } ;
 356
 357 static yyconst short int yy_def[96] =
 358     {   0,
 359        92,    1,   92,   92,   92,   92,   93,   94,   92,   95,
 360        92,   95,   95,   95,   95,   95,   95,   95,   95,   95,
 361        95,   95,   95,   95,   92,   92,   92,   93,   94,   95,
 362        95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
 363        95,   95,   95,   93,   92,   95,   95,   95,   95,   95,
 364        95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
 365        95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
 366        95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
 367        95,   95,   95,   95,   95,   95,   95,   95,   95,   95,
 368        95,    0,   92,   92,   92
 369
 370     } ;
 371
 372 static yyconst short int yy_nxt[155] =
 373     {   0,
 374         4,    5,    6,    7,    8,    9,   10,   10,   10,   10,
 375        10,   11,   12,   13,   14,   15,   16,   17,   18,   12,
 376        19,   12,   12,   20,   12,   12,   12,   21,   12,   22,
 377        12,   12,   23,   24,   12,   25,   26,   30,   30,   30,
 378        30,   30,   30,   30,   30,   30,   30,   60,   61,   62,
 379        63,   69,   70,   71,   72,   28,   31,   28,   29,   91,
 380        29,   90,   89,   88,   87,   86,   85,   84,   83,   82,
 381        81,   80,   79,   78,   77,   76,   75,   74,   73,   68,
 382        67,   66,   65,   64,   59,   58,   44,   57,   56,   55,
 383        54,   53,   52,   51,   50,   49,   48,   47,   46,   45,
 384
 385        44,   27,   43,   42,   41,   40,   39,   38,   37,   36,
 386        35,   34,   33,   32,   27,   92,    3,   92,   92,   92,
 387        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 388        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 389        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 390        92,   92,   92,   92
 391     } ;
 392
 393 static yyconst short int yy_chk[155] =
 394     {   0,
 395         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398         1,    1,    1,    1,    1,    1,    1,   10,   10,   10,
 399        10,   10,   30,   30,   30,   30,   30,   48,   48,   48,
 400        48,   54,   54,   54,   54,   93,   95,   93,   94,   87,
 401        94,   86,   85,   84,   82,   80,   78,   76,   74,   73,
 402        68,   67,   65,   64,   59,   58,   57,   56,   55,   53,
 403        52,   51,   50,   49,   47,   46,   44,   43,   42,   41,
 404        40,   39,   38,   37,   36,   35,   34,   33,   32,   29,
 405
 406        28,   27,   24,   23,   22,   21,   20,   19,   18,   17,
 407        16,   15,   14,   13,    5,    3,   92,   92,   92,   92,
 408        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 409        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 410        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 411        92,   92,   92,   92
 412     } ;
 413
 414 static yy_state_type yy_last_accepting_state;
 415 static char *yy_last_accepting_cpos;
 416
 417 /* The intent behind this definition is that it'll catch
 418  * any uses of REJECT which flex missed.
 419  */
 420 #define REJECT reject_used_but_not_detected
 421 #define yymore() yymore_used_but_not_detected
 422 #define YY_MORE_ADJ 0
 423 #define YY_RESTORE_YY_MORE_OFFSET
 424 char *yytext;
 425 #line 1 "epist.l"
 426 #define INITIAL 0
 427 #line 2 "epist.l"
 428 #include <stdio.h>
 429 #include <string.h>
 430 #include "yacc_parser.hh"
 431
 432 extern YYSTYPE yylval;
 433
 434 #line 435 "lex.yy.c"
 435
 436 /* Macros after this point can all be overridden by user definitions in
 437  * section 1.
 438  */
 439
 440 #ifndef YY_SKIP_YYWRAP
 441 #ifdef __cplusplus
 442 extern "C" int yywrap YY_PROTO(( void ));
 443 #else
 444 extern int yywrap YY_PROTO(( void ));
 445 #endif
 446 #endif
 447
 448 #ifndef YY_NO_UNPUT
 449 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 450 #endif
 451
 452 #ifndef yytext_ptr
 453 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 454 #endif
 455
 456 #ifdef YY_NEED_STRLEN
 457 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 458 #endif
 459
 460 #ifndef YY_NO_INPUT
 461 #ifdef __cplusplus
 462 static int yyinput YY_PROTO(( void ));
 463 #else
 464 static int input YY_PROTO(( void ));
 465 #endif
 466 #endif
 467
 468 #if YY_STACK_USED
 469 static int yy_start_stack_ptr = 0;
 470 static int yy_start_stack_depth = 0;
 471 static int *yy_start_stack = 0;
 472 #ifndef YY_NO_PUSH_STATE
 473 static void yy_push_state YY_PROTO(( int new_state ));
 474 #endif
 475 #ifndef YY_NO_POP_STATE
 476 static void yy_pop_state YY_PROTO(( void ));
 477 #endif
 478 #ifndef YY_NO_TOP_STATE
 479 static int yy_top_state YY_PROTO(( void ));
 480 #endif
 481
 482 #else
 483 #define YY_NO_PUSH_STATE 1
 484 #define YY_NO_POP_STATE 1
 485 #define YY_NO_TOP_STATE 1
 486 #endif
 487
 488 #ifdef YY_MALLOC_DECL
 489 YY_MALLOC_DECL
 490 #else
 491 #if __STDC__
 492 #ifndef __cplusplus
 493 #include <stdlib.h>
 494 #endif
 495 #else
 496 /* Just try to get by without declaring the routines.  This will fail
 497  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 498  * or sizeof(void*) != sizeof(int).
 499  */
 500 #endif
 501 #endif
 502
 503 /* Amount of stuff to slurp up with each read. */
 504 #ifndef YY_READ_BUF_SIZE
 505 #define YY_READ_BUF_SIZE 8192
 506 #endif
 507
 508 /* Copy whatever the last rule matched to the standard output. */
 509
 510 #ifndef ECHO
 511 /* This used to be an fputs(), but since the string might contain NUL's,
 512  * we now use fwrite().
 513  */
 514 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 515 #endif
 516
 517 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 518  * is returned in "result".
 519  */
 520 #ifndef YY_INPUT
 521 #define YY_INPUT(buf,result,max_size) \
 522         if ( yy_current_buffer->yy_is_interactive ) \
 523                 { \
 524                 int c = '*', n; \
 525                 for ( n = 0; n < max_size && \
 526                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 527                         buf[n] = (char) c; \
 528                 if ( c == '\n' ) \
 529                         buf[n++] = (char) c; \
 530                 if ( c == EOF && ferror( yyin ) ) \
 531                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 532                 result = n; \
 533                 } \
 534         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 535                   && ferror( yyin ) ) \
 536                 YY_FATAL_ERROR( "input in flex scanner failed" );
 537 #endif
 538
 539 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 540  * we don't want an extra ';' after the "return" because that will cause
 541  * some compilers to complain about unreachable statements.
 542  */
 543 #ifndef yyterminate
 544 #define yyterminate() return YY_NULL
 545 #endif
 546
 547 /* Number of entries by which start-condition stack grows. */
 548 #ifndef YY_START_STACK_INCR
 549 #define YY_START_STACK_INCR 25
 550 #endif
 551
 552 /* Report a fatal error. */
 553 #ifndef YY_FATAL_ERROR
 554 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 555 #endif
 556
 557 /* Default declaration of generated scanner - a define so the user can
 558  * easily add parameters.
 559  */
 560 #ifndef YY_DECL
 561 #define YY_DECL int yylex YY_PROTO(( void ))
 562 #endif
 563
 564 /* Code executed at the beginning of each rule, after yytext and yyleng
 565  * have been set up.
 566  */
 567 #ifndef YY_USER_ACTION
 568 #define YY_USER_ACTION
 569 #endif
 570
 571 /* Code executed at the end of each rule. */
 572 #ifndef YY_BREAK
 573 #define YY_BREAK break;
 574 #endif
 575
 576 #define YY_RULE_SETUP \
 577         YY_USER_ACTION
 578
 579 YY_DECL
 580         {
 581         register yy_state_type yy_current_state;
 582         register char *yy_cp, *yy_bp;
 583         register int yy_act;
 584
 585 #line 10 "epist.l"
 586
 587
 588 #line 589 "lex.yy.c"
 589
 590         if ( yy_init )
 591                 {
 592                 yy_init = 0;
 593
 594 #ifdef YY_USER_INIT
 595                 YY_USER_INIT;
 596 #endif
 597
 598                 if ( ! yy_start )
 599                         yy_start = 1;   /* first start state */
 600
 601                 if ( ! yyin )
 602                         yyin = stdin;
 603
 604                 if ( ! yyout )
 605                         yyout = stdout;
 606
 607                 if ( ! yy_current_buffer )
 608                         yy_current_buffer =
 609                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 610
 611                 yy_load_buffer_state();
 612                 }
 613
 614         while ( 1 )             /* loops until end-of-file is reached */
 615                 {
 616                 yy_cp = yy_c_buf_p;
 617
 618                 /* Support of yytext. */
 619                 *yy_cp = yy_hold_char;
 620
 621                 /* yy_bp points to the position in yy_ch_buf of the start of
 622                  * the current run.
 623                  */
 624                 yy_bp = yy_cp;
 625
 626                 yy_current_state = yy_start;
 627 yy_match:
 628                 do
 629                         {
 630                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 631                         if ( yy_accept[yy_current_state] )
 632                                 {
 633                                 yy_last_accepting_state = yy_current_state;
 634                                 yy_last_accepting_cpos = yy_cp;
 635                                 }
 636                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 637                                 {
 638                                 yy_current_state = (int) yy_def[yy_current_state];
 639                                 if ( yy_current_state >= 93 )
 640                                         yy_c = yy_meta[(unsigned int) yy_c];
 641                                 }
 642                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 643                         ++yy_cp;
 644                         }
 645                 while ( yy_base[yy_current_state] != 117 );
 646
 647 yy_find_action:
 648                 yy_act = yy_accept[yy_current_state];
 649                 if ( yy_act == 0 )
 650                         { /* have to back up */
 651                         yy_cp = yy_last_accepting_cpos;
 652                         yy_current_state = yy_last_accepting_state;
 653                         yy_act = yy_accept[yy_current_state];
 654                         }
 655
 656                 YY_DO_BEFORE_ACTION;
 657
 658
 659 do_action:      /* This label is used only to access EOF actions. */
 660
 661
 662                 switch ( yy_act )
 663         { /* beginning of action switch */
 664                         case 0: /* must back up */
 665                         /* undo the effects of YY_DO_BEFORE_ACTION */
 666                         *yy_cp = yy_hold_char;
 667                         yy_cp = yy_last_accepting_cpos;
 668                         yy_current_state = yy_last_accepting_state;
 669                         goto yy_find_action;
 670
 671 case 1:
 672 YY_RULE_SETUP
 673 #line 12 "epist.l"
 674 return OBRACE;
 675         YY_BREAK
 676 case 2:
 677 YY_RULE_SETUP
 678 #line 13 "epist.l"
 679 return EBRACE;
 680         YY_BREAK
 681 case 3:
 682 YY_RULE_SETUP
 683 #line 14 "epist.l"
 684 return SEMICOLON;
 685         YY_BREAK
 686 case 4:
 687 YY_RULE_SETUP
 688 #line 15 "epist.l"
 689 return DASH;
 690         YY_BREAK
 691 case 5:
 692 #line 17 "epist.l"
 693 case 6:
 694 YY_RULE_SETUP
 695 #line 17 "epist.l"
 696 return OPTIONS;
 697         YY_BREAK
 698 case 7:
 699 #line 19 "epist.l"
 700 case 8:
 701 #line 20 "epist.l"
 702 case 9:
 703 #line 21 "epist.l"
 704 case 10:
 705 #line 22 "epist.l"
 706 case 11:
 707 #line 23 "epist.l"
 708 case 12:
 709 #line 24 "epist.l"
 710 case 13:
 711 #line 25 "epist.l"
 712 case 14:
 713 #line 26 "epist.l"
 714 case 15:
 715 #line 27 "epist.l"
 716 case 16:
 717 #line 28 "epist.l"
 718 case 17:
 719 #line 29 "epist.l"
 720 case 18:
 721 YY_RULE_SETUP
 722 #line 29 "epist.l"
 723 yylval = (int) strdup(yytext); return BINDING;
 724         YY_BREAK
 725 case 19:
 726 #line 31 "epist.l"
 727 case 20:
 728 YY_RULE_SETUP
 729 #line 31 "epist.l"
 730 yylval = (int) strdup(yytext); return TRUE;
 731         YY_BREAK
 732 case 21:
 733 #line 33 "epist.l"
 734 case 22:
 735 YY_RULE_SETUP
 736 #line 33 "epist.l"
 737 yylval = (int) strdup(yytext); return FALSE;
 738         YY_BREAK
 739 case 23:
 740 YY_RULE_SETUP
 741 #line 34 "epist.l"
 742 yylval = (int) strdup(yytext); return NUMBER;
 743         YY_BREAK
 744 case 24:
 745 YY_RULE_SETUP
 746 #line 35 "epist.l"
 747 yylval = (int) strdup(yytext); return QUOTES;
 748         YY_BREAK
 749 case 25:
 750 YY_RULE_SETUP
 751 #line 36 "epist.l"
 752 yylval = (int) strdup(yytext); return WORD;
 753         YY_BREAK
 754 case 26:
 755 YY_RULE_SETUP
 756 #line 37 "epist.l"
 757 /* ignore */
 758         YY_BREAK
 759 case 27:
 760 YY_RULE_SETUP
 761 #line 38 "epist.l"
 762 /* ignore */
 763         YY_BREAK
 764 case 28:
 765 YY_RULE_SETUP
 766 #line 39 "epist.l"
 767 /* */
 768         YY_BREAK
 769 case 29:
 770 YY_RULE_SETUP
 771 #line 40 "epist.l"
 772 ECHO;
 773         YY_BREAK
 774 #line 775 "lex.yy.c"
 775 case YY_STATE_EOF(INITIAL):
 776         yyterminate();
 777
 778         case YY_END_OF_BUFFER:
 779                 {
 780                 /* Amount of text matched not including the EOB char. */
 781                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
 782
 783                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 784                 *yy_cp = yy_hold_char;
 785                 YY_RESTORE_YY_MORE_OFFSET
 786
 787                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
 788                         {
 789                         /* We're scanning a new file or input source.  It's
 790                          * possible that this happened because the user
 791                          * just pointed yyin at a new source and called
 792                          * yylex().  If so, then we have to assure
 793                          * consistency between yy_current_buffer and our
 794                          * globals.  Here is the right place to do so, because
 795                          * this is the first action (other than possibly a
 796                          * back-up) that will match for the new input source.
 797                          */
 798                         yy_n_chars = yy_current_buffer->yy_n_chars;
 799                         yy_current_buffer->yy_input_file = yyin;
 800                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
 801                         }
 802
 803                 /* Note that here we test for yy_c_buf_p "<=" to the position
 804                  * of the first EOB in the buffer, since yy_c_buf_p will
 805                  * already have been incremented past the NUL character
 806                  * (since all states make transitions on EOB to the
 807                  * end-of-buffer state).  Contrast this with the test
 808                  * in input().
 809                  */
 810                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 811                         { /* This was really a NUL. */
 812                         yy_state_type yy_next_state;
 813
 814                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 815
 816                         yy_current_state = yy_get_previous_state();
 817
 818                         /* Okay, we're now positioned to make the NUL
 819                          * transition.  We couldn't have
 820                          * yy_get_previous_state() go ahead and do it
 821                          * for us because it doesn't know how to deal
 822                          * with the possibility of jamming (and we don't
 823                          * want to build jamming into it because then it
 824                          * will run more slowly).
 825                          */
 826
 827                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 828
 829                         yy_bp = yytext_ptr + YY_MORE_ADJ;
 830
 831                         if ( yy_next_state )
 832                                 {
 833                                 /* Consume the NUL. */
 834                                 yy_cp = ++yy_c_buf_p;
 835                                 yy_current_state = yy_next_state;
 836                                 goto yy_match;
 837                                 }
 838
 839                         else
 840                                 {
 841                                 yy_cp = yy_c_buf_p;
 842                                 goto yy_find_action;
 843                                 }
 844                         }
 845
 846                 else switch ( yy_get_next_buffer() )
 847                         {
 848                         case EOB_ACT_END_OF_FILE:
 849                                 {
 850                                 yy_did_buffer_switch_on_eof = 0;
 851
 852                                 if ( yywrap() )
 853                                         {
 854                                         /* Note: because we've taken care in
 855                                          * yy_get_next_buffer() to have set up
 856                                          * yytext, we can now set up
 857                                          * yy_c_buf_p so that if some total
 858                                          * hoser (like flex itself) wants to
 859                                          * call the scanner after we return the
 860                                          * YY_NULL, it'll still work - another
 861                                          * YY_NULL will get returned.
 862                                          */
 863                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
 864
 865                                         yy_act = YY_STATE_EOF(YY_START);
 866                                         goto do_action;
 867                                         }
 868
 869                                 else
 870                                         {
 871                                         if ( ! yy_did_buffer_switch_on_eof )
 872                                                 YY_NEW_FILE;
 873                                         }
 874                                 break;
 875                                 }
 876
 877                         case EOB_ACT_CONTINUE_SCAN:
 878                                 yy_c_buf_p =
 879                                         yytext_ptr + yy_amount_of_matched_text;
 880
 881                                 yy_current_state = yy_get_previous_state();
 882
 883                                 yy_cp = yy_c_buf_p;
 884                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 885                                 goto yy_match;
 886
 887                         case EOB_ACT_LAST_MATCH:
 888                                 yy_c_buf_p =
 889                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
 890
 891                                 yy_current_state = yy_get_previous_state();
 892
 893                                 yy_cp = yy_c_buf_p;
 894                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 895                                 goto yy_find_action;
 896                         }
 897                 break;
 898                 }
 899
 900         default:
 901                 YY_FATAL_ERROR(
 902                         "fatal flex scanner internal error--no action found" );
 903         } /* end of action switch */
 904                 } /* end of scanning one token */
 905         } /* end of yylex */
 906
 907
 908 /* yy_get_next_buffer - try to read in a new buffer
 909  *
 910  * Returns a code representing an action:
 911  *      EOB_ACT_LAST_MATCH -
 912  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 913  *      EOB_ACT_END_OF_FILE - end of file
 914  */
 915
 916 static int yy_get_next_buffer()
 917         {
 918         register char *dest = yy_current_buffer->yy_ch_buf;
 919         register char *source = yytext_ptr;
 920         register int number_to_move, i;
 921         int ret_val;
 922
 923         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
 924                 YY_FATAL_ERROR(
 925                 "fatal flex scanner internal error--end of buffer missed" );
 926
 927         if ( yy_current_buffer->yy_fill_buffer == 0 )
 928                 { /* Don't try to fill the buffer, so this is an EOF. */
 929                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
 930                         {
 931                         /* We matched a single character, the EOB, so
 932                          * treat this as a final EOF.
 933                          */
 934                         return EOB_ACT_END_OF_FILE;
 935                         }
 936
 937                 else
 938                         {
 939                         /* We matched some text prior to the EOB, first
 940                          * process it.
 941                          */
 942                         return EOB_ACT_LAST_MATCH;
 943                         }
 944                 }
 945
 946         /* Try to read more data. */
 947
 948         /* First move last chars to start of buffer. */
 949         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
 950
 951         for ( i = 0; i < number_to_move; ++i )
 952                 *(dest++) = *(source++);
 953
 954         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
 955                 /* don't do the read, it's not guaranteed to return an EOF,
 956                  * just force an EOF
 957                  */
 958                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
 959
 960         else
 961                 {
 962                 int num_to_read =
 963                         yy_current_buffer->yy_buf_size - number_to_move - 1;
 964
 965                 while ( num_to_read <= 0 )
 966                         { /* Not enough room in the buffer - grow it. */
 967 #ifdef YY_USES_REJECT
 968                         YY_FATAL_ERROR(
 969 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
 970 #else
 971
 972                         /* just a shorter name for the current buffer */
 973                         YY_BUFFER_STATE b = yy_current_buffer;
 974
 975                         int yy_c_buf_p_offset =
 976                                 (int) (yy_c_buf_p - b->yy_ch_buf);
 977
 978                         if ( b->yy_is_our_buffer )
 979                                 {
 980                                 int new_size = b->yy_buf_size * 2;
 981
 982                                 if ( new_size <= 0 )
 983                                         b->yy_buf_size += b->yy_buf_size / 8;
 984                                 else
 985                                         b->yy_buf_size *= 2;
 986
 987                                 b->yy_ch_buf = (char *)
 988                                         /* Include room in for 2 EOB chars. */
 989                                         yy_flex_realloc( (void *) b->yy_ch_buf,
 990                                                          b->yy_buf_size + 2 );
 991                                 }
 992                         else
 993                                 /* Can't grow it, we don't own it. */
 994                                 b->yy_ch_buf = 0;
 995
 996                         if ( ! b->yy_ch_buf )
 997                                 YY_FATAL_ERROR(
 998                                 "fatal error - scanner input buffer overflow" );
 999
1000                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1001
1002                         num_to_read = yy_current_buffer->yy_buf_size -
1003                                                 number_to_move - 1;
1004 #endif
1005                         }
1006
1007                 if ( num_to_read > YY_READ_BUF_SIZE )
1008                         num_to_read = YY_READ_BUF_SIZE;
1009
1010                 /* Read in more data. */
1011                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1012                         yy_n_chars, num_to_read );
1013
1014                 yy_current_buffer->yy_n_chars = yy_n_chars;
1015                 }
1016
1017         if ( yy_n_chars == 0 )
1018                 {
1019                 if ( number_to_move == YY_MORE_ADJ )
1020                         {
1021                         ret_val = EOB_ACT_END_OF_FILE;
1022                         yyrestart( yyin );
1023                         }
1024
1025                 else
1026                         {
1027                         ret_val = EOB_ACT_LAST_MATCH;
1028                         yy_current_buffer->yy_buffer_status =
1029                                 YY_BUFFER_EOF_PENDING;
1030                         }
1031                 }
1032
1033         else
1034                 ret_val = EOB_ACT_CONTINUE_SCAN;
1035
1036         yy_n_chars += number_to_move;
1037         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1038         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1039
1040         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1041
1042         return ret_val;
1043         }
1044
1045
1046 /* yy_get_previous_state - get the state just before the EOB char was reached */
1047
1048 static yy_state_type yy_get_previous_state()
1049         {
1050         register yy_state_type yy_current_state;
1051         register char *yy_cp;
1052
1053         yy_current_state = yy_start;
1054
1055         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1056                 {
1057                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1058                 if ( yy_accept[yy_current_state] )
1059                         {
1060                         yy_last_accepting_state = yy_current_state;
1061                         yy_last_accepting_cpos = yy_cp;
1062                         }
1063                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1064                         {
1065                         yy_current_state = (int) yy_def[yy_current_state];
1066                         if ( yy_current_state >= 93 )
1067                                 yy_c = yy_meta[(unsigned int) yy_c];
1068                         }
1069                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1070                 }
1071
1072         return yy_current_state;
1073         }
1074
1075
1076 /* yy_try_NUL_trans - try to make a transition on the NUL character
1077  *
1078  * synopsis
1079  *      next_state = yy_try_NUL_trans( current_state );
1080  */
1081
1082 #ifdef YY_USE_PROTOS
1083 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1084 #else
1085 static yy_state_type yy_try_NUL_trans( yy_current_state )
1086 yy_state_type yy_current_state;
1087 #endif
1088         {
1089         register int yy_is_jam;
1090         register char *yy_cp = yy_c_buf_p;
1091
1092         register YY_CHAR yy_c = 1;
1093         if ( yy_accept[yy_current_state] )
1094                 {
1095                 yy_last_accepting_state = yy_current_state;
1096                 yy_last_accepting_cpos = yy_cp;
1097                 }
1098         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1099                 {
1100                 yy_current_state = (int) yy_def[yy_current_state];
1101                 if ( yy_current_state >= 93 )
1102                         yy_c = yy_meta[(unsigned int) yy_c];
1103                 }
1104         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1105         yy_is_jam = (yy_current_state == 92);
1106
1107         return yy_is_jam ? 0 : yy_current_state;
1108         }
1109
1110
1111 #ifndef YY_NO_UNPUT
1112 #ifdef YY_USE_PROTOS
1113 static void yyunput( int c, register char *yy_bp )
1114 #else
1115 static void yyunput( c, yy_bp )
1116 int c;
1117 register char *yy_bp;
1118 #endif
1119         {
1120         register char *yy_cp = yy_c_buf_p;
1121
1122         /* undo effects of setting up yytext */
1123         *yy_cp = yy_hold_char;
1124
1125         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1126                 { /* need to shift things up to make room */
1127                 /* +2 for EOB chars. */
1128                 register int number_to_move = yy_n_chars + 2;
1129                 register char *dest = &yy_current_buffer->yy_ch_buf[
1130                                         yy_current_buffer->yy_buf_size + 2];
1131                 register char *source =
1132                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1133
1134                 while ( source > yy_current_buffer->yy_ch_buf )
1135                         *--dest = *--source;
1136
1137                 yy_cp += (int) (dest - source);
1138                 yy_bp += (int) (dest - source);
1139                 yy_current_buffer->yy_n_chars =
1140                         yy_n_chars = yy_current_buffer->yy_buf_size;
1141
1142                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1143                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1144                 }
1145
1146         *--yy_cp = (char) c;
1147
1148
1149         yytext_ptr = yy_bp;
1150         yy_hold_char = *yy_cp;
1151         yy_c_buf_p = yy_cp;
1152         }
1153 #endif  /* ifndef YY_NO_UNPUT */
1154
1155
1156 #ifdef __cplusplus
1157 static int yyinput()
1158 #else
1159 static int input()
1160 #endif
1161         {
1162         int c;
1163
1164         *yy_c_buf_p = yy_hold_char;
1165
1166         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1167                 {
1168                 /* yy_c_buf_p now points to the character we want to return.
1169                  * If this occurs *before* the EOB characters, then it's a
1170                  * valid NUL; if not, then we've hit the end of the buffer.
1171                  */
1172                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1173                         /* This was really a NUL. */
1174                         *yy_c_buf_p = '\0';
1175
1176                 else
1177                         { /* need more input */
1178                         int offset = yy_c_buf_p - yytext_ptr;
1179                         ++yy_c_buf_p;
1180
1181                         switch ( yy_get_next_buffer() )
1182                                 {
1183                                 case EOB_ACT_LAST_MATCH:
1184                                         /* This happens because yy_g_n_b()
1185                                          * sees that we've accumulated a
1186                                          * token and flags that we need to
1187                                          * try matching the token before
1188                                          * proceeding.  But for input(),
1189                                          * there's no matching to consider.
1190                                          * So convert the EOB_ACT_LAST_MATCH
1191                                          * to EOB_ACT_END_OF_FILE.
1192                                          */
1193
1194                                         /* Reset buffer status. */
1195                                         yyrestart( yyin );
1196
1197                                         /* fall through */
1198
1199                                 case EOB_ACT_END_OF_FILE:
1200                                         {
1201                                         if ( yywrap() )
1202                                                 return EOF;
1203
1204                                         if ( ! yy_did_buffer_switch_on_eof )
1205                                                 YY_NEW_FILE;
1206 #ifdef __cplusplus
1207                                         return yyinput();
1208 #else
1209                                         return input();
1210 #endif
1211                                         }
1212
1213                                 case EOB_ACT_CONTINUE_SCAN:
1214                                         yy_c_buf_p = yytext_ptr + offset;
1215                                         break;
1216                                 }
1217                         }
1218                 }
1219
1220         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1221         *yy_c_buf_p = '\0';     /* preserve yytext */
1222         yy_hold_char = *++yy_c_buf_p;
1223
1224
1225         return c;
1226         }
1227
1228
1229 #ifdef YY_USE_PROTOS
1230 void yyrestart( FILE *input_file )
1231 #else
1232 void yyrestart( input_file )
1233 FILE *input_file;
1234 #endif
1235         {
1236         if ( ! yy_current_buffer )
1237                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1238
1239         yy_init_buffer( yy_current_buffer, input_file );
1240         yy_load_buffer_state();
1241         }
1242
1243
1244 #ifdef YY_USE_PROTOS
1245 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1246 #else
1247 void yy_switch_to_buffer( new_buffer )
1248 YY_BUFFER_STATE new_buffer;
1249 #endif
1250         {
1251         if ( yy_current_buffer == new_buffer )
1252                 return;
1253
1254         if ( yy_current_buffer )
1255                 {
1256                 /* Flush out information for old buffer. */
1257                 *yy_c_buf_p = yy_hold_char;
1258                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1259                 yy_current_buffer->yy_n_chars = yy_n_chars;
1260                 }
1261
1262         yy_current_buffer = new_buffer;
1263         yy_load_buffer_state();
1264
1265         /* We don't actually know whether we did this switch during
1266          * EOF (yywrap()) processing, but the only time this flag
1267          * is looked at is after yywrap() is called, so it's safe
1268          * to go ahead and always set it.
1269          */
1270         yy_did_buffer_switch_on_eof = 1;
1271         }
1272
1273
1274 #ifdef YY_USE_PROTOS
1275 void yy_load_buffer_state( void )
1276 #else
1277 void yy_load_buffer_state()
1278 #endif
1279         {
1280         yy_n_chars = yy_current_buffer->yy_n_chars;
1281         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1282         yyin = yy_current_buffer->yy_input_file;
1283         yy_hold_char = *yy_c_buf_p;
1284         }
1285
1286
1287 #ifdef YY_USE_PROTOS
1288 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1289 #else
1290 YY_BUFFER_STATE yy_create_buffer( file, size )
1291 FILE *file;
1292 int size;
1293 #endif
1294         {
1295         YY_BUFFER_STATE b;
1296
1297         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1298         if ( ! b )
1299                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1300
1301         b->yy_buf_size = size;
1302
1303         /* yy_ch_buf has to be 2 characters longer than the size given because
1304          * we need to put in 2 end-of-buffer characters.
1305          */
1306         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1307         if ( ! b->yy_ch_buf )
1308                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1309
1310         b->yy_is_our_buffer = 1;
1311
1312         yy_init_buffer( b, file );
1313
1314         return b;
1315         }
1316
1317
1318 #ifdef YY_USE_PROTOS
1319 void yy_delete_buffer( YY_BUFFER_STATE b )
1320 #else
1321 void yy_delete_buffer( b )
1322 YY_BUFFER_STATE b;
1323 #endif
1324         {
1325         if ( ! b )
1326                 return;
1327
1328         if ( b == yy_current_buffer )
1329                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1330
1331         if ( b->yy_is_our_buffer )
1332                 yy_flex_free( (void *) b->yy_ch_buf );
1333
1334         yy_flex_free( (void *) b );
1335         }
1336
1337
1338 #ifndef YY_ALWAYS_INTERACTIVE
1339 #ifndef YY_NEVER_INTERACTIVE
1340 extern int isatty YY_PROTO(( int ));
1341 #endif
1342 #endif
1343
1344 #ifdef YY_USE_PROTOS
1345 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1346 #else
1347 void yy_init_buffer( b, file )
1348 YY_BUFFER_STATE b;
1349 FILE *file;
1350 #endif
1351
1352
1353         {
1354         yy_flush_buffer( b );
1355
1356         b->yy_input_file = file;
1357         b->yy_fill_buffer = 1;
1358
1359 #if YY_ALWAYS_INTERACTIVE
1360         b->yy_is_interactive = 1;
1361 #else
1362 #if YY_NEVER_INTERACTIVE
1363         b->yy_is_interactive = 0;
1364 #else
1365         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1366 #endif
1367 #endif
1368         }
1369
1370
1371 #ifdef YY_USE_PROTOS
1372 void yy_flush_buffer( YY_BUFFER_STATE b )
1373 #else
1374 void yy_flush_buffer( b )
1375 YY_BUFFER_STATE b;
1376 #endif
1377
1378         {
1379         if ( ! b )
1380                 return;
1381
1382         b->yy_n_chars = 0;
1383
1384         /* We always need two end-of-buffer characters.  The first causes
1385          * a transition to the end-of-buffer state.  The second causes
1386          * a jam in that state.
1387          */
1388         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1389         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1390
1391         b->yy_buf_pos = &b->yy_ch_buf[0];
1392
1393         b->yy_at_bol = 1;
1394         b->yy_buffer_status = YY_BUFFER_NEW;
1395
1396         if ( b == yy_current_buffer )
1397                 yy_load_buffer_state();
1398         }
1399
1400
1401 #ifndef YY_NO_SCAN_BUFFER
1402 #ifdef YY_USE_PROTOS
1403 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1404 #else
1405 YY_BUFFER_STATE yy_scan_buffer( base, size )
1406 char *base;
1407 yy_size_t size;
1408 #endif
1409         {
1410         YY_BUFFER_STATE b;
1411
1412         if ( size < 2 ||
1413              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1414              base[size-1] != YY_END_OF_BUFFER_CHAR )
1415                 /* They forgot to leave room for the EOB's. */
1416                 return 0;
1417
1418         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1419         if ( ! b )
1420                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1421
1422         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1423         b->yy_buf_pos = b->yy_ch_buf = base;
1424         b->yy_is_our_buffer = 0;
1425         b->yy_input_file = 0;
1426         b->yy_n_chars = b->yy_buf_size;
1427         b->yy_is_interactive = 0;
1428         b->yy_at_bol = 1;
1429         b->yy_fill_buffer = 0;
1430         b->yy_buffer_status = YY_BUFFER_NEW;
1431
1432         yy_switch_to_buffer( b );
1433
1434         return b;
1435         }
1436 #endif
1437
1438
1439 #ifndef YY_NO_SCAN_STRING
1440 #ifdef YY_USE_PROTOS
1441 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1442 #else
1443 YY_BUFFER_STATE yy_scan_string( yy_str )
1444 yyconst char *yy_str;
1445 #endif
1446         {
1447         int len;
1448         for ( len = 0; yy_str[len]; ++len )
1449                 ;
1450
1451         return yy_scan_bytes( yy_str, len );
1452         }
1453 #endif
1454
1455
1456 #ifndef YY_NO_SCAN_BYTES
1457 #ifdef YY_USE_PROTOS
1458 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1459 #else
1460 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1461 yyconst char *bytes;
1462 int len;
1463 #endif
1464         {
1465         YY_BUFFER_STATE b;
1466         char *buf;
1467         yy_size_t n;
1468         int i;
1469
1470         /* Get memory for full buffer, including space for trailing EOB's. */
1471         n = len + 2;
1472         buf = (char *) yy_flex_alloc( n );
1473         if ( ! buf )
1474                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1475
1476         for ( i = 0; i < len; ++i )
1477                 buf[i] = bytes[i];
1478
1479         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1480
1481         b = yy_scan_buffer( buf, n );
1482         if ( ! b )
1483                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1484
1485         /* It's okay to grow etc. this buffer, and we should throw it
1486          * away when we're done.
1487          */
1488         b->yy_is_our_buffer = 1;
1489
1490         return b;
1491         }
1492 #endif
1493
1494
1495 #ifndef YY_NO_PUSH_STATE
1496 #ifdef YY_USE_PROTOS
1497 static void yy_push_state( int new_state )
1498 #else
1499 static void yy_push_state( new_state )
1500 int new_state;
1501 #endif
1502         {
1503         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1504                 {
1505                 yy_size_t new_size;
1506
1507                 yy_start_stack_depth += YY_START_STACK_INCR;
1508                 new_size = yy_start_stack_depth * sizeof( int );
1509
1510                 if ( ! yy_start_stack )
1511                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1512
1513                 else
1514                         yy_start_stack = (int *) yy_flex_realloc(
1515                                         (void *) yy_start_stack, new_size );
1516
1517                 if ( ! yy_start_stack )
1518                         YY_FATAL_ERROR(
1519                         "out of memory expanding start-condition stack" );
1520                 }
1521
1522         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1523
1524         BEGIN(new_state);
1525         }
1526 #endif
1527
1528
1529 #ifndef YY_NO_POP_STATE
1530 static void yy_pop_state()
1531         {
1532         if ( --yy_start_stack_ptr < 0 )
1533                 YY_FATAL_ERROR( "start-condition stack underflow" );
1534
1535         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1536         }
1537 #endif
1538
1539
1540 #ifndef YY_NO_TOP_STATE
1541 static int yy_top_state()
1542         {
1543         return yy_start_stack[yy_start_stack_ptr - 1];
1544         }
1545 #endif
1546
1547 #ifndef YY_EXIT_FAILURE
1548 #define YY_EXIT_FAILURE 2
1549 #endif
1550
1551 #ifdef YY_USE_PROTOS
1552 static void yy_fatal_error( yyconst char msg[] )
1553 #else
1554 static void yy_fatal_error( msg )
1555 char msg[];
1556 #endif
1557         {
1558         (void) fprintf( stderr, "%s\n", msg );
1559         exit( YY_EXIT_FAILURE );
1560         }
1561
1562
1563
1564 /* Redefine yyless() so it works in section 3 code. */
1565
1566 #undef yyless
1567 #define yyless(n) \
1568         do \
1569                 { \
1570                 /* Undo effects of setting up yytext. */ \
1571                 yytext[yyleng] = yy_hold_char; \
1572                 yy_c_buf_p = yytext + n; \
1573                 yy_hold_char = *yy_c_buf_p; \
1574                 *yy_c_buf_p = '\0'; \
1575                 yyleng = n; \
1576                 } \
1577         while ( 0 )
1578
1579
1580 /* Internal utility routines. */
1581
1582 #ifndef yytext_ptr
1583 #ifdef YY_USE_PROTOS
1584 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1585 #else
1586 static void yy_flex_strncpy( s1, s2, n )
1587 char *s1;
1588 yyconst char *s2;
1589 int n;
1590 #endif
1591         {
1592         register int i;
1593         for ( i = 0; i < n; ++i )
1594                 s1[i] = s2[i];
1595         }
1596 #endif
1597
1598 #ifdef YY_NEED_STRLEN
1599 #ifdef YY_USE_PROTOS
1600 static int yy_flex_strlen( yyconst char *s )
1601 #else
1602 static int yy_flex_strlen( s )
1603 yyconst char *s;
1604 #endif
1605         {
1606         register int n;
1607         for ( n = 0; s[n]; ++n )
1608                 ;
1609
1610         return n;
1611         }
1612 #endif
1613
1614
1615 #ifdef YY_USE_PROTOS
1616 static void *yy_flex_alloc( yy_size_t size )
1617 #else
1618 static void *yy_flex_alloc( size )
1619 yy_size_t size;
1620 #endif
1621         {
1622         return (void *) malloc( size );
1623         }
1624
1625 #ifdef YY_USE_PROTOS
1626 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1627 #else
1628 static void *yy_flex_realloc( ptr, size )
1629 void *ptr;
1630 yy_size_t size;
1631 #endif
1632         {
1633         /* The cast to (char *) in the following accommodates both
1634          * implementations that use char* generic pointers, and those
1635          * that use void* generic pointers.  It works with the latter
1636          * because both ANSI C and C++ allow castless assignment from
1637          * any pointer type to void*, and deal with argument conversions
1638          * as though doing an assignment.
1639          */
1640         return (void *) realloc( (char *) ptr, size );
1641         }
1642
1643 #ifdef YY_USE_PROTOS
1644 static void yy_flex_free( void *ptr )
1645 #else
1646 static void yy_flex_free( ptr )
1647 void *ptr;
1648 #endif
1649         {
1650         free( ptr );
1651         }
1652
1653 #if YY_MAIN
1654 int main()
1655         {
1656         yylex();
1657         return 0;
1658         }
1659 #endif
1660 #line 40 "epist.l"
1661
1662