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