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