HCoop / hcoop / debian / openafs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Import Upstream version 1.8.5
[hcoop/debian/openafs.git] / src / comerr / et_lex.lex_nt.c
CommitLineData
805e021f
CE		 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
99typedef struct yy_buffer_state *YY_BUFFER_STATE;
100
101extern int yyleng;
102extern 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 */
140typedef unsigned int yy_size_t;
141
142
143struct 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
200static 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. */
210static char yy_hold_char;
211
212static int yy_n_chars; /* number of characters read into yy_ch_buf */
213
214
215int yyleng;
216
217/* Points to current character in buffer. */
218static char *yy_c_buf_p = NULL;
219static int yy_init = 1; /* whether we need to initialize */
220static 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 */
225static int yy_did_buffer_switch_on_eof;
226
227void yyrestart YY_PROTO(( FILE *input_file ));
228
229void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
230void yy_load_buffer_state YY_PROTO(( void ));
231YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
232void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
233void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
234void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
235#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
236
237YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
238YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
239YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
240
241static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
242static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
243static 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
265typedef unsigned char YY_CHAR;
266FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
267typedef int yy_state_type;
268#define YY_FLEX_LEX_COMPAT
269extern int yylineno;
270int yylineno = 1;
271extern char yytext[];
272
273
274static yy_state_type yy_get_previous_state YY_PROTO(( void ));
275static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
276static int yy_get_next_buffer YY_PROTO(( void ));
277static 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
295static 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
304static 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
312static 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
344static 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
350static 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
358static 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
366static 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
377static 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
388static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
389static char *yy_full_match;
390static int yy_lp;
391static int yy_more_flag = 0;
392static 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
399char yytext[YYLMAX];
400char *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
410extern "C" int yywrap YY_PROTO(( void ));
411#else
412extern int yywrap YY_PROTO(( void ));
413#endif
414#endif
415
416#ifndef YY_NO_UNPUT
417static void yyunput YY_PROTO(( int c, char *buf_ptr ));
418#endif
419
420#ifndef yytext_ptr
421static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
422#endif
423
424#ifndef YY_NO_INPUT
425#ifdef __cplusplus
426static int yyinput YY_PROTO(( void ));
427#else
428static int input YY_PROTO(( void ));
429#endif
430#endif
431
432#if YY_STACK_USED
433static int yy_start_stack_ptr = 0;
434static int yy_start_stack_depth = 0;
435static int *yy_start_stack = 0;
436#ifndef YY_NO_PUSH_STATE
437static void yy_push_state YY_PROTO(( int new_state ));
438#endif
439#ifndef YY_NO_POP_STATE
440static void yy_pop_state YY_PROTO(( void ));
441#endif
442#ifndef YY_NO_TOP_STATE
443static 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
453YY_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
543YY_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;
598yy_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
614yy_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
642do_action: /* This label is used only to access EOF actions. */
643
644
645 switch ( yy_act )
646 { /* beginning of action switch */
647case 1:
648YY_RULE_SETUP
649#line 5 "et_lex.lex.l"
650return ERROR_TABLE;
651 YY_BREAK
652case 2:
653YY_RULE_SETUP
654#line 6 "et_lex.lex.l"
655return ERROR_TABLE;
656 YY_BREAK
657case 3:
658YY_RULE_SETUP
659#line 7 "et_lex.lex.l"
660return ERROR_CODE_ENTRY;
661 YY_BREAK
662case 4:
663YY_RULE_SETUP
664#line 8 "et_lex.lex.l"
665return ERROR_CODE_ENTRY;
666 YY_BREAK
667case 5:
668YY_RULE_SETUP
669#line 9 "et_lex.lex.l"
670return END;
671 YY_BREAK
672case 6:
673YY_RULE_SETUP
674#line 11 "et_lex.lex.l"
675;
676 YY_BREAK
677case 7:
678YY_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
685case 8:
686YY_RULE_SETUP
687#line 18 "et_lex.lex.l"
688{ yylval.dynstr = strdup((char *)yytext); return STRING; }
689 YY_BREAK
690case 9:
691YY_RULE_SETUP
692#line 20 "et_lex.lex.l"
693;
694 YY_BREAK
695case 10:
696YY_RULE_SETUP
697#line 22 "et_lex.lex.l"
698{ return (*yytext); }
699 YY_BREAK
700case 11:
701YY_RULE_SETUP
702#line 23 "et_lex.lex.l"
703ECHO;
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
845static 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
975static 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
1008static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1009#else
1010static yy_state_type yy_try_NUL_trans( yy_current_state )
1011yy_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
1033static void yyunput( int c, char *yy_bp )
1034#else
1035static void yyunput( c, yy_bp )
1036int c;
1037char *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
1078static int yyinput()
1079#else
1080static 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
1150void yyrestart( FILE *input_file )
1151#else
1152void yyrestart( input_file )
1153FILE *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
1165void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1166#else
1167void yy_switch_to_buffer( new_buffer )
1168YY_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
1195void yy_load_buffer_state( void )
1196#else
1197void 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
1208YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1209#else
1210YY_BUFFER_STATE yy_create_buffer( file, size )
1211FILE *file;
1212int 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
1239void yy_delete_buffer( YY_BUFFER_STATE b )
1240#else
1241void yy_delete_buffer( b )
1242YY_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
1260extern int isatty YY_PROTO(( int ));
1261#endif
1262#endif
1263
1264#ifdef YY_USE_PROTOS
1265void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1266#else
1267void yy_init_buffer( b, file )
1268YY_BUFFER_STATE b;
1269FILE *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
1292void yy_flush_buffer( YY_BUFFER_STATE b )
1293#else
1294void yy_flush_buffer( b )
1295YY_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
1320YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1321#else
1322YY_BUFFER_STATE yy_scan_buffer( base, size )
1323char *base;
1324yy_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
1358YY_BUFFER_STATE yy_scan_string( yyconst char *str )
1359#else
1360YY_BUFFER_STATE yy_scan_string( str )
1361yyconst 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
1375YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1376#else
1377YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1378yyconst char *bytes;
1379int 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
1414static void yy_push_state( int new_state )
1415#else
1416static void yy_push_state( new_state )
1417int 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
1447static 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
1458static 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
1469static void yy_fatal_error( yyconst char msg[] )
1470#else
1471static void yy_fatal_error( msg )
1472char 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
1501static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1502#else
1503static void yy_flex_strncpy( s1, s2, n )
1504char *s1;
1505yyconst char *s2;
1506int 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
1517static void *yy_flex_alloc( yy_size_t size )
1518#else
1519static void *yy_flex_alloc( size )
1520yy_size_t size;
1521#endif
1522 {
1523 return malloc( size );
1524 }
1525
1526#ifdef YY_USE_PROTOS
1527static void *yy_flex_realloc( void *ptr, yy_size_t size )
1528#else
1529static void *yy_flex_realloc( ptr, size )
1530void *ptr;
1531yy_size_t size;
1532#endif
1533 {
1534 return realloc( (char *) ptr, size );
1535 }
1536
1537#ifdef YY_USE_PROTOS
1538static void yy_flex_free( void *ptr )
1539#else
1540static void yy_flex_free( ptr )
1541void *ptr;
1542#endif
1543 {
1544 free( ptr );
1545 }
1546
1547#if YY_MAIN
1548int 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 */
1564int yywrap(void) {
1565 return 1;
1566}
openafs packaging