change how the widgets' _dirty flag works so that all inheritence levels of the widge...
[mikachu/openbox.git] / 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