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