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