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