1 #define yy_create_buffer kraut_yy_create_buffer
2 #define yy_delete_buffer kraut_yy_delete_buffer
3 #define yy_scan_buffer kraut_yy_scan_buffer
4 #define yy_scan_string kraut_yy_scan_string
5 #define yy_scan_bytes kraut_yy_scan_bytes
6 #define yy_flex_debug kraut_yy_flex_debug
7 #define yy_init_buffer kraut_yy_init_buffer
8 #define yy_flush_buffer kraut_yy_flush_buffer
9 #define yy_load_buffer_state kraut_yy_load_buffer_state
10 #define yy_switch_to_buffer kraut_yy_switch_to_buffer
11 #define yyin kraut_yyin
12 #define yyleng kraut_yyleng
13 #define yylex kraut_yylex
14 #define yyout kraut_yyout
15 #define yyrestart kraut_yyrestart
16 #define yytext kraut_yytext
17
18 #line 19 "kraut.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 65
307 #define YY_END_OF_BUFFER 66
308 static yyconst short int yy_accept[180] =
309 { 0,
310 0, 0, 66, 63, 62, 64, 63, 63, 63, 63,
311 63, 63, 63, 63, 63, 63, 63, 17, 63, 63,
312 51, 53, 63, 63, 63, 63, 63, 63, 63, 63,
313 63, 63, 63, 63, 63, 63, 50, 0, 49, 0,
314 0, 0, 18, 0, 52, 0, 0, 0, 0, 0,
315 0, 48, 0, 0, 0, 0, 0, 38, 0, 0,
316 0, 47, 0, 55, 0, 0, 16, 0, 0, 0,
317 60, 48, 0, 61, 0, 0, 55, 46, 0, 15,
318 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
319 0, 0, 0, 0, 0, 43, 0, 58, 0, 33,
320
321 0, 26, 27, 28, 37, 0, 0, 0, 0, 0,
322 0, 0, 0, 0, 0, 0, 5, 45, 0, 44,
323 29, 31, 30, 32, 0, 36, 42, 0, 0, 0,
324 40, 56, 0, 57, 35, 34, 41, 0, 12, 54,
325 2, 0, 0, 22, 19, 21, 20, 0, 0, 39,
326 7, 10, 8, 9, 11, 0, 23, 25, 24, 0,
327 59, 0, 14, 0, 0, 13, 0, 0, 0, 4,
328 0, 3, 0, 0, 0, 0, 0, 6, 0
329 } ;
330
331 static yyconst int yy_ec[256] =
332 { 0,
333 1, 1, 1, 2, 1, 1, 1, 1, 1, 3,
334 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
335 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
336 1, 4, 5, 1, 1, 1, 1, 1, 1, 6,
337 7, 1, 1, 1, 1, 8, 9, 1, 1, 1,
338 1, 1, 1, 1, 1, 1, 1, 1, 1, 10,
339 1, 11, 12, 1, 13, 14, 15, 16, 17, 18,
340 19, 18, 20, 21, 18, 18, 22, 23, 24, 18,
341 18, 25, 26, 27, 18, 28, 29, 18, 30, 18,
342 31, 1, 32, 1, 1, 1, 33, 34, 35, 36,
343
344 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
345 47, 18, 18, 48, 49, 50, 18, 51, 52, 18,
346 53, 18, 1, 54, 1, 1, 1, 1, 1, 1,
347 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
348 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
350 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
351 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
352 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
353 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
354
355 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
356 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
357 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
358 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
360 1, 1, 1, 1, 1
361 } ;
362
363 static yyconst int yy_meta[55] =
364 { 0,
365 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
366 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
367 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
368 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
369 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
370 2, 2, 2, 1
371 } ;
372
373 static yyconst short int yy_base[182] =
374 { 0,
375 0, 0, 217, 218, 218, 218, 40, 207, 169, 15,
376 174, 180, 163, 164, 16, 163, 20, 218, 20, 169,
377 218, 30, 42, 192, 202, 56, 62, 63, 67, 201,
378 57, 69, 71, 153, 164, 73, 218, 157, 218, 153,
379 154, 45, 218, 160, 158, 161, 188, 185, 159, 150,
380 160, 155, 143, 186, 49, 140, 74, 218, 94, 184,
381 150, 218, 145, 43, 132, 57, 218, 158, 134, 146,
382 218, 218, 136, 218, 141, 175, 137, 218, 133, 218,
383 140, 171, 105, 170, 136, 135, 121, 121, 158, 218,
384 164, 123, 130, 114, 111, 218, 117, 218, 113, 218,
385
386 153, 218, 218, 218, 218, 156, 109, 154, 105, 149,
387 108, 111, 145, 107, 117, 103, 218, 218, 143, 218,
388 218, 218, 218, 218, 120, 218, 218, 142, 105, 122,
389 218, 218, 138, 218, 218, 218, 218, 103, 218, 218,
390 218, 101, 137, 218, 218, 218, 218, 107, 98, 218,
391 218, 218, 218, 218, 218, 134, 218, 218, 218, 84,
392 218, 103, 218, 90, 84, 218, 79, 86, 83, 218,
393 74, 218, 73, 74, 71, 55, 87, 218, 218, 83,
394 155
395 } ;
396
397 static yyconst short int yy_def[182] =
398 { 0,
399 179, 1, 179, 179, 179, 179, 179, 180, 179, 179,
400 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
401 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
402 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
403 179, 179, 179, 179, 179, 179, 180, 181, 179, 179,
404 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
405 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
406 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
407 179, 179, 179, 179, 179, 179, 179, 179, 181, 179,
408 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
409
410 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
411 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
412 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
413 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
414 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
415 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
416 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
417 179, 179, 179, 179, 179, 179, 179, 179, 0, 179,
418 179
419 } ;
420
421 static yyconst short int yy_nxt[273] =
422 { 0,
423 4, 5, 6, 7, 4, 4, 4, 4, 4, 8,
424 4, 4, 9, 10, 11, 4, 4, 4, 12, 13,
425 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
426 24, 4, 25, 26, 27, 28, 25, 25, 29, 30,
427 31, 32, 30, 30, 33, 4, 34, 4, 19, 35,
428 21, 36, 4, 4, 37, 50, 56, 60, 68, 62,
429 71, 74, 51, 57, 63, 61, 71, 71, 58, 65,
430 66, 74, 38, 74, 39, 74, 78, 67, 69, 108,
431 40, 100, 84, 109, 48, 41, 42, 43, 97, 44,
432 85, 45, 46, 178, 98, 73, 50, 102, 103, 53,
433
434 111, 72, 75, 51, 177, 104, 112, 176, 121, 122,
435 145, 146, 123, 79, 147, 55, 124, 175, 57, 174,
436 80, 173, 101, 151, 152, 157, 158, 153, 172, 159,
437 132, 154, 171, 170, 169, 168, 167, 166, 165, 164,
438 163, 162, 161, 160, 156, 155, 150, 149, 148, 144,
439 143, 142, 141, 140, 125, 89, 89, 139, 138, 137,
440 136, 135, 98, 134, 133, 132, 132, 131, 90, 130,
441 129, 128, 127, 126, 120, 119, 111, 109, 118, 117,
442 116, 115, 114, 113, 110, 107, 106, 105, 99, 96,
443 95, 94, 93, 92, 91, 90, 179, 88, 87, 86,
444
445 83, 82, 81, 77, 76, 74, 71, 70, 64, 59,
446 55, 54, 53, 52, 49, 47, 179, 3, 179, 179,
447 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
448 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
449 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
450 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
451 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
452 179, 179
453 } ;
454
455 static yyconst short int yy_chk[273] =
456 { 0,
457 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
458 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
459 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
460 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
461 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
462 1, 1, 1, 1, 7, 10, 15, 17, 23, 19,
463 26, 31, 10, 15, 19, 17, 27, 28, 15, 22,
464 22, 29, 7, 32, 7, 33, 36, 22, 23, 64,
465 7, 57, 42, 64, 180, 7, 7, 7, 55, 7,
466 42, 7, 7, 177, 55, 28, 26, 59, 59, 29,
467
468 66, 27, 31, 26, 176, 59, 66, 175, 83, 83,
469 114, 114, 83, 36, 114, 32, 83, 174, 33, 173,
470 36, 171, 57, 125, 125, 130, 130, 125, 169, 130,
471 168, 125, 167, 165, 164, 162, 160, 156, 149, 148,
472 143, 142, 138, 133, 129, 128, 119, 116, 115, 113,
473 112, 111, 110, 109, 83, 181, 181, 108, 107, 106,
474 101, 99, 97, 95, 94, 93, 92, 91, 89, 88,
475 87, 86, 85, 84, 82, 81, 79, 77, 76, 75,
476 73, 70, 69, 68, 65, 63, 61, 60, 56, 54,
477 53, 52, 51, 50, 49, 48, 47, 46, 45, 44,
478
479 41, 40, 38, 35, 34, 30, 25, 24, 20, 16,
480 14, 13, 12, 11, 9, 8, 3, 179, 179, 179,
481 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
482 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
483 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
484 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
485 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
486 179, 179
487 } ;
488
489 static yy_state_type yy_last_accepting_state;
490 static char *yy_last_accepting_cpos;
491
492 /* The intent behind this definition is that it'll catch
493 * any uses of REJECT which flex missed.
494 */
495 #define REJECT reject_used_but_not_detected
496 #define yymore() yymore_used_but_not_detected
497 #define YY_MORE_ADJ 0
498 #define YY_RESTORE_YY_MORE_OFFSET
499 char *yytext;
500 #line 1 "kraut.l"
501 #define INITIAL 0
502 /* GNU Talkfilters
503 Copyright (C) 1998-2003 Free Software Foundation, Inc.
504
505 This file is part of GNU Talkfilters
506
507 GNU Talkfilters is free software; you can redistribute it and/or
508 modify it under the terms of the GNU General Public License as
509 published by the Free Software Foundation; either version 2, or (at
510 your option) any later version.
511
512 This software is distributed in the hope that it will be amusing, but
513 WITHOUT ANY WARRANTY; without even the implied warranty of
514 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
515 General Public License for more details.
516
517 You should have received a copy of the GNU General Public License
518 along with this software; see the file COPYING. If not, write to the
519 Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
520 */
521 #line 33 "kraut.l"
522
523 #include "common.h"
524 #include "talkfilters.h"
525
526 #define YY_DECL int yylex(gtf_databuf_t *buf)
527
528 #line 529 "kraut.c"
529
530 /* Macros after this point can all be overridden by user definitions in
531 * section 1.
532 */
533
534 #ifndef YY_SKIP_YYWRAP
535 #ifdef __cplusplus
536 extern "C" int yywrap YY_PROTO(( void ));
537 #else
538 extern int yywrap YY_PROTO(( void ));
539 #endif
540 #endif
541
542 #ifndef YY_NO_UNPUT
543 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
544 #endif
545
546 #ifndef yytext_ptr
547 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
548 #endif
549
550 #ifdef YY_NEED_STRLEN
551 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
552 #endif
553
554 #ifndef YY_NO_INPUT
555 #ifdef __cplusplus
556 static int yyinput YY_PROTO(( void ));
557 #else
558 static int input YY_PROTO(( void ));
559 #endif
560 #endif
561
562 #if YY_STACK_USED
563 static int yy_start_stack_ptr = 0;
564 static int yy_start_stack_depth = 0;
565 static int *yy_start_stack = 0;
566 #ifndef YY_NO_PUSH_STATE
567 static void yy_push_state YY_PROTO(( int new_state ));
568 #endif
569 #ifndef YY_NO_POP_STATE
570 static void yy_pop_state YY_PROTO(( void ));
571 #endif
572 #ifndef YY_NO_TOP_STATE
573 static int yy_top_state YY_PROTO(( void ));
574 #endif
575
576 #else
577 #define YY_NO_PUSH_STATE 1
578 #define YY_NO_POP_STATE 1
579 #define YY_NO_TOP_STATE 1
580 #endif
581
582 #ifdef YY_MALLOC_DECL
583 YY_MALLOC_DECL
584 #else
585 #if __STDC__
586 #ifndef __cplusplus
587 #include <stdlib.h>
588 #endif
589 #else
590 /* Just try to get by without declaring the routines. This will fail
591 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
592 * or sizeof(void*) != sizeof(int).
593 */
594 #endif
595 #endif
596
597 /* Amount of stuff to slurp up with each read. */
598 #ifndef YY_READ_BUF_SIZE
599 #define YY_READ_BUF_SIZE 8192
600 #endif
601
602 /* Copy whatever the last rule matched to the standard output. */
603
604 #ifndef ECHO
605 /* This used to be an fputs(), but since the string might contain NUL's,
606 * we now use fwrite().
607 */
608 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
609 #endif
610
611 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
612 * is returned in "result".
613 */
614 #ifndef YY_INPUT
615 #define YY_INPUT(buf,result,max_size) \
616 if ( yy_current_buffer->yy_is_interactive ) \
617 { \
618 int c = '*', n; \
619 for ( n = 0; n < max_size && \
620 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
621 buf[n] = (char) c; \
622 if ( c == '\n' ) \
623 buf[n++] = (char) c; \
624 if ( c == EOF && ferror( yyin ) ) \
625 YY_FATAL_ERROR( "input in flex scanner failed" ); \
626 result = n; \
627 } \
628 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
629 && ferror( yyin ) ) \
630 YY_FATAL_ERROR( "input in flex scanner failed" );
631 #endif
632
633 /* No semi-colon after return; correct usage is to write "yyterminate();" -
634 * we don't want an extra ';' after the "return" because that will cause
635 * some compilers to complain about unreachable statements.
636 */
637 #ifndef yyterminate
638 #define yyterminate() return YY_NULL
639 #endif
640
641 /* Number of entries by which start-condition stack grows. */
642 #ifndef YY_START_STACK_INCR
643 #define YY_START_STACK_INCR 25
644 #endif
645
646 /* Report a fatal error. */
647 #ifndef YY_FATAL_ERROR
648 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
649 #endif
650
651 /* Default declaration of generated scanner - a define so the user can
652 * easily add parameters.
653 */
654 #ifndef YY_DECL
655 #define YY_DECL int yylex YY_PROTO(( void ))
656 #endif
657
658 /* Code executed at the beginning of each rule, after yytext and yyleng
659 * have been set up.
660 */
661 #ifndef YY_USER_ACTION
662 #define YY_USER_ACTION
663 #endif
664
665 /* Code executed at the end of each rule. */
666 #ifndef YY_BREAK
667 #define YY_BREAK break;
668 #endif
669
670 #define YY_RULE_SETUP \
671 YY_USER_ACTION
672
673 YY_DECL
674 {
675 register yy_state_type yy_current_state;
676 register char *yy_cp = NULL, *yy_bp = NULL;
677 register int yy_act;
678
679 #line 45 "kraut.l"
680
681
682 #line 683 "kraut.c"
683
684 if ( yy_init )
685 {
686 yy_init = 0;
687
688 #ifdef YY_USER_INIT
689 YY_USER_INIT;
690 #endif
691
692 if ( ! yy_start )
693 yy_start = 1; /* first start state */
694
695 if ( ! yyin )
696 yyin = stdin;
697
698 if ( ! yyout )
699 yyout = stdout;
700
701 if ( ! yy_current_buffer )
702 yy_current_buffer =
703 yy_create_buffer( yyin, YY_BUF_SIZE );
704
705 yy_load_buffer_state();
706 }
707
708 while ( 1 ) /* loops until end-of-file is reached */
709 {
710 yy_cp = yy_c_buf_p;
711
712 /* Support of yytext. */
713 *yy_cp = yy_hold_char;
714
715 /* yy_bp points to the position in yy_ch_buf of the start of
716 * the current run.
717 */
718 yy_bp = yy_cp;
719
720 yy_current_state = yy_start;
721 yy_match:
722 do
723 {
724 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
725 if ( yy_accept[yy_current_state] )
726 {
727 yy_last_accepting_state = yy_current_state;
728 yy_last_accepting_cpos = yy_cp;
729 }
730 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
731 {
732 yy_current_state = (int) yy_def[yy_current_state];
733 if ( yy_current_state >= 180 )
734 yy_c = yy_meta[(unsigned int) yy_c];
735 }
736 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
737 ++yy_cp;
738 }
739 while ( yy_base[yy_current_state] != 218 );
740
741 yy_find_action:
742 yy_act = yy_accept[yy_current_state];
743 if ( yy_act == 0 )
744 { /* have to back up */
745 yy_cp = yy_last_accepting_cpos;
746 yy_current_state = yy_last_accepting_state;
747 yy_act = yy_accept[yy_current_state];
748 }
749
750 YY_DO_BEFORE_ACTION;
751
752
753 do_action: /* This label is used only to access EOF actions. */
754
755
756 switch ( yy_act )
757 { /* beginning of action switch */
758 case 0: /* must back up */
759 /* undo the effects of YY_DO_BEFORE_ACTION */
760 *yy_cp = yy_hold_char;
761 yy_cp = yy_last_accepting_cpos;
762 yy_current_state = yy_last_accepting_state;
763 goto yy_find_action;
764
765 case 1:
766 YY_RULE_SETUP
767 #line 47 "kraut.l"
768 gtf_echo(); // don't damage HTML tags
769 YY_BREAK
770 case 2:
771 YY_RULE_SETUP
772 #line 49 "kraut.l"
773 gtf_printf("Warum ");
774 YY_BREAK
775 case 3:
776 YY_RULE_SETUP
777 #line 50 "kraut.l"
778 gtf_puts_case("verdammt");
779 YY_BREAK
780 case 4:
781 YY_RULE_SETUP
782 #line 51 "kraut.l"
783 gtf_printf("Gott verdammt");
784 YY_BREAK
785 case 5:
786 YY_RULE_SETUP
787 #line 52 "kraut.l"
788 gtf_printf("inkt");
789 YY_BREAK
790 case 6:
791 YY_RULE_SETUP
792 #line 53 "kraut.l"
793 gtf_printf("Volkswagen");
794 YY_BREAK
795 case 7:
796 YY_RULE_SETUP
797 #line 54 "kraut.l"
798 gtf_printf(" nicht ");
799 YY_BREAK
800 case 8:
801 YY_RULE_SETUP
802 #line 55 "kraut.l"
803 gtf_printf("nicht.");
804 YY_BREAK
805 case 9:
806 YY_RULE_SETUP
807 #line 56 "kraut.l"
808 gtf_printf("nicht?");
809 YY_BREAK
810 case 10:
811 YY_RULE_SETUP
812 #line 57 "kraut.l"
813 gtf_printf("nicht!");
814 YY_BREAK
815 case 11:
816 YY_RULE_SETUP
817 #line 58 "kraut.l"
818 gtf_printf(" ze ");
819 YY_BREAK
820 case 12:
821 YY_RULE_SETUP
822 #line 59 "kraut.l"
823 gtf_printf("Ze ");
824 YY_BREAK
825 case 13:
826 YY_RULE_SETUP
827 #line 60 "kraut.l"
828 gtf_printf(" mit ");
829 YY_BREAK
830 case 14:
831 YY_RULE_SETUP
832 #line 61 "kraut.l"
833 gtf_printf("Mit ");
834 YY_BREAK
835 case 15:
836 YY_RULE_SETUP
837 #line 62 "kraut.l"
838 gtf_printf("w-r-r");
839 YY_BREAK
840 case 16:
841 YY_RULE_SETUP
842 #line 63 "kraut.l"
843 gtf_printf("W-r-r");
844 YY_BREAK
845 case 17:
846 YY_RULE_SETUP
847 #line 64 "kraut.l"
848 gtf_printf("R-r-r");
849 YY_BREAK
850 case 18:
851 YY_RULE_SETUP
852 #line 65 "kraut.l"
853 gtf_printf(" r-r-r");
854 YY_BREAK
855 case 19:
856 YY_RULE_SETUP
857 #line 66 "kraut.l"
858 gtf_printf("Jawohl ");
859 YY_BREAK
860 case 20:
861 YY_RULE_SETUP
862 #line 67 "kraut.l"
863 gtf_printf("Jawohl.");
864 YY_BREAK
865 case 21:
866 YY_RULE_SETUP
867 #line 68 "kraut.l"
868 gtf_printf("Jawohl!");
869 YY_BREAK
870 case 22:
871 YY_RULE_SETUP
872 #line 69 "kraut.l"
873 gtf_printf("JAWOHL!");
874 YY_BREAK
875 case 23:
876 YY_RULE_SETUP
877 #line 70 "kraut.l"
878 gtf_printf(" ja ");
879 YY_BREAK
880 case 24:
881 YY_RULE_SETUP
882 #line 71 "kraut.l"
883 gtf_printf(" ja.");
884 YY_BREAK
885 case 25:
886 YY_RULE_SETUP
887 #line 72 "kraut.l"
888 gtf_printf(" ja!");
889 YY_BREAK
890 case 26:
891 YY_RULE_SETUP
892 #line 73 "kraut.l"
893 gtf_printf("Nein ");
894 YY_BREAK
895 case 27:
896 YY_RULE_SETUP
897 #line 74 "kraut.l"
898 gtf_printf("Nein!");
899 YY_BREAK
900 case 28:
901 YY_RULE_SETUP
902 #line 75 "kraut.l"
903 gtf_printf("Nein?");
904 YY_BREAK
905 case 29:
906 YY_RULE_SETUP
907 #line 76 "kraut.l"
908 gtf_printf(" nein ");
909 YY_BREAK
910 case 30:
911 YY_RULE_SETUP
912 #line 77 "kraut.l"
913 gtf_printf(" nein.");
914 YY_BREAK
915 case 31:
916 YY_RULE_SETUP
917 #line 78 "kraut.l"
918 gtf_printf(" nein!");
919 YY_BREAK
920 case 32:
921 YY_RULE_SETUP
922 #line 79 "kraut.l"
923 gtf_printf(" nein?");
924 YY_BREAK
925 case 33:
926 YY_RULE_SETUP
927 #line 80 "kraut.l"
928 gtf_printf("Herr");
929 YY_BREAK
930 case 34:
931 YY_RULE_SETUP
932 #line 81 "kraut.l"
933 gtf_printf("Frau");
934 YY_BREAK
935 case 35:
936 YY_RULE_SETUP
937 #line 82 "kraut.l"
938 gtf_printf("Fraulein");
939 YY_BREAK
940 case 36:
941 YY_RULE_SETUP
942 #line 83 "kraut.l"
943 gtf_printf(" uff ");
944 YY_BREAK
945 case 37:
946 YY_RULE_SETUP
947 #line 84 "kraut.l"
948 gtf_printf("Uff ");
949 YY_BREAK
950 case 38:
951 YY_RULE_SETUP
952 #line 85 "kraut.l"
953 gtf_puts_case("mein");
954 YY_BREAK
955 case 39:
956 YY_RULE_SETUP
957 #line 86 "kraut.l"
958 gtf_printf(" und ");
959 YY_BREAK
960 case 40:
961 YY_RULE_SETUP
962 #line 87 "kraut.l"
963 gtf_printf("Und ");
964 YY_BREAK
965 case 41:
966 YY_RULE_SETUP
967 #line 88 "kraut.l"
968 gtf_printf("Ein ");
969 YY_BREAK
970 case 42:
971 YY_RULE_SETUP
972 #line 89 "kraut.l"
973 gtf_printf(" ein");
974 YY_BREAK
975 case 43:
976 YY_RULE_SETUP
977 #line 90 "kraut.l"
978 gtf_printf("Ist ");
979 YY_BREAK
980 case 44:
981 YY_RULE_SETUP
982 #line 91 "kraut.l"
983 gtf_printf(" ist ");
984 YY_BREAK
985 case 45:
986 YY_RULE_SETUP
987 #line 92 "kraut.l"
988 gtf_printf("ow ");
989 YY_BREAK
990 case 46:
991 YY_RULE_SETUP
992 #line 93 "kraut.l"
993 gtf_printf("w ");
994 YY_BREAK
995 case 47:
996 YY_RULE_SETUP
997 #line 94 "kraut.l"
998 gtf_puts_case("sch");
999 YY_BREAK
1000 case 48:
1001 YY_RULE_SETUP
1002 #line 95 "kraut.l"
1003 gtf_puts_case("ch");
1004 YY_BREAK
1005 case 49:
1006 YY_RULE_SETUP
1007 #line 96 "kraut.l"
1008 gtf_printf(" k");
1009 YY_BREAK
1010 case 50:
1011 YY_RULE_SETUP
1012 #line 97 "kraut.l"
1013 gtf_printf(" K");
1014 YY_BREAK
1015 case 51:
1016 YY_RULE_SETUP
1017 #line 98 "kraut.l"
1018 gtf_puts_case("f");
1019 YY_BREAK
1020 case 52:
1021 YY_RULE_SETUP
1022 #line 99 "kraut.l"
1023 gtf_printf(" v");
1024 YY_BREAK
1025 case 53:
1026 YY_RULE_SETUP
1027 #line 100 "kraut.l"
1028 gtf_printf("V");
1029 YY_BREAK
1030 case 54:
1031 YY_RULE_SETUP
1032 #line 101 "kraut.l"
1033 gtf_puts_case("das");
1034 YY_BREAK
1035 case 55:
1036 YY_RULE_SETUP
1037 #line 102 "kraut.l"
1038 gtf_puts_case("d");
1039 YY_BREAK
1040 case 56:
1041 YY_RULE_SETUP
1042 #line 103 "kraut.l"
1043 gtf_printf("Wilhelm");
1044 YY_BREAK
1045 case 57:
1046 YY_RULE_SETUP
1047 #line 104 "kraut.l"
1048 gtf_printf("Gerhardt");
1049 YY_BREAK
1050 case 58:
1051 YY_RULE_SETUP
1052 #line 105 "kraut.l"
1053 gtf_printf("Hans");
1054 YY_BREAK
1055 case 59:
1056 YY_RULE_SETUP
1057 #line 106 "kraut.l"
1058 gtf_printf("Schultz");
1059 YY_BREAK
1060 case 60:
1061 YY_RULE_SETUP
1062 #line 107 "kraut.l"
1063 gtf_printf("%s Naturlich!", yytext);
1064 YY_BREAK
1065 case 61:
1066 YY_RULE_SETUP
1067 #line 108 "kraut.l"
1068 gtf_printf("%s Scheisse!", yytext);
1069 YY_BREAK
1070 case 62:
1071 YY_RULE_SETUP
1072 #line 110 "kraut.l"
1073 /* ignore trailing EOT character */
1074 YY_BREAK
1075 case 63:
1076 YY_RULE_SETUP
1077 #line 111 "kraut.l"
1078 gtf_echo();
1079 YY_BREAK
1080 case 64:
1081 YY_RULE_SETUP
1082 #line 112 "kraut.l"
1083 gtf_printf("\n");
1084 YY_BREAK
1085 case 65:
1086 YY_RULE_SETUP
1087 #line 114 "kraut.l"
1088 ECHO;
1089 YY_BREAK
1090 #line 1091 "kraut.c"
1091 case YY_STATE_EOF(INITIAL):
1092 yyterminate();
1093
1094 case YY_END_OF_BUFFER:
1095 {
1096 /* Amount of text matched not including the EOB char. */
1097 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1098
1099 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1100 *yy_cp = yy_hold_char;
1101 YY_RESTORE_YY_MORE_OFFSET
1102
1103 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1104 {
1105 /* We're scanning a new file or input source. It's
1106 * possible that this happened because the user
1107 * just pointed yyin at a new source and called
1108 * yylex(). If so, then we have to assure
1109 * consistency between yy_current_buffer and our
1110 * globals. Here is the right place to do so, because
1111 * this is the first action (other than possibly a
1112 * back-up) that will match for the new input source.
1113 */
1114 yy_n_chars = yy_current_buffer->yy_n_chars;
1115 yy_current_buffer->yy_input_file = yyin;
1116 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1117 }
1118
1119 /* Note that here we test for yy_c_buf_p "<=" to the position
1120 * of the first EOB in the buffer, since yy_c_buf_p will
1121 * already have been incremented past the NUL character
1122 * (since all states make transitions on EOB to the
1123 * end-of-buffer state). Contrast this with the test
1124 * in input().
1125 */
1126 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1127 { /* This was really a NUL. */
1128 yy_state_type yy_next_state;
1129
1130 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1131
1132 yy_current_state = yy_get_previous_state();
1133
1134 /* Okay, we're now positioned to make the NUL
1135 * transition. We couldn't have
1136 * yy_get_previous_state() go ahead and do it
1137 * for us because it doesn't know how to deal
1138 * with the possibility of jamming (and we don't
1139 * want to build jamming into it because then it
1140 * will run more slowly).
1141 */
1142
1143 yy_next_state = yy_try_NUL_trans( yy_current_state );
1144
1145 yy_bp = yytext_ptr + YY_MORE_ADJ;
1146
1147 if ( yy_next_state )
1148 {
1149 /* Consume the NUL. */
1150 yy_cp = ++yy_c_buf_p;
1151 yy_current_state = yy_next_state;
1152 goto yy_match;
1153 }
1154
1155 else
1156 {
1157 yy_cp = yy_c_buf_p;
1158 goto yy_find_action;
1159 }
1160 }
1161
1162 else switch ( yy_get_next_buffer() )
1163 {
1164 case EOB_ACT_END_OF_FILE:
1165 {
1166 yy_did_buffer_switch_on_eof = 0;
1167
1168 if ( yywrap() )
1169 {
1170 /* Note: because we've taken care in
1171 * yy_get_next_buffer() to have set up
1172 * yytext, we can now set up
1173 * yy_c_buf_p so that if some total
1174 * hoser (like flex itself) wants to
1175 * call the scanner after we return the
1176 * YY_NULL, it'll still work - another
1177 * YY_NULL will get returned.
1178 */
1179 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1180
1181 yy_act = YY_STATE_EOF(YY_START);
1182 goto do_action;
1183 }
1184
1185 else
1186 {
1187 if ( ! yy_did_buffer_switch_on_eof )
1188 YY_NEW_FILE;
1189 }
1190 break;
1191 }
1192
1193 case EOB_ACT_CONTINUE_SCAN:
1194 yy_c_buf_p =
1195 yytext_ptr + yy_amount_of_matched_text;
1196
1197 yy_current_state = yy_get_previous_state();
1198
1199 yy_cp = yy_c_buf_p;
1200 yy_bp = yytext_ptr + YY_MORE_ADJ;
1201 goto yy_match;
1202
1203 case EOB_ACT_LAST_MATCH:
1204 yy_c_buf_p =
1205 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1206
1207 yy_current_state = yy_get_previous_state();
1208
1209 yy_cp = yy_c_buf_p;
1210 yy_bp = yytext_ptr + YY_MORE_ADJ;
1211 goto yy_find_action;
1212 }
1213 break;
1214 }
1215
1216 default:
1217 YY_FATAL_ERROR(
1218 "fatal flex scanner internal error--no action found" );
1219 } /* end of action switch */
1220 } /* end of scanning one token */
1221 } /* end of yylex */
1222
1223
1224 /* yy_get_next_buffer - try to read in a new buffer
1225 *
1226 * Returns a code representing an action:
1227 * EOB_ACT_LAST_MATCH -
1228 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1229 * EOB_ACT_END_OF_FILE - end of file
1230 */
1231
yy_get_next_buffer()1232 static int yy_get_next_buffer()
1233 {
1234 register char *dest = yy_current_buffer->yy_ch_buf;
1235 register char *source = yytext_ptr;
1236 register int number_to_move, i;
1237 int ret_val;
1238
1239 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1240 YY_FATAL_ERROR(
1241 "fatal flex scanner internal error--end of buffer missed" );
1242
1243 if ( yy_current_buffer->yy_fill_buffer == 0 )
1244 { /* Don't try to fill the buffer, so this is an EOF. */
1245 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1246 {
1247 /* We matched a single character, the EOB, so
1248 * treat this as a final EOF.
1249 */
1250 return EOB_ACT_END_OF_FILE;
1251 }
1252
1253 else
1254 {
1255 /* We matched some text prior to the EOB, first
1256 * process it.
1257 */
1258 return EOB_ACT_LAST_MATCH;
1259 }
1260 }
1261
1262 /* Try to read more data. */
1263
1264 /* First move last chars to start of buffer. */
1265 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1266
1267 for ( i = 0; i < number_to_move; ++i )
1268 *(dest++) = *(source++);
1269
1270 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1271 /* don't do the read, it's not guaranteed to return an EOF,
1272 * just force an EOF
1273 */
1274 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1275
1276 else
1277 {
1278 int num_to_read =
1279 yy_current_buffer->yy_buf_size - number_to_move - 1;
1280
1281 while ( num_to_read <= 0 )
1282 { /* Not enough room in the buffer - grow it. */
1283 #ifdef YY_USES_REJECT
1284 YY_FATAL_ERROR(
1285 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1286 #else
1287
1288 /* just a shorter name for the current buffer */
1289 YY_BUFFER_STATE b = yy_current_buffer;
1290
1291 int yy_c_buf_p_offset =
1292 (int) (yy_c_buf_p - b->yy_ch_buf);
1293
1294 if ( b->yy_is_our_buffer )
1295 {
1296 int new_size = b->yy_buf_size * 2;
1297
1298 if ( new_size <= 0 )
1299 b->yy_buf_size += b->yy_buf_size / 8;
1300 else
1301 b->yy_buf_size *= 2;
1302
1303 b->yy_ch_buf = (char *)
1304 /* Include room in for 2 EOB chars. */
1305 yy_flex_realloc( (void *) b->yy_ch_buf,
1306 b->yy_buf_size + 2 );
1307 }
1308 else
1309 /* Can't grow it, we don't own it. */
1310 b->yy_ch_buf = 0;
1311
1312 if ( ! b->yy_ch_buf )
1313 YY_FATAL_ERROR(
1314 "fatal error - scanner input buffer overflow" );
1315
1316 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1317
1318 num_to_read = yy_current_buffer->yy_buf_size -
1319 number_to_move - 1;
1320 #endif
1321 }
1322
1323 if ( num_to_read > YY_READ_BUF_SIZE )
1324 num_to_read = YY_READ_BUF_SIZE;
1325
1326 /* Read in more data. */
1327 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1328 yy_n_chars, num_to_read );
1329
1330 yy_current_buffer->yy_n_chars = yy_n_chars;
1331 }
1332
1333 if ( yy_n_chars == 0 )
1334 {
1335 if ( number_to_move == YY_MORE_ADJ )
1336 {
1337 ret_val = EOB_ACT_END_OF_FILE;
1338 yyrestart( yyin );
1339 }
1340
1341 else
1342 {
1343 ret_val = EOB_ACT_LAST_MATCH;
1344 yy_current_buffer->yy_buffer_status =
1345 YY_BUFFER_EOF_PENDING;
1346 }
1347 }
1348
1349 else
1350 ret_val = EOB_ACT_CONTINUE_SCAN;
1351
1352 yy_n_chars += number_to_move;
1353 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1354 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1355
1356 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1357
1358 return ret_val;
1359 }
1360
1361
1362 /* yy_get_previous_state - get the state just before the EOB char was reached */
1363
yy_get_previous_state()1364 static yy_state_type yy_get_previous_state()
1365 {
1366 register yy_state_type yy_current_state;
1367 register char *yy_cp;
1368
1369 yy_current_state = yy_start;
1370
1371 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1372 {
1373 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1374 if ( yy_accept[yy_current_state] )
1375 {
1376 yy_last_accepting_state = yy_current_state;
1377 yy_last_accepting_cpos = yy_cp;
1378 }
1379 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1380 {
1381 yy_current_state = (int) yy_def[yy_current_state];
1382 if ( yy_current_state >= 180 )
1383 yy_c = yy_meta[(unsigned int) yy_c];
1384 }
1385 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1386 }
1387
1388 return yy_current_state;
1389 }
1390
1391
1392 /* yy_try_NUL_trans - try to make a transition on the NUL character
1393 *
1394 * synopsis
1395 * next_state = yy_try_NUL_trans( current_state );
1396 */
1397
1398 #ifdef YY_USE_PROTOS
yy_try_NUL_trans(yy_state_type yy_current_state)1399 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1400 #else
1401 static yy_state_type yy_try_NUL_trans( yy_current_state )
1402 yy_state_type yy_current_state;
1403 #endif
1404 {
1405 register int yy_is_jam;
1406 register char *yy_cp = yy_c_buf_p;
1407
1408 register YY_CHAR yy_c = 1;
1409 if ( yy_accept[yy_current_state] )
1410 {
1411 yy_last_accepting_state = yy_current_state;
1412 yy_last_accepting_cpos = yy_cp;
1413 }
1414 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1415 {
1416 yy_current_state = (int) yy_def[yy_current_state];
1417 if ( yy_current_state >= 180 )
1418 yy_c = yy_meta[(unsigned int) yy_c];
1419 }
1420 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1421 yy_is_jam = (yy_current_state == 179);
1422
1423 return yy_is_jam ? 0 : yy_current_state;
1424 }
1425
1426
1427 #ifndef YY_NO_UNPUT
1428 #ifdef YY_USE_PROTOS
yyunput(int c,register char * yy_bp)1429 static void yyunput( int c, register char *yy_bp )
1430 #else
1431 static void yyunput( c, yy_bp )
1432 int c;
1433 register char *yy_bp;
1434 #endif
1435 {
1436 register char *yy_cp = yy_c_buf_p;
1437
1438 /* undo effects of setting up yytext */
1439 *yy_cp = yy_hold_char;
1440
1441 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1442 { /* need to shift things up to make room */
1443 /* +2 for EOB chars. */
1444 register int number_to_move = yy_n_chars + 2;
1445 register char *dest = &yy_current_buffer->yy_ch_buf[
1446 yy_current_buffer->yy_buf_size + 2];
1447 register char *source =
1448 &yy_current_buffer->yy_ch_buf[number_to_move];
1449
1450 while ( source > yy_current_buffer->yy_ch_buf )
1451 *--dest = *--source;
1452
1453 yy_cp += (int) (dest - source);
1454 yy_bp += (int) (dest - source);
1455 yy_current_buffer->yy_n_chars =
1456 yy_n_chars = yy_current_buffer->yy_buf_size;
1457
1458 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1459 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1460 }
1461
1462 *--yy_cp = (char) c;
1463
1464
1465 yytext_ptr = yy_bp;
1466 yy_hold_char = *yy_cp;
1467 yy_c_buf_p = yy_cp;
1468 }
1469 #endif /* ifndef YY_NO_UNPUT */
1470
1471
1472 #ifndef YY_NO_INPUT
1473 #ifdef __cplusplus
yyinput()1474 static int yyinput()
1475 #else
1476 static int input()
1477 #endif
1478 {
1479 int c;
1480
1481 *yy_c_buf_p = yy_hold_char;
1482
1483 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1484 {
1485 /* yy_c_buf_p now points to the character we want to return.
1486 * If this occurs *before* the EOB characters, then it's a
1487 * valid NUL; if not, then we've hit the end of the buffer.
1488 */
1489 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1490 /* This was really a NUL. */
1491 *yy_c_buf_p = '\0';
1492
1493 else
1494 { /* need more input */
1495 int offset = yy_c_buf_p - yytext_ptr;
1496 ++yy_c_buf_p;
1497
1498 switch ( yy_get_next_buffer() )
1499 {
1500 case EOB_ACT_LAST_MATCH:
1501 /* This happens because yy_g_n_b()
1502 * sees that we've accumulated a
1503 * token and flags that we need to
1504 * try matching the token before
1505 * proceeding. But for input(),
1506 * there's no matching to consider.
1507 * So convert the EOB_ACT_LAST_MATCH
1508 * to EOB_ACT_END_OF_FILE.
1509 */
1510
1511 /* Reset buffer status. */
1512 yyrestart( yyin );
1513
1514 /* fall through */
1515
1516 case EOB_ACT_END_OF_FILE:
1517 {
1518 if ( yywrap() )
1519 return EOF;
1520
1521 if ( ! yy_did_buffer_switch_on_eof )
1522 YY_NEW_FILE;
1523 #ifdef __cplusplus
1524 return yyinput();
1525 #else
1526 return input();
1527 #endif
1528 }
1529
1530 case EOB_ACT_CONTINUE_SCAN:
1531 yy_c_buf_p = yytext_ptr + offset;
1532 break;
1533 }
1534 }
1535 }
1536
1537 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1538 *yy_c_buf_p = '\0'; /* preserve yytext */
1539 yy_hold_char = *++yy_c_buf_p;
1540
1541
1542 return c;
1543 }
1544 #endif /* YY_NO_INPUT */
1545
1546 #ifdef YY_USE_PROTOS
yyrestart(FILE * input_file)1547 void yyrestart( FILE *input_file )
1548 #else
1549 void yyrestart( input_file )
1550 FILE *input_file;
1551 #endif
1552 {
1553 if ( ! yy_current_buffer )
1554 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1555
1556 yy_init_buffer( yy_current_buffer, input_file );
1557 yy_load_buffer_state();
1558 }
1559
1560
1561 #ifdef YY_USE_PROTOS
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)1562 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1563 #else
1564 void yy_switch_to_buffer( new_buffer )
1565 YY_BUFFER_STATE new_buffer;
1566 #endif
1567 {
1568 if ( yy_current_buffer == new_buffer )
1569 return;
1570
1571 if ( yy_current_buffer )
1572 {
1573 /* Flush out information for old buffer. */
1574 *yy_c_buf_p = yy_hold_char;
1575 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1576 yy_current_buffer->yy_n_chars = yy_n_chars;
1577 }
1578
1579 yy_current_buffer = new_buffer;
1580 yy_load_buffer_state();
1581
1582 /* We don't actually know whether we did this switch during
1583 * EOF (yywrap()) processing, but the only time this flag
1584 * is looked at is after yywrap() is called, so it's safe
1585 * to go ahead and always set it.
1586 */
1587 yy_did_buffer_switch_on_eof = 1;
1588 }
1589
1590
1591 #ifdef YY_USE_PROTOS
yy_load_buffer_state(void)1592 void yy_load_buffer_state( void )
1593 #else
1594 void yy_load_buffer_state()
1595 #endif
1596 {
1597 yy_n_chars = yy_current_buffer->yy_n_chars;
1598 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1599 yyin = yy_current_buffer->yy_input_file;
1600 yy_hold_char = *yy_c_buf_p;
1601 }
1602
1603
1604 #ifdef YY_USE_PROTOS
yy_create_buffer(FILE * file,int size)1605 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1606 #else
1607 YY_BUFFER_STATE yy_create_buffer( file, size )
1608 FILE *file;
1609 int size;
1610 #endif
1611 {
1612 YY_BUFFER_STATE b;
1613
1614 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1615 if ( ! b )
1616 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1617
1618 b->yy_buf_size = size;
1619
1620 /* yy_ch_buf has to be 2 characters longer than the size given because
1621 * we need to put in 2 end-of-buffer characters.
1622 */
1623 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1624 if ( ! b->yy_ch_buf )
1625 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1626
1627 b->yy_is_our_buffer = 1;
1628
1629 yy_init_buffer( b, file );
1630
1631 return b;
1632 }
1633
1634
1635 #ifdef YY_USE_PROTOS
yy_delete_buffer(YY_BUFFER_STATE b)1636 void yy_delete_buffer( YY_BUFFER_STATE b )
1637 #else
1638 void yy_delete_buffer( b )
1639 YY_BUFFER_STATE b;
1640 #endif
1641 {
1642 if ( ! b )
1643 return;
1644
1645 if ( b == yy_current_buffer )
1646 yy_current_buffer = (YY_BUFFER_STATE) 0;
1647
1648 if ( b->yy_is_our_buffer )
1649 yy_flex_free( (void *) b->yy_ch_buf );
1650
1651 yy_flex_free( (void *) b );
1652 }
1653
1654
1655
1656 #ifdef YY_USE_PROTOS
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)1657 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1658 #else
1659 void yy_init_buffer( b, file )
1660 YY_BUFFER_STATE b;
1661 FILE *file;
1662 #endif
1663
1664
1665 {
1666 yy_flush_buffer( b );
1667
1668 b->yy_input_file = file;
1669 b->yy_fill_buffer = 1;
1670
1671 #if YY_ALWAYS_INTERACTIVE
1672 b->yy_is_interactive = 1;
1673 #else
1674 #if YY_NEVER_INTERACTIVE
1675 b->yy_is_interactive = 0;
1676 #else
1677 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1678 #endif
1679 #endif
1680 }
1681
1682
1683 #ifdef YY_USE_PROTOS
yy_flush_buffer(YY_BUFFER_STATE b)1684 void yy_flush_buffer( YY_BUFFER_STATE b )
1685 #else
1686 void yy_flush_buffer( b )
1687 YY_BUFFER_STATE b;
1688 #endif
1689
1690 {
1691 if ( ! b )
1692 return;
1693
1694 b->yy_n_chars = 0;
1695
1696 /* We always need two end-of-buffer characters. The first causes
1697 * a transition to the end-of-buffer state. The second causes
1698 * a jam in that state.
1699 */
1700 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1701 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1702
1703 b->yy_buf_pos = &b->yy_ch_buf[0];
1704
1705 b->yy_at_bol = 1;
1706 b->yy_buffer_status = YY_BUFFER_NEW;
1707
1708 if ( b == yy_current_buffer )
1709 yy_load_buffer_state();
1710 }
1711
1712
1713 #ifndef YY_NO_SCAN_BUFFER
1714 #ifdef YY_USE_PROTOS
yy_scan_buffer(char * base,yy_size_t size)1715 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1716 #else
1717 YY_BUFFER_STATE yy_scan_buffer( base, size )
1718 char *base;
1719 yy_size_t size;
1720 #endif
1721 {
1722 YY_BUFFER_STATE b;
1723
1724 if ( size < 2 ||
1725 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1726 base[size-1] != YY_END_OF_BUFFER_CHAR )
1727 /* They forgot to leave room for the EOB's. */
1728 return 0;
1729
1730 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1731 if ( ! b )
1732 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1733
1734 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1735 b->yy_buf_pos = b->yy_ch_buf = base;
1736 b->yy_is_our_buffer = 0;
1737 b->yy_input_file = 0;
1738 b->yy_n_chars = b->yy_buf_size;
1739 b->yy_is_interactive = 0;
1740 b->yy_at_bol = 1;
1741 b->yy_fill_buffer = 0;
1742 b->yy_buffer_status = YY_BUFFER_NEW;
1743
1744 yy_switch_to_buffer( b );
1745
1746 return b;
1747 }
1748 #endif
1749
1750
1751 #ifndef YY_NO_SCAN_STRING
1752 #ifdef YY_USE_PROTOS
yy_scan_string(yyconst char * yy_str)1753 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1754 #else
1755 YY_BUFFER_STATE yy_scan_string( yy_str )
1756 yyconst char *yy_str;
1757 #endif
1758 {
1759 int len;
1760 for ( len = 0; yy_str[len]; ++len )
1761 ;
1762
1763 return yy_scan_bytes( yy_str, len );
1764 }
1765 #endif
1766
1767
1768 #ifndef YY_NO_SCAN_BYTES
1769 #ifdef YY_USE_PROTOS
yy_scan_bytes(yyconst char * bytes,int len)1770 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1771 #else
1772 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1773 yyconst char *bytes;
1774 int len;
1775 #endif
1776 {
1777 YY_BUFFER_STATE b;
1778 char *buf;
1779 yy_size_t n;
1780 int i;
1781
1782 /* Get memory for full buffer, including space for trailing EOB's. */
1783 n = len + 2;
1784 buf = (char *) yy_flex_alloc( n );
1785 if ( ! buf )
1786 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1787
1788 for ( i = 0; i < len; ++i )
1789 buf[i] = bytes[i];
1790
1791 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1792
1793 b = yy_scan_buffer( buf, n );
1794 if ( ! b )
1795 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1796
1797 /* It's okay to grow etc. this buffer, and we should throw it
1798 * away when we're done.
1799 */
1800 b->yy_is_our_buffer = 1;
1801
1802 return b;
1803 }
1804 #endif
1805
1806
1807 #ifndef YY_NO_PUSH_STATE
1808 #ifdef YY_USE_PROTOS
yy_push_state(int new_state)1809 static void yy_push_state( int new_state )
1810 #else
1811 static void yy_push_state( new_state )
1812 int new_state;
1813 #endif
1814 {
1815 if ( yy_start_stack_ptr >= yy_start_stack_depth )
1816 {
1817 yy_size_t new_size;
1818
1819 yy_start_stack_depth += YY_START_STACK_INCR;
1820 new_size = yy_start_stack_depth * sizeof( int );
1821
1822 if ( ! yy_start_stack )
1823 yy_start_stack = (int *) yy_flex_alloc( new_size );
1824
1825 else
1826 yy_start_stack = (int *) yy_flex_realloc(
1827 (void *) yy_start_stack, new_size );
1828
1829 if ( ! yy_start_stack )
1830 YY_FATAL_ERROR(
1831 "out of memory expanding start-condition stack" );
1832 }
1833
1834 yy_start_stack[yy_start_stack_ptr++] = YY_START;
1835
1836 BEGIN(new_state);
1837 }
1838 #endif
1839
1840
1841 #ifndef YY_NO_POP_STATE
yy_pop_state()1842 static void yy_pop_state()
1843 {
1844 if ( --yy_start_stack_ptr < 0 )
1845 YY_FATAL_ERROR( "start-condition stack underflow" );
1846
1847 BEGIN(yy_start_stack[yy_start_stack_ptr]);
1848 }
1849 #endif
1850
1851
1852 #ifndef YY_NO_TOP_STATE
yy_top_state()1853 static int yy_top_state()
1854 {
1855 return yy_start_stack[yy_start_stack_ptr - 1];
1856 }
1857 #endif
1858
1859 #ifndef YY_EXIT_FAILURE
1860 #define YY_EXIT_FAILURE 2
1861 #endif
1862
1863 #ifdef YY_USE_PROTOS
yy_fatal_error(yyconst char msg[])1864 static void yy_fatal_error( yyconst char msg[] )
1865 #else
1866 static void yy_fatal_error( msg )
1867 char msg[];
1868 #endif
1869 {
1870 (void) fprintf( stderr, "%s\n", msg );
1871 exit( YY_EXIT_FAILURE );
1872 }
1873
1874
1875
1876 /* Redefine yyless() so it works in section 3 code. */
1877
1878 #undef yyless
1879 #define yyless(n) \
1880 do \
1881 { \
1882 /* Undo effects of setting up yytext. */ \
1883 yytext[yyleng] = yy_hold_char; \
1884 yy_c_buf_p = yytext + n; \
1885 yy_hold_char = *yy_c_buf_p; \
1886 *yy_c_buf_p = '\0'; \
1887 yyleng = n; \
1888 } \
1889 while ( 0 )
1890
1891
1892 /* Internal utility routines. */
1893
1894 #ifndef yytext_ptr
1895 #ifdef YY_USE_PROTOS
yy_flex_strncpy(char * s1,yyconst char * s2,int n)1896 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1897 #else
1898 static void yy_flex_strncpy( s1, s2, n )
1899 char *s1;
1900 yyconst char *s2;
1901 int n;
1902 #endif
1903 {
1904 register int i;
1905 for ( i = 0; i < n; ++i )
1906 s1[i] = s2[i];
1907 }
1908 #endif
1909
1910 #ifdef YY_NEED_STRLEN
1911 #ifdef YY_USE_PROTOS
yy_flex_strlen(yyconst char * s)1912 static int yy_flex_strlen( yyconst char *s )
1913 #else
1914 static int yy_flex_strlen( s )
1915 yyconst char *s;
1916 #endif
1917 {
1918 register int n;
1919 for ( n = 0; s[n]; ++n )
1920 ;
1921
1922 return n;
1923 }
1924 #endif
1925
1926
1927 #ifdef YY_USE_PROTOS
yy_flex_alloc(yy_size_t size)1928 static void *yy_flex_alloc( yy_size_t size )
1929 #else
1930 static void *yy_flex_alloc( size )
1931 yy_size_t size;
1932 #endif
1933 {
1934 return (void *) malloc( size );
1935 }
1936
1937 #ifdef YY_USE_PROTOS
yy_flex_realloc(void * ptr,yy_size_t size)1938 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1939 #else
1940 static void *yy_flex_realloc( ptr, size )
1941 void *ptr;
1942 yy_size_t size;
1943 #endif
1944 {
1945 /* The cast to (char *) in the following accommodates both
1946 * implementations that use char* generic pointers, and those
1947 * that use void* generic pointers. It works with the latter
1948 * because both ANSI C and C++ allow castless assignment from
1949 * any pointer type to void*, and deal with argument conversions
1950 * as though doing an assignment.
1951 */
1952 return (void *) realloc( (char *) ptr, size );
1953 }
1954
1955 #ifdef YY_USE_PROTOS
yy_flex_free(void * ptr)1956 static void yy_flex_free( void *ptr )
1957 #else
1958 static void yy_flex_free( ptr )
1959 void *ptr;
1960 #endif
1961 {
1962 free( ptr );
1963 }
1964
1965 #if YY_MAIN
main()1966 int main()
1967 {
1968 yylex();
1969 return 0;
1970 }
1971 #endif
1972 #line 114 "kraut.l"
1973
1974
1975 #ifdef LIBRARY_MODE
1976
gtf_filter_kraut(const char * input,char * buf,size_t bufsz)1977 int gtf_filter_kraut(const char *input, char *buf, size_t bufsz)
1978 {
1979 gtf_databuf_t buffer;
1980 YY_BUFFER_STATE _yybuf;
1981
1982 gtf_strbuf_init(&buffer, buf, bufsz);
1983 _yybuf = yy_scan_string(input);
1984 yylex(&buffer);
1985 yy_delete_buffer(_yybuf);
1986 gtf_reset();
1987
1988 return(buffer.overflow);
1989 }
1990
__gtf_filter_kraut(const char * input,char * buf,size_t bufsz)1991 int __gtf_filter_kraut(const char *input, char *buf, size_t bufsz)
1992 {
1993 return(gtf_filter_kraut(input, buf, bufsz));
1994 }
1995
1996 #else /* LIBRARY_MODE */
1997
main(int argc,char ** argv)1998 int main(int argc, char **argv)
1999 {
2000 gtf_parse_args();
2001
2002 yylex(NULL);
2003
2004 return(EXIT_SUCCESS);
2005 }
2006
2007 #endif /* LIBRARY_MODE */
2008
2009 /* end of source file */
2010