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