1 #define yy_create_buffer hyd_create_buffer
2 #define yy_delete_buffer hyd_delete_buffer
3 #define yy_scan_buffer hyd_scan_buffer
4 #define yy_scan_string hyd_scan_string
5 #define yy_scan_bytes hyd_scan_bytes
6 #define yy_flex_debug hyd_flex_debug
7 #define yy_init_buffer hyd_init_buffer
8 #define yy_flush_buffer hyd_flush_buffer
9 #define yy_load_buffer_state hyd_load_buffer_state
10 #define yy_switch_to_buffer hyd_switch_to_buffer
11 #define yyin hydin
12 #define yyleng hydleng
13 #define yylex hydlex
14 #define yyout hydout
15 #define yyrestart hydrestart
16 #define yytext hydtext
17 #define yywrap hydwrap
18
19 /* A lexical scanner generated by flex */
20
21 /* Scanner skeleton version:
22 * $Header: /cvs/root/flex/flex/skel.c,v 1.2 2004/05/07 00:28:17 jkh 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
31
32 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
33 #ifdef c_plusplus
34 #ifndef __cplusplus
35 #define __cplusplus
36 #endif
37 #endif
38
39
40 #ifdef __cplusplus
41
42 #include <stdlib.h>
43 #include <unistd.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 typedef unsigned char YY_CHAR;
283 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
284 typedef int yy_state_type;
285 extern char *yytext;
286 #define yytext_ptr yytext
287
288 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
289 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
290 static int yy_get_next_buffer YY_PROTO(( void ));
291 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
292
293 /* Done after the current pattern has been matched and before the
294 * corresponding action - sets up yytext.
295 */
296 #define YY_DO_BEFORE_ACTION \
297 yytext_ptr = yy_bp; \
298 yyleng = (int) (yy_cp - yy_bp); \
299 yy_hold_char = *yy_cp; \
300 *yy_cp = '\0'; \
301 yy_c_buf_p = yy_cp;
302
303 #define YY_NUM_RULES 88
304 #define YY_END_OF_BUFFER 89
305 static yyconst short int yy_accept[327] =
306 { 0,
307 0, 0, 71, 71, 89, 87, 85, 84, 83, 87,
308 87, 76, 79, 78, 82, 74, 81, 80, 76, 76,
309 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
310 76, 76, 76, 76, 76, 76, 76, 72, 71, 88,
311 0, 0, 86, 76, 0, 74, 76, 76, 76, 76,
312 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
313 76, 76, 76, 76, 76, 76, 76, 62, 24, 59,
314 76, 76, 76, 76, 37, 76, 15, 76, 43, 76,
315 60, 76, 76, 76, 76, 76, 76, 76, 76, 76,
316 76, 76, 76, 76, 76, 76, 76, 76, 42, 76,
317
318 76, 76, 76, 76, 76, 72, 71, 77, 75, 76,
319 76, 76, 2, 76, 76, 76, 76, 76, 76, 76,
320 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
321 76, 27, 76, 76, 76, 76, 76, 76, 76, 76,
322 30, 20, 19, 76, 76, 76, 76, 76, 76, 76,
323 76, 76, 11, 76, 76, 76, 76, 25, 76, 53,
324 76, 76, 76, 54, 26, 76, 76, 61, 0, 35,
325 36, 76, 76, 76, 76, 4, 76, 76, 76, 76,
326 76, 76, 44, 18, 76, 76, 76, 76, 76, 51,
327 55, 76, 76, 76, 31, 58, 38, 76, 76, 7,
328
329 76, 76, 76, 3, 76, 76, 76, 76, 76, 76,
330 76, 76, 76, 76, 76, 65, 76, 76, 76, 0,
331 76, 76, 76, 76, 6, 5, 76, 69, 76, 76,
332 76, 76, 29, 76, 76, 76, 76, 76, 76, 76,
333 76, 76, 76, 76, 21, 76, 8, 76, 28, 76,
334 76, 50, 76, 76, 76, 76, 76, 76, 0, 10,
335 76, 76, 76, 1, 76, 52, 76, 76, 76, 76,
336 76, 76, 76, 76, 67, 76, 41, 76, 76, 13,
337 76, 45, 57, 76, 49, 76, 48, 76, 22, 73,
338 76, 76, 64, 9, 76, 56, 76, 16, 76, 70,
339
340 76, 33, 47, 76, 76, 46, 76, 76, 32, 14,
341 76, 23, 68, 17, 66, 76, 76, 76, 40, 34,
342 63, 76, 39, 76, 12, 0
343 } ;
344
345 static yyconst int yy_ec[256] =
346 { 0,
347 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
348 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
350 1, 4, 1, 5, 6, 7, 1, 1, 1, 8,
351 8, 8, 1, 1, 9, 10, 11, 12, 12, 12,
352 12, 12, 12, 12, 12, 12, 12, 13, 1, 1,
353 14, 1, 1, 1, 15, 15, 15, 15, 15, 15,
354 15, 15, 15, 15, 16, 15, 17, 15, 15, 15,
355 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
356 1, 1, 1, 1, 8, 1, 18, 19, 20, 21,
357
358 22, 23, 24, 25, 26, 15, 27, 28, 29, 30,
359 31, 32, 15, 33, 34, 35, 36, 15, 37, 38,
360 39, 15, 1, 1, 1, 1, 1, 1, 1, 1,
361 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
362 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
363 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
364 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
365 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
366 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
367 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
368
369 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
370 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
371 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
373 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
374 1, 1, 1, 1, 1
375 } ;
376
377 static yyconst int yy_meta[40] =
378 { 0,
379 1, 2, 2, 2, 3, 1, 1, 4, 4, 4,
380 4, 4, 1, 1, 4, 4, 4, 4, 4, 4,
381 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
382 4, 4, 4, 4, 4, 4, 4, 4, 4
383 } ;
384
385 static yyconst short int yy_base[332] =
386 { 0,
387 0, 0, 38, 41, 351, 352, 352, 352, 352, 0,
388 347, 0, 352, 352, 352, 36, 352, 352, 330, 329,
389 29, 29, 25, 38, 26, 36, 321, 44, 47, 34,
390 44, 51, 58, 66, 76, 98, 79, 0, 68, 352,
391 341, 342, 352, 0, 332, 80, 311, 310, 306, 319,
392 309, 308, 302, 306, 304, 303, 311, 76, 312, 300,
393 300, 294, 303, 297, 75, 305, 296, 0, 67, 0,
394 289, 80, 289, 284, 0, 59, 0, 300, 0, 95,
395 0, 295, 286, 285, 286, 286, 281, 278, 278, 294,
396 275, 279, 290, 278, 274, 274, 276, 275, 0, 273,
397
398 270, 280, 267, 264, 276, 0, 117, 352, 113, 263,
399 262, 269, 0, 263, 272, 255, 270, 270, 259, 270,
400 251, 268, 263, 252, 251, 264, 248, 258, 245, 254,
401 248, 0, 244, 247, 252, 251, 245, 236, 236, 246,
402 231, 0, 0, 237, 240, 243, 230, 228, 224, 240,
403 100, 225, 0, 226, 225, 226, 222, 0, 223, 0,
404 222, 231, 222, 0, 0, 229, 224, 0, 237, 0,
405 0, 217, 212, 209, 223, 0, 217, 221, 207, 217,
406 204, 204, 0, 205, 208, 197, 202, 214, 204, 0,
407 0, 196, 198, 200, 0, 0, 0, 208, 197, 0,
408
409 196, 193, 194, 0, 185, 192, 187, 203, 198, 197,
410 198, 194, 177, 189, 186, 0, 191, 194, 182, 116,
411 180, 191, 182, 185, 0, 0, 184, 0, 177, 182,
412 185, 176, 0, 171, 182, 177, 177, 167, 176, 161,
413 161, 163, 155, 161, 0, 161, 0, 156, 0, 167,
414 165, 0, 152, 150, 166, 155, 162, 159, 168, 0,
415 144, 157, 147, 0, 141, 0, 140, 154, 151, 142,
416 141, 148, 151, 129, 0, 140, 0, 140, 147, 0,
417 129, 0, 0, 128, 0, 127, 0, 136, 0, 148,
418 137, 123, 0, 0, 135, 0, 121, 0, 120, 0,
419
420 126, 0, 0, 119, 124, 0, 127, 120, 0, 0,
421 108, 0, 0, 0, 0, 110, 105, 98, 0, 0,
422 0, 68, 0, 43, 0, 352, 135, 139, 143, 50,
423 147
424 } ;
425
426 static yyconst short int yy_def[332] =
427 { 0,
428 326, 1, 327, 327, 326, 326, 326, 326, 326, 328,
429 329, 330, 326, 326, 326, 326, 326, 326, 330, 330,
430 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
431 330, 330, 330, 330, 330, 330, 330, 331, 326, 326,
432 328, 329, 326, 330, 326, 326, 330, 330, 330, 330,
433 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
434 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
435 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
436 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
437 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
438
439 330, 330, 330, 330, 330, 331, 326, 326, 326, 330,
440 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
441 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
442 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
443 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
444 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
445 330, 330, 330, 330, 330, 330, 330, 330, 326, 330,
446 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
447 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
448 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
449
450 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
451 330, 330, 330, 330, 330, 330, 330, 330, 330, 326,
452 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
453 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
454 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
455 330, 330, 330, 330, 330, 330, 330, 330, 326, 330,
456 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
457 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
458 330, 330, 330, 330, 330, 330, 330, 330, 330, 326,
459 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
460
461 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
462 330, 330, 330, 330, 330, 330, 330, 330, 330, 330,
463 330, 330, 330, 330, 330, 0, 326, 326, 326, 326,
464 326
465 } ;
466
467 static yyconst short int yy_nxt[392] =
468 { 0,
469 6, 7, 8, 9, 10, 11, 12, 6, 13, 14,
470 15, 16, 17, 18, 12, 19, 20, 21, 22, 23,
471 24, 25, 26, 27, 12, 28, 12, 29, 30, 31,
472 32, 33, 34, 35, 36, 37, 12, 12, 12, 39,
473 40, 39, 39, 40, 39, 45, 52, 46, 49, 50,
474 53, 74, 56, 44, 54, 62, 55, 57, 51, 58,
475 63, 64, 59, 67, 71, 76, 68, 75, 65, 107,
476 60, 107, 72, 69, 77, 70, 61, 73, 78, 83,
477 79, 325, 80, 86, 81, 82, 134, 87, 84, 45,
478 85, 46, 130, 141, 121, 142, 88, 89, 122, 101,
479
480 90, 135, 324, 123, 102, 131, 91, 92, 103, 137,
481 104, 93, 105, 138, 94, 95, 144, 96, 107, 97,
482 107, 207, 169, 98, 109, 259, 323, 220, 99, 145,
483 322, 321, 320, 100, 208, 38, 38, 38, 38, 41,
484 41, 319, 41, 42, 42, 42, 42, 106, 318, 106,
485 106, 317, 316, 315, 314, 313, 312, 311, 310, 290,
486 309, 308, 307, 306, 305, 304, 303, 302, 301, 300,
487 299, 298, 297, 296, 295, 294, 293, 292, 291, 290,
488 289, 288, 287, 286, 285, 284, 283, 282, 281, 280,
489 279, 278, 277, 276, 275, 274, 273, 272, 271, 270,
490
491 269, 268, 267, 266, 265, 264, 263, 262, 261, 260,
492 258, 257, 256, 255, 254, 253, 252, 251, 250, 249,
493 248, 247, 246, 245, 244, 243, 242, 241, 240, 239,
494 238, 237, 236, 235, 234, 233, 232, 231, 230, 229,
495 228, 227, 226, 225, 224, 223, 222, 221, 220, 219,
496 218, 217, 216, 215, 214, 213, 212, 211, 210, 209,
497 206, 205, 204, 203, 202, 201, 200, 199, 198, 197,
498 196, 195, 194, 193, 192, 191, 190, 189, 188, 187,
499 186, 185, 184, 183, 182, 181, 180, 179, 178, 177,
500 176, 175, 174, 173, 172, 171, 170, 168, 167, 166,
501
502 165, 164, 163, 162, 161, 160, 159, 158, 157, 156,
503 155, 154, 153, 152, 151, 150, 149, 148, 147, 146,
504 143, 140, 139, 136, 133, 132, 129, 128, 127, 126,
505 125, 124, 120, 119, 118, 117, 116, 115, 114, 113,
506 112, 111, 110, 109, 43, 108, 66, 48, 47, 43,
507 326, 5, 326, 326, 326, 326, 326, 326, 326, 326,
508 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
509 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
510 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
511 326
512
513 } ;
514
515 static yyconst short int yy_chk[392] =
516 { 0,
517 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
518 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
519 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
520 1, 1, 1, 1, 1, 1, 1, 1, 1, 3,
521 3, 3, 4, 4, 4, 16, 22, 16, 21, 21,
522 22, 30, 23, 330, 22, 25, 22, 23, 21, 24,
523 25, 26, 24, 28, 29, 31, 28, 30, 26, 39,
524 24, 39, 29, 28, 31, 28, 24, 29, 32, 33,
525 32, 324, 32, 34, 32, 32, 69, 34, 33, 46,
526 33, 46, 65, 76, 58, 76, 34, 35, 58, 37,
527
528 35, 69, 322, 58, 37, 65, 35, 35, 37, 72,
529 37, 35, 37, 72, 35, 36, 80, 36, 107, 36,
530 107, 151, 109, 36, 109, 220, 318, 220, 36, 80,
531 317, 316, 311, 36, 151, 327, 327, 327, 327, 328,
532 328, 308, 328, 329, 329, 329, 329, 331, 307, 331,
533 331, 305, 304, 301, 299, 297, 295, 292, 291, 290,
534 288, 286, 284, 281, 279, 278, 276, 274, 273, 272,
535 271, 270, 269, 268, 267, 265, 263, 262, 261, 259,
536 258, 257, 256, 255, 254, 253, 251, 250, 248, 246,
537 244, 243, 242, 241, 240, 239, 238, 237, 236, 235,
538
539 234, 232, 231, 230, 229, 227, 224, 223, 222, 221,
540 219, 218, 217, 215, 214, 213, 212, 211, 210, 209,
541 208, 207, 206, 205, 203, 202, 201, 199, 198, 194,
542 193, 192, 189, 188, 187, 186, 185, 184, 182, 181,
543 180, 179, 178, 177, 175, 174, 173, 172, 169, 167,
544 166, 163, 162, 161, 159, 157, 156, 155, 154, 152,
545 150, 149, 148, 147, 146, 145, 144, 141, 140, 139,
546 138, 137, 136, 135, 134, 133, 131, 130, 129, 128,
547 127, 126, 125, 124, 123, 122, 121, 120, 119, 118,
548 117, 116, 115, 114, 112, 111, 110, 105, 104, 103,
549
550 102, 101, 100, 98, 97, 96, 95, 94, 93, 92,
551 91, 90, 89, 88, 87, 86, 85, 84, 83, 82,
552 78, 74, 73, 71, 67, 66, 64, 63, 62, 61,
553 60, 59, 57, 56, 55, 54, 53, 52, 51, 50,
554 49, 48, 47, 45, 42, 41, 27, 20, 19, 11,
555 5, 326, 326, 326, 326, 326, 326, 326, 326, 326,
556 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
557 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
558 326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
559 326
560
561 } ;
562
563 static yy_state_type yy_last_accepting_state;
564 static char *yy_last_accepting_cpos;
565
566 /* The intent behind this definition is that it'll catch
567 * any uses of REJECT which flex missed.
568 */
569 #define REJECT reject_used_but_not_detected
570 #define yymore() yymore_used_but_not_detected
571 #define YY_MORE_ADJ 0
572 #define YY_RESTORE_YY_MORE_OFFSET
573 char *yytext;
574 #line 1 "lex.l"
575 #define INITIAL 0
576 /*
577 * Copyright (c) 2002, 2003, 2004 Niels Provos <provos@citi.umich.edu>
578 * All rights reserved.
579 *
580 * This program is free software; you can redistribute it and/or modify
581 * it under the terms of the GNU General Public License as published by
582 * the Free Software Foundation; either version 2 of the License, or
583 * (at your option) any later version.
584 *
585 * This program is distributed in the hope that it will be useful,
586 * but WITHOUT ANY WARRANTY; without even the implied warranty of
587 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
588 * GNU General Public License for more details.
589 *
590 * You should have received a copy of the GNU General Public License
591 * along with this program; if not, write to the Free Software
592 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
593 * This program is free software; you can redistribute it and/or modify
594 * it under the terms of the GNU General Public License as published by
595 * the Free Software Foundation; either version 2 of the License, or
596 * (at your option) any later version.
597 *
598 * This program is distributed in the hope that it will be useful,
599 * but WITHOUT ANY WARRANTY; without even the implied warranty of
600 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
601 * GNU General Public License for more details.
602 *
603 * You should have received a copy of the GNU General Public License
604 * along with this program; if not, write to the Free Software
605 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
606 */
607 #define incl 1
608
609 #line 10 "lex.l"
610 #include <sys/types.h>
611 #include <sys/tree.h>
612
613 #include "config.h"
614
615 #include <sys/queue.h>
616 #include <sys/socket.h>
617 #ifdef HAVE_SYS_TIME_H
618 #include <sys/time.h>
619 #endif
620
621 #include <stdio.h>
622 #include <stdlib.h>
623 #include <err.h>
624 #include <stdarg.h>
625 #include <string.h>
626 #ifdef HAVE_TIME_H
627 #include <time.h>
628 #endif
629
630 #include <dnet.h>
631
632 #include <event.h>
633
634 #include "honeyd.h"
635 #include "router.h"
636 #include "personality.h"
637 #include "plugins_config.h"
638 #include "condition.h"
639 #include "parse.h"
640
641 int hyderror(char *fmt, ...);
642 #define yyerror hyderror
643
644 extern int lineno;
645 extern char *filename;
646 extern int curtype;
647
648 #define MAX_INCLUDE_DEPTH 10
649
650 YY_BUFFER_STATE includes[MAX_INCLUDE_DEPTH];
651 int linenos[MAX_INCLUDE_DEPTH];
652 char *filenames[MAX_INCLUDE_DEPTH];
653 int includes_index = 0;
654
655 #line 631 "lex.c"
656
657 /* Macros after this point can all be overridden by user definitions in
658 * section 1.
659 */
660
661 #ifndef YY_SKIP_YYWRAP
662 #ifdef __cplusplus
663 extern "C" int yywrap YY_PROTO(( void ));
664 #else
665 extern int yywrap YY_PROTO(( void ));
666 #endif
667 #endif
668
669 #ifndef YY_NO_UNPUT
670 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
671 #endif
672
673 #ifndef yytext_ptr
674 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
675 #endif
676
677 #ifdef YY_NEED_STRLEN
678 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
679 #endif
680
681 #ifndef YY_NO_INPUT
682 #ifdef __cplusplus
683 static int yyinput YY_PROTO(( void ));
684 #else
685 static int input YY_PROTO(( void ));
686 #endif
687 #endif
688
689 #if YY_STACK_USED
690 static int yy_start_stack_ptr = 0;
691 static int yy_start_stack_depth = 0;
692 static int *yy_start_stack = 0;
693 #ifndef YY_NO_PUSH_STATE
694 static void yy_push_state YY_PROTO(( int new_state ));
695 #endif
696 #ifndef YY_NO_POP_STATE
697 static void yy_pop_state YY_PROTO(( void ));
698 #endif
699 #ifndef YY_NO_TOP_STATE
700 static int yy_top_state YY_PROTO(( void ));
701 #endif
702
703 #else
704 #define YY_NO_PUSH_STATE 1
705 #define YY_NO_POP_STATE 1
706 #define YY_NO_TOP_STATE 1
707 #endif
708
709 #ifdef YY_MALLOC_DECL
710 YY_MALLOC_DECL
711 #else
712 #if __STDC__
713 #ifndef __cplusplus
714 #include <stdlib.h>
715 #endif
716 #else
717 /* Just try to get by without declaring the routines. This will fail
718 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
719 * or sizeof(void*) != sizeof(int).
720 */
721 #endif
722 #endif
723
724 /* Amount of stuff to slurp up with each read. */
725 #ifndef YY_READ_BUF_SIZE
726 #define YY_READ_BUF_SIZE 8192
727 #endif
728
729 /* Copy whatever the last rule matched to the standard output. */
730
731 #ifndef ECHO
732 /* This used to be an fputs(), but since the string might contain NUL's,
733 * we now use fwrite().
734 */
735 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
736 #endif
737
738 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
739 * is returned in "result".
740 */
741 #ifndef YY_INPUT
742 #define YY_INPUT(buf,result,max_size) \
743 if ( yy_current_buffer->yy_is_interactive ) \
744 { \
745 int c = '*', n; \
746 for ( n = 0; n < max_size && \
747 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
748 buf[n] = (char) c; \
749 if ( c == '\n' ) \
750 buf[n++] = (char) c; \
751 if ( c == EOF && ferror( yyin ) ) \
752 YY_FATAL_ERROR( "input in flex scanner failed" ); \
753 result = n; \
754 } \
755 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
756 && ferror( yyin ) ) \
757 YY_FATAL_ERROR( "input in flex scanner failed" );
758 #endif
759
760 /* No semi-colon after return; correct usage is to write "yyterminate();" -
761 * we don't want an extra ';' after the "return" because that will cause
762 * some compilers to complain about unreachable statements.
763 */
764 #ifndef yyterminate
765 #define yyterminate() return YY_NULL
766 #endif
767
768 /* Number of entries by which start-condition stack grows. */
769 #ifndef YY_START_STACK_INCR
770 #define YY_START_STACK_INCR 25
771 #endif
772
773 /* Report a fatal error. */
774 #ifndef YY_FATAL_ERROR
775 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
776 #endif
777
778 /* Default declaration of generated scanner - a define so the user can
779 * easily add parameters.
780 */
781 #ifndef YY_DECL
782 #define YY_DECL int yylex YY_PROTO(( void ))
783 #endif
784
785 /* Code executed at the beginning of each rule, after yytext and yyleng
786 * have been set up.
787 */
788 #ifndef YY_USER_ACTION
789 #define YY_USER_ACTION
790 #endif
791
792 /* Code executed at the end of each rule. */
793 #ifndef YY_BREAK
794 #define YY_BREAK break;
795 #endif
796
797 #define YY_RULE_SETUP \
798 YY_USER_ACTION
799
800 YY_DECL
801 {
802 register yy_state_type yy_current_state;
803 register char *yy_cp, *yy_bp;
804 register int yy_act;
805
806 #line 57 "lex.l"
807
808 #line 784 "lex.c"
809
810 if ( yy_init )
811 {
812 yy_init = 0;
813
814 #ifdef YY_USER_INIT
815 YY_USER_INIT;
816 #endif
817
818 if ( ! yy_start )
819 yy_start = 1; /* first start state */
820
821 if ( ! yyin )
822 yyin = stdin;
823
824 if ( ! yyout )
825 yyout = stdout;
826
827 if ( ! yy_current_buffer )
828 yy_current_buffer =
829 yy_create_buffer( yyin, YY_BUF_SIZE );
830
831 yy_load_buffer_state();
832 }
833
834 while ( 1 ) /* loops until end-of-file is reached */
835 {
836 yy_cp = yy_c_buf_p;
837
838 /* Support of yytext. */
839 *yy_cp = yy_hold_char;
840
841 /* yy_bp points to the position in yy_ch_buf of the start of
842 * the current run.
843 */
844 yy_bp = yy_cp;
845
846 yy_current_state = yy_start;
847 yy_match:
848 do
849 {
850 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
851 if ( yy_accept[yy_current_state] )
852 {
853 yy_last_accepting_state = yy_current_state;
854 yy_last_accepting_cpos = yy_cp;
855 }
856 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
857 {
858 yy_current_state = (int) yy_def[yy_current_state];
859 if ( yy_current_state >= 327 )
860 yy_c = yy_meta[(unsigned int) yy_c];
861 }
862 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
863 ++yy_cp;
864 }
865 while ( yy_base[yy_current_state] != 352 );
866
867 yy_find_action:
868 yy_act = yy_accept[yy_current_state];
869 if ( yy_act == 0 )
870 { /* have to back up */
871 yy_cp = yy_last_accepting_cpos;
872 yy_current_state = yy_last_accepting_state;
873 yy_act = yy_accept[yy_current_state];
874 }
875
876 YY_DO_BEFORE_ACTION;
877
878
879 do_action: /* This label is used only to access EOF actions. */
880
881
882 switch ( yy_act )
883 { /* beginning of action switch */
884 case 0: /* must back up */
885 /* undo the effects of YY_DO_BEFORE_ACTION */
886 *yy_cp = yy_hold_char;
887 yy_cp = yy_last_accepting_cpos;
888 yy_current_state = yy_last_accepting_state;
889 goto yy_find_action;
890
891 case 1:
892 YY_RULE_SETUP
893 #line 58 "lex.l"
894 { return CREATE; }
895 YY_BREAK
896 case 2:
897 YY_RULE_SETUP
898 #line 59 "lex.l"
899 { return ADD; }
900 YY_BREAK
901 case 3:
902 YY_RULE_SETUP
903 #line 60 "lex.l"
904 { return PORT; }
905 YY_BREAK
906 case 4:
907 YY_RULE_SETUP
908 #line 61 "lex.l"
909 { return BIND; }
910 YY_BREAK
911 case 5:
912 YY_RULE_SETUP
913 #line 62 "lex.l"
914 { return CLONE; }
915 YY_BREAK
916 case 6:
917 YY_RULE_SETUP
918 #line 63 "lex.l"
919 { return BLOCK; }
920 YY_BREAK
921 case 7:
922 YY_RULE_SETUP
923 #line 64 "lex.l"
924 { return OPEN; }
925 YY_BREAK
926 case 8:
927 YY_RULE_SETUP
928 #line 65 "lex.l"
929 { return RESET; }
930 YY_BREAK
931 case 9:
932 YY_RULE_SETUP
933 #line 66 "lex.l"
934 { return DEFAULT; }
935 YY_BREAK
936 case 10:
937 YY_RULE_SETUP
938 #line 67 "lex.l"
939 { return ACTION; }
940 YY_BREAK
941 case 11:
942 YY_RULE_SETUP
943 #line 68 "lex.l"
944 { return SET; }
945 YY_BREAK
946 case 12:
947 YY_RULE_SETUP
948 #line 69 "lex.l"
949 { return PERSONALITY; }
950 YY_BREAK
951 case 13:
952 YY_RULE_SETUP
953 #line 70 "lex.l"
954 { return RANDOM; }
955 YY_BREAK
956 case 14:
957 YY_RULE_SETUP
958 #line 71 "lex.l"
959 { return ANNOTATE; }
960 YY_BREAK
961 case 15:
962 YY_RULE_SETUP
963 #line 72 "lex.l"
964 { return NO; }
965 YY_BREAK
966 case 16:
967 YY_RULE_SETUP
968 #line 73 "lex.l"
969 { return FINSCAN; }
970 YY_BREAK
971 case 17:
972 YY_RULE_SETUP
973 #line 74 "lex.l"
974 { return FRAGMENT; }
975 YY_BREAK
976 case 18:
977 YY_RULE_SETUP
978 #line 75 "lex.l"
979 { return DROP; }
980 YY_BREAK
981 case 19:
982 YY_RULE_SETUP
983 #line 76 "lex.l"
984 { return OLD; }
985 YY_BREAK
986 case 20:
987 YY_RULE_SETUP
988 #line 77 "lex.l"
989 { return NEW; }
990 YY_BREAK
991 case 21:
992 YY_RULE_SETUP
993 #line 78 "lex.l"
994 { return PROXY; }
995 YY_BREAK
996 case 22:
997 YY_RULE_SETUP
998 #line 79 "lex.l"
999 { return UPTIME; }
1000 YY_BREAK
1001 case 23:
1002 YY_RULE_SETUP
1003 #line 80 "lex.l"
1004 { return DROPRATE; }
1005 YY_BREAK
1006 case 24:
1007 YY_RULE_SETUP
1008 #line 81 "lex.l"
1009 { return IN; }
1010 YY_BREAK
1011 case 25:
1012 YY_RULE_SETUP
1013 #line 82 "lex.l"
1014 { return SYN; }
1015 YY_BREAK
1016 case 26:
1017 YY_RULE_SETUP
1018 #line 83 "lex.l"
1019 { return UID; }
1020 YY_BREAK
1021 case 27:
1022 YY_RULE_SETUP
1023 #line 84 "lex.l"
1024 { return GID; }
1025 YY_BREAK
1026 case 28:
1027 YY_RULE_SETUP
1028 #line 85 "lex.l"
1029 { return ROUTE; }
1030 YY_BREAK
1031 case 29:
1032 YY_RULE_SETUP
1033 #line 86 "lex.l"
1034 { return ENTRY; }
1035 YY_BREAK
1036 case 30:
1037 YY_RULE_SETUP
1038 #line 87 "lex.l"
1039 { return NET; }
1040 YY_BREAK
1041 case 31:
1042 YY_RULE_SETUP
1043 #line 88 "lex.l"
1044 { return LINK; }
1045 YY_BREAK
1046 case 32:
1047 YY_RULE_SETUP
1048 #line 89 "lex.l"
1049 { return UNREACH; }
1050 YY_BREAK
1051 case 33:
1052 YY_RULE_SETUP
1053 #line 90 "lex.l"
1054 { return LATENCY; }
1055 YY_BREAK
1056 case 34:
1057 YY_RULE_SETUP
1058 #line 91 "lex.l"
1059 { return BANDWIDTH; }
1060 YY_BREAK
1061 case 35:
1062 YY_RULE_SETUP
1063 #line 92 "lex.l"
1064 { yylval.number = 1000; return NUMBER; }
1065 YY_BREAK
1066 case 36:
1067 YY_RULE_SETUP
1068 #line 93 "lex.l"
1069 { yylval.number = 1000000; return NUMBER; }
1070 YY_BREAK
1071 case 37:
1072 YY_RULE_SETUP
1073 #line 94 "lex.l"
1074 { return MS; }
1075 YY_BREAK
1076 case 38:
1077 YY_RULE_SETUP
1078 #line 95 "lex.l"
1079 { return LOSS; }
1080 YY_BREAK
1081 case 39:
1082 YY_RULE_SETUP
1083 #line 96 "lex.l"
1084 { return SUBSYSTEM; }
1085 YY_BREAK
1086 case 40:
1087 YY_RULE_SETUP
1088 #line 97 "lex.l"
1089 { return TEMPLATE; }
1090 YY_BREAK
1091 case 41:
1092 YY_RULE_SETUP
1093 #line 98 "lex.l"
1094 { return OPTION; }
1095 YY_BREAK
1096 case 42:
1097 YY_RULE_SETUP
1098 #line 99 "lex.l"
1099 { return TO; }
1100 YY_BREAK
1101 case 43:
1102 YY_RULE_SETUP
1103 #line 100 "lex.l"
1104 { return ON; }
1105 YY_BREAK
1106 case 44:
1107 YY_RULE_SETUP
1108 #line 101 "lex.l"
1109 { return DHCP; }
1110 YY_BREAK
1111 case 45:
1112 YY_RULE_SETUP
1113 #line 102 "lex.l"
1114 { return SHARED; }
1115 YY_BREAK
1116 case 46:
1117 YY_RULE_SETUP
1118 #line 103 "lex.l"
1119 { return RESTART; }
1120 YY_BREAK
1121 case 47:
1122 YY_RULE_SETUP
1123 #line 104 "lex.l"
1124 { return NETWORK; }
1125 YY_BREAK
1126 case 48:
1127 YY_RULE_SETUP
1128 #line 105 "lex.l"
1129 { return TUNNEL; }
1130 YY_BREAK
1131 case 49:
1132 YY_RULE_SETUP
1133 #line 106 "lex.l"
1134 { return TARPIT; }
1135 YY_BREAK
1136 case 50:
1137 YY_RULE_SETUP
1138 #line 107 "lex.l"
1139 { return SPOOF; }
1140 YY_BREAK
1141 case 51:
1142 YY_RULE_SETUP
1143 #line 108 "lex.l"
1144 { return FROM; }
1145 YY_BREAK
1146 case 52:
1147 YY_RULE_SETUP
1148 #line 109 "lex.l"
1149 { return DELETE; }
1150 YY_BREAK
1151 case 53:
1152 YY_RULE_SETUP
1153 #line 110 "lex.l"
1154 { yylval.number = IP_PROTO_TCP;
1155 curtype = SOCK_STREAM; return PROTO; }
1156 YY_BREAK
1157 case 54:
1158 YY_RULE_SETUP
1159 #line 112 "lex.l"
1160 { yylval.number = IP_PROTO_UDP;
1161 curtype = SOCK_DGRAM; return PROTO; }
1162 YY_BREAK
1163 case 55:
1164 YY_RULE_SETUP
1165 #line 114 "lex.l"
1166 { yylval.number = IP_PROTO_ICMP; return PROTO; }
1167 YY_BREAK
1168 case 56:
1169 YY_RULE_SETUP
1170 #line 115 "lex.l"
1171 { return DYNAMIC; }
1172 YY_BREAK
1173 case 57:
1174 YY_RULE_SETUP
1175 #line 116 "lex.l"
1176 { return SOURCE; }
1177 YY_BREAK
1178 case 58:
1179 YY_RULE_SETUP
1180 #line 117 "lex.l"
1181 { return LIST; }
1182 YY_BREAK
1183 case 59:
1184 YY_RULE_SETUP
1185 #line 118 "lex.l"
1186 { return IP; }
1187 YY_BREAK
1188 case 60:
1189 YY_RULE_SETUP
1190 #line 119 "lex.l"
1191 { return OS; }
1192 YY_BREAK
1193 case 61:
1194 YY_RULE_SETUP
1195 #line 120 "lex.l"
1196 { return USE; }
1197 YY_BREAK
1198 case 62:
1199 YY_RULE_SETUP
1200 #line 121 "lex.l"
1201 { return IF; }
1202 YY_BREAK
1203 case 63:
1204 YY_RULE_SETUP
1205 #line 122 "lex.l"
1206 { return OTHERWISE; }
1207 YY_BREAK
1208 case 64:
1209 YY_RULE_SETUP
1210 #line 123 "lex.l"
1211 { return BETWEEN; }
1212 YY_BREAK
1213 case 65:
1214 YY_RULE_SETUP
1215 #line 124 "lex.l"
1216 { return TIME; }
1217 YY_BREAK
1218 case 66:
1219 YY_RULE_SETUP
1220 #line 125 "lex.l"
1221 { return INTERNAL; }
1222 YY_BREAK
1223 case 67:
1224 YY_RULE_SETUP
1225 #line 126 "lex.l"
1226 { return MAXFDS; }
1227 YY_BREAK
1228 case 68:
1229 YY_RULE_SETUP
1230 #line 127 "lex.l"
1231 { return ETHERNET; }
1232 YY_BREAK
1233 case 69:
1234 YY_RULE_SETUP
1235 #line 128 "lex.l"
1236 { return DEBUG; }
1237 YY_BREAK
1238 case 70:
1239 YY_RULE_SETUP
1240 #line 129 "lex.l"
1241 { BEGIN(incl); }
1242 YY_BREAK
1243 case 71:
1244 YY_RULE_SETUP
1245 #line 130 "lex.l"
1246 /* eat the whitespace */
1247 YY_BREAK
1248 case 72:
1249 YY_RULE_SETUP
1250 #line 131 "lex.l"
1251 { /* got the include file name */
1252 if (includes_index >= MAX_INCLUDE_DEPTH) {
1253 yyerror("Includes nested too deeply");
1254 exit(1);
1255 }
1256
1257 linenos[includes_index] = lineno;
1258 filenames[includes_index] = filename;
1259 includes[includes_index++] = YY_CURRENT_BUFFER;
1260 if ((yyin = fopen(yytext, "r")) == NULL) {
1261 yyerror("Can not open \"%s\"", yytext);
1262 exit(1);
1263 }
1264 filename = strdup(yytext);
1265 lineno = 1;
1266 yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
1267
1268 BEGIN(INITIAL);
1269 }
1270 YY_BREAK
1271 case YY_STATE_EOF(INITIAL):
1272 case YY_STATE_EOF(incl):
1273 #line 150 "lex.l"
1274 {
1275 if (--includes_index < 0)
1276 yyterminate();
1277 else {
1278 free(filenames[includes_index + 1]);
1279 filename = filenames[includes_index];
1280 lineno = linenos[includes_index];
1281 yy_delete_buffer(YY_CURRENT_BUFFER);
1282 yy_switch_to_buffer(includes[includes_index]);
1283 }
1284 }
1285 YY_BREAK
1286 case 73:
1287 YY_RULE_SETUP
1288 #line 161 "lex.l"
1289 { yylval.string = strdup(yytext); return IPSTRING; }
1290 YY_BREAK
1291 case 74:
1292 YY_RULE_SETUP
1293 #line 162 "lex.l"
1294 { yylval.number = atoi(yytext); return NUMBER; }
1295 YY_BREAK
1296 case 75:
1297 YY_RULE_SETUP
1298 #line 163 "lex.l"
1299 { yylval.floatp = atof(yytext); return FLOAT; }
1300 YY_BREAK
1301 case 76:
1302 YY_RULE_SETUP
1303 #line 164 "lex.l"
1304 { yylval.string = strdup(yytext); return STRING; }
1305 YY_BREAK
1306 case 77:
1307 YY_RULE_SETUP
1308 #line 165 "lex.l"
1309 { yylval.string = strdup(yytext); return CMDSTRING; }
1310 YY_BREAK
1311 case 78:
1312 YY_RULE_SETUP
1313 #line 166 "lex.l"
1314 { return DOT; }
1315 YY_BREAK
1316 case 79:
1317 YY_RULE_SETUP
1318 #line 167 "lex.l"
1319 { return DASH; }
1320 YY_BREAK
1321 case 80:
1322 YY_RULE_SETUP
1323 #line 168 "lex.l"
1324 { return EQUAL; }
1325 YY_BREAK
1326 case 81:
1327 YY_RULE_SETUP
1328 #line 169 "lex.l"
1329 { return COLON; }
1330 YY_BREAK
1331 case 82:
1332 YY_RULE_SETUP
1333 #line 170 "lex.l"
1334 { return SLASH; }
1335 YY_BREAK
1336 case 83:
1337 YY_RULE_SETUP
1338 #line 171 "lex.l"
1339 { ; }
1340 YY_BREAK
1341 case 84:
1342 YY_RULE_SETUP
1343 #line 172 "lex.l"
1344 { lineno++;}
1345 YY_BREAK
1346 case 85:
1347 YY_RULE_SETUP
1348 #line 173 "lex.l"
1349 { ; }
1350 YY_BREAK
1351 case 86:
1352 YY_RULE_SETUP
1353 #line 174 "lex.l"
1354 { lineno++; }
1355 YY_BREAK
1356 case 87:
1357 YY_RULE_SETUP
1358 #line 175 "lex.l"
1359 { yyerror("illegal token"); }
1360 YY_BREAK
1361 case 88:
1362 YY_RULE_SETUP
1363 #line 176 "lex.l"
1364 ECHO;
1365 YY_BREAK
1366 #line 1342 "lex.c"
1367
1368 case YY_END_OF_BUFFER:
1369 {
1370 /* Amount of text matched not including the EOB char. */
1371 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1372
1373 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1374 *yy_cp = yy_hold_char;
1375 YY_RESTORE_YY_MORE_OFFSET
1376
1377 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1378 {
1379 /* We're scanning a new file or input source. It's
1380 * possible that this happened because the user
1381 * just pointed yyin at a new source and called
1382 * yylex(). If so, then we have to assure
1383 * consistency between yy_current_buffer and our
1384 * globals. Here is the right place to do so, because
1385 * this is the first action (other than possibly a
1386 * back-up) that will match for the new input source.
1387 */
1388 yy_n_chars = yy_current_buffer->yy_n_chars;
1389 yy_current_buffer->yy_input_file = yyin;
1390 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1391 }
1392
1393 /* Note that here we test for yy_c_buf_p "<=" to the position
1394 * of the first EOB in the buffer, since yy_c_buf_p will
1395 * already have been incremented past the NUL character
1396 * (since all states make transitions on EOB to the
1397 * end-of-buffer state). Contrast this with the test
1398 * in input().
1399 */
1400 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1401 { /* This was really a NUL. */
1402 yy_state_type yy_next_state;
1403
1404 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1405
1406 yy_current_state = yy_get_previous_state();
1407
1408 /* Okay, we're now positioned to make the NUL
1409 * transition. We couldn't have
1410 * yy_get_previous_state() go ahead and do it
1411 * for us because it doesn't know how to deal
1412 * with the possibility of jamming (and we don't
1413 * want to build jamming into it because then it
1414 * will run more slowly).
1415 */
1416
1417 yy_next_state = yy_try_NUL_trans( yy_current_state );
1418
1419 yy_bp = yytext_ptr + YY_MORE_ADJ;
1420
1421 if ( yy_next_state )
1422 {
1423 /* Consume the NUL. */
1424 yy_cp = ++yy_c_buf_p;
1425 yy_current_state = yy_next_state;
1426 goto yy_match;
1427 }
1428
1429 else
1430 {
1431 yy_cp = yy_c_buf_p;
1432 goto yy_find_action;
1433 }
1434 }
1435
1436 else switch ( yy_get_next_buffer() )
1437 {
1438 case EOB_ACT_END_OF_FILE:
1439 {
1440 yy_did_buffer_switch_on_eof = 0;
1441
1442 if ( yywrap() )
1443 {
1444 /* Note: because we've taken care in
1445 * yy_get_next_buffer() to have set up
1446 * yytext, we can now set up
1447 * yy_c_buf_p so that if some total
1448 * hoser (like flex itself) wants to
1449 * call the scanner after we return the
1450 * YY_NULL, it'll still work - another
1451 * YY_NULL will get returned.
1452 */
1453 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1454
1455 yy_act = YY_STATE_EOF(YY_START);
1456 goto do_action;
1457 }
1458
1459 else
1460 {
1461 if ( ! yy_did_buffer_switch_on_eof )
1462 YY_NEW_FILE;
1463 }
1464 break;
1465 }
1466
1467 case EOB_ACT_CONTINUE_SCAN:
1468 yy_c_buf_p =
1469 yytext_ptr + yy_amount_of_matched_text;
1470
1471 yy_current_state = yy_get_previous_state();
1472
1473 yy_cp = yy_c_buf_p;
1474 yy_bp = yytext_ptr + YY_MORE_ADJ;
1475 goto yy_match;
1476
1477 case EOB_ACT_LAST_MATCH:
1478 yy_c_buf_p =
1479 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1480
1481 yy_current_state = yy_get_previous_state();
1482
1483 yy_cp = yy_c_buf_p;
1484 yy_bp = yytext_ptr + YY_MORE_ADJ;
1485 goto yy_find_action;
1486 }
1487 break;
1488 }
1489
1490 default:
1491 YY_FATAL_ERROR(
1492 "fatal flex scanner internal error--no action found" );
1493 } /* end of action switch */
1494 } /* end of scanning one token */
1495 } /* end of yylex */
1496
1497
1498 /* yy_get_next_buffer - try to read in a new buffer
1499 *
1500 * Returns a code representing an action:
1501 * EOB_ACT_LAST_MATCH -
1502 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1503 * EOB_ACT_END_OF_FILE - end of file
1504 */
1505
yy_get_next_buffer()1506 static int yy_get_next_buffer()
1507 {
1508 register char *dest = yy_current_buffer->yy_ch_buf;
1509 register char *source = yytext_ptr;
1510 register int number_to_move, i;
1511 int ret_val;
1512
1513 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1514 YY_FATAL_ERROR(
1515 "fatal flex scanner internal error--end of buffer missed" );
1516
1517 if ( yy_current_buffer->yy_fill_buffer == 0 )
1518 { /* Don't try to fill the buffer, so this is an EOF. */
1519 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1520 {
1521 /* We matched a single character, the EOB, so
1522 * treat this as a final EOF.
1523 */
1524 return EOB_ACT_END_OF_FILE;
1525 }
1526
1527 else
1528 {
1529 /* We matched some text prior to the EOB, first
1530 * process it.
1531 */
1532 return EOB_ACT_LAST_MATCH;
1533 }
1534 }
1535
1536 /* Try to read more data. */
1537
1538 /* First move last chars to start of buffer. */
1539 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1540
1541 for ( i = 0; i < number_to_move; ++i )
1542 *(dest++) = *(source++);
1543
1544 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1545 /* don't do the read, it's not guaranteed to return an EOF,
1546 * just force an EOF
1547 */
1548 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1549
1550 else
1551 {
1552 int num_to_read =
1553 yy_current_buffer->yy_buf_size - number_to_move - 1;
1554
1555 while ( num_to_read <= 0 )
1556 { /* Not enough room in the buffer - grow it. */
1557 #ifdef YY_USES_REJECT
1558 YY_FATAL_ERROR(
1559 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1560 #else
1561
1562 /* just a shorter name for the current buffer */
1563 YY_BUFFER_STATE b = yy_current_buffer;
1564
1565 int yy_c_buf_p_offset =
1566 (int) (yy_c_buf_p - b->yy_ch_buf);
1567
1568 if ( b->yy_is_our_buffer )
1569 {
1570 int new_size = b->yy_buf_size * 2;
1571
1572 if ( new_size <= 0 )
1573 b->yy_buf_size += b->yy_buf_size / 8;
1574 else
1575 b->yy_buf_size *= 2;
1576
1577 b->yy_ch_buf = (char *)
1578 /* Include room in for 2 EOB chars. */
1579 yy_flex_realloc( (void *) b->yy_ch_buf,
1580 b->yy_buf_size + 2 );
1581 }
1582 else
1583 /* Can't grow it, we don't own it. */
1584 b->yy_ch_buf = 0;
1585
1586 if ( ! b->yy_ch_buf )
1587 YY_FATAL_ERROR(
1588 "fatal error - scanner input buffer overflow" );
1589
1590 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1591
1592 num_to_read = yy_current_buffer->yy_buf_size -
1593 number_to_move - 1;
1594 #endif
1595 }
1596
1597 if ( num_to_read > YY_READ_BUF_SIZE )
1598 num_to_read = YY_READ_BUF_SIZE;
1599
1600 /* Read in more data. */
1601 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1602 yy_n_chars, num_to_read );
1603
1604 yy_current_buffer->yy_n_chars = yy_n_chars;
1605 }
1606
1607 if ( yy_n_chars == 0 )
1608 {
1609 if ( number_to_move == YY_MORE_ADJ )
1610 {
1611 ret_val = EOB_ACT_END_OF_FILE;
1612 yyrestart( yyin );
1613 }
1614
1615 else
1616 {
1617 ret_val = EOB_ACT_LAST_MATCH;
1618 yy_current_buffer->yy_buffer_status =
1619 YY_BUFFER_EOF_PENDING;
1620 }
1621 }
1622
1623 else
1624 ret_val = EOB_ACT_CONTINUE_SCAN;
1625
1626 yy_n_chars += number_to_move;
1627 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1628 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1629
1630 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1631
1632 return ret_val;
1633 }
1634
1635
1636 /* yy_get_previous_state - get the state just before the EOB char was reached */
1637
yy_get_previous_state()1638 static yy_state_type yy_get_previous_state()
1639 {
1640 register yy_state_type yy_current_state;
1641 register char *yy_cp;
1642
1643 yy_current_state = yy_start;
1644
1645 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1646 {
1647 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1648 if ( yy_accept[yy_current_state] )
1649 {
1650 yy_last_accepting_state = yy_current_state;
1651 yy_last_accepting_cpos = yy_cp;
1652 }
1653 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1654 {
1655 yy_current_state = (int) yy_def[yy_current_state];
1656 if ( yy_current_state >= 327 )
1657 yy_c = yy_meta[(unsigned int) yy_c];
1658 }
1659 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1660 }
1661
1662 return yy_current_state;
1663 }
1664
1665
1666 /* yy_try_NUL_trans - try to make a transition on the NUL character
1667 *
1668 * synopsis
1669 * next_state = yy_try_NUL_trans( current_state );
1670 */
1671
1672 #ifdef YY_USE_PROTOS
yy_try_NUL_trans(yy_state_type yy_current_state)1673 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1674 #else
1675 static yy_state_type yy_try_NUL_trans( yy_current_state )
1676 yy_state_type yy_current_state;
1677 #endif
1678 {
1679 register int yy_is_jam;
1680 register char *yy_cp = yy_c_buf_p;
1681
1682 register YY_CHAR yy_c = 1;
1683 if ( yy_accept[yy_current_state] )
1684 {
1685 yy_last_accepting_state = yy_current_state;
1686 yy_last_accepting_cpos = yy_cp;
1687 }
1688 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1689 {
1690 yy_current_state = (int) yy_def[yy_current_state];
1691 if ( yy_current_state >= 327 )
1692 yy_c = yy_meta[(unsigned int) yy_c];
1693 }
1694 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1695 yy_is_jam = (yy_current_state == 326);
1696
1697 return yy_is_jam ? 0 : yy_current_state;
1698 }
1699
1700
1701 #ifndef YY_NO_UNPUT
1702 #ifdef YY_USE_PROTOS
yyunput(int c,register char * yy_bp)1703 static void yyunput( int c, register char *yy_bp )
1704 #else
1705 static void yyunput( c, yy_bp )
1706 int c;
1707 register char *yy_bp;
1708 #endif
1709 {
1710 register char *yy_cp = yy_c_buf_p;
1711
1712 /* undo effects of setting up yytext */
1713 *yy_cp = yy_hold_char;
1714
1715 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1716 { /* need to shift things up to make room */
1717 /* +2 for EOB chars. */
1718 register int number_to_move = yy_n_chars + 2;
1719 register char *dest = &yy_current_buffer->yy_ch_buf[
1720 yy_current_buffer->yy_buf_size + 2];
1721 register char *source =
1722 &yy_current_buffer->yy_ch_buf[number_to_move];
1723
1724 while ( source > yy_current_buffer->yy_ch_buf )
1725 *--dest = *--source;
1726
1727 yy_cp += (int) (dest - source);
1728 yy_bp += (int) (dest - source);
1729 yy_current_buffer->yy_n_chars =
1730 yy_n_chars = yy_current_buffer->yy_buf_size;
1731
1732 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1733 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1734 }
1735
1736 *--yy_cp = (char) c;
1737
1738
1739 yytext_ptr = yy_bp;
1740 yy_hold_char = *yy_cp;
1741 yy_c_buf_p = yy_cp;
1742 }
1743 #endif /* ifndef YY_NO_UNPUT */
1744
1745
1746 #ifdef __cplusplus
yyinput()1747 static int yyinput()
1748 #else
1749 static int input()
1750 #endif
1751 {
1752 int c;
1753
1754 *yy_c_buf_p = yy_hold_char;
1755
1756 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1757 {
1758 /* yy_c_buf_p now points to the character we want to return.
1759 * If this occurs *before* the EOB characters, then it's a
1760 * valid NUL; if not, then we've hit the end of the buffer.
1761 */
1762 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1763 /* This was really a NUL. */
1764 *yy_c_buf_p = '\0';
1765
1766 else
1767 { /* need more input */
1768 int offset = yy_c_buf_p - yytext_ptr;
1769 ++yy_c_buf_p;
1770
1771 switch ( yy_get_next_buffer() )
1772 {
1773 case EOB_ACT_LAST_MATCH:
1774 /* This happens because yy_g_n_b()
1775 * sees that we've accumulated a
1776 * token and flags that we need to
1777 * try matching the token before
1778 * proceeding. But for input(),
1779 * there's no matching to consider.
1780 * So convert the EOB_ACT_LAST_MATCH
1781 * to EOB_ACT_END_OF_FILE.
1782 */
1783
1784 /* Reset buffer status. */
1785 yyrestart( yyin );
1786
1787 /* fall through */
1788
1789 case EOB_ACT_END_OF_FILE:
1790 {
1791 if ( yywrap() )
1792 return EOF;
1793
1794 if ( ! yy_did_buffer_switch_on_eof )
1795 YY_NEW_FILE;
1796 #ifdef __cplusplus
1797 return yyinput();
1798 #else
1799 return input();
1800 #endif
1801 }
1802
1803 case EOB_ACT_CONTINUE_SCAN:
1804 yy_c_buf_p = yytext_ptr + offset;
1805 break;
1806 }
1807 }
1808 }
1809
1810 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1811 *yy_c_buf_p = '\0'; /* preserve yytext */
1812 yy_hold_char = *++yy_c_buf_p;
1813
1814
1815 return c;
1816 }
1817
1818
1819 #ifdef YY_USE_PROTOS
yyrestart(FILE * input_file)1820 void yyrestart( FILE *input_file )
1821 #else
1822 void yyrestart( input_file )
1823 FILE *input_file;
1824 #endif
1825 {
1826 if ( ! yy_current_buffer )
1827 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1828
1829 yy_init_buffer( yy_current_buffer, input_file );
1830 yy_load_buffer_state();
1831 }
1832
1833
1834 #ifdef YY_USE_PROTOS
yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)1835 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1836 #else
1837 void yy_switch_to_buffer( new_buffer )
1838 YY_BUFFER_STATE new_buffer;
1839 #endif
1840 {
1841 if ( yy_current_buffer == new_buffer )
1842 return;
1843
1844 if ( yy_current_buffer )
1845 {
1846 /* Flush out information for old buffer. */
1847 *yy_c_buf_p = yy_hold_char;
1848 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1849 yy_current_buffer->yy_n_chars = yy_n_chars;
1850 }
1851
1852 yy_current_buffer = new_buffer;
1853 yy_load_buffer_state();
1854
1855 /* We don't actually know whether we did this switch during
1856 * EOF (yywrap()) processing, but the only time this flag
1857 * is looked at is after yywrap() is called, so it's safe
1858 * to go ahead and always set it.
1859 */
1860 yy_did_buffer_switch_on_eof = 1;
1861 }
1862
1863
1864 #ifdef YY_USE_PROTOS
yy_load_buffer_state(void)1865 void yy_load_buffer_state( void )
1866 #else
1867 void yy_load_buffer_state()
1868 #endif
1869 {
1870 yy_n_chars = yy_current_buffer->yy_n_chars;
1871 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1872 yyin = yy_current_buffer->yy_input_file;
1873 yy_hold_char = *yy_c_buf_p;
1874 }
1875
1876
1877 #ifdef YY_USE_PROTOS
yy_create_buffer(FILE * file,int size)1878 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1879 #else
1880 YY_BUFFER_STATE yy_create_buffer( file, size )
1881 FILE *file;
1882 int size;
1883 #endif
1884 {
1885 YY_BUFFER_STATE b;
1886
1887 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1888 if ( ! b )
1889 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1890
1891 b->yy_buf_size = size;
1892
1893 /* yy_ch_buf has to be 2 characters longer than the size given because
1894 * we need to put in 2 end-of-buffer characters.
1895 */
1896 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1897 if ( ! b->yy_ch_buf )
1898 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1899
1900 b->yy_is_our_buffer = 1;
1901
1902 yy_init_buffer( b, file );
1903
1904 return b;
1905 }
1906
1907
1908 #ifdef YY_USE_PROTOS
yy_delete_buffer(YY_BUFFER_STATE b)1909 void yy_delete_buffer( YY_BUFFER_STATE b )
1910 #else
1911 void yy_delete_buffer( b )
1912 YY_BUFFER_STATE b;
1913 #endif
1914 {
1915 if ( ! b )
1916 return;
1917
1918 if ( b == yy_current_buffer )
1919 yy_current_buffer = (YY_BUFFER_STATE) 0;
1920
1921 if ( b->yy_is_our_buffer )
1922 yy_flex_free( (void *) b->yy_ch_buf );
1923
1924 yy_flex_free( (void *) b );
1925 }
1926
1927
1928 #ifndef YY_ALWAYS_INTERACTIVE
1929 #ifndef YY_NEVER_INTERACTIVE
1930 extern int isatty YY_PROTO(( int ));
1931 #endif
1932 #endif
1933
1934 #ifdef YY_USE_PROTOS
yy_init_buffer(YY_BUFFER_STATE b,FILE * file)1935 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1936 #else
1937 void yy_init_buffer( b, file )
1938 YY_BUFFER_STATE b;
1939 FILE *file;
1940 #endif
1941
1942
1943 {
1944 yy_flush_buffer( b );
1945
1946 b->yy_input_file = file;
1947 b->yy_fill_buffer = 1;
1948
1949 #if YY_ALWAYS_INTERACTIVE
1950 b->yy_is_interactive = 1;
1951 #else
1952 #if YY_NEVER_INTERACTIVE
1953 b->yy_is_interactive = 0;
1954 #else
1955 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1956 #endif
1957 #endif
1958 }
1959
1960
1961 #ifdef YY_USE_PROTOS
yy_flush_buffer(YY_BUFFER_STATE b)1962 void yy_flush_buffer( YY_BUFFER_STATE b )
1963 #else
1964 void yy_flush_buffer( b )
1965 YY_BUFFER_STATE b;
1966 #endif
1967
1968 {
1969 if ( ! b )
1970 return;
1971
1972 b->yy_n_chars = 0;
1973
1974 /* We always need two end-of-buffer characters. The first causes
1975 * a transition to the end-of-buffer state. The second causes
1976 * a jam in that state.
1977 */
1978 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1979 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1980
1981 b->yy_buf_pos = &b->yy_ch_buf[0];
1982
1983 b->yy_at_bol = 1;
1984 b->yy_buffer_status = YY_BUFFER_NEW;
1985
1986 if ( b == yy_current_buffer )
1987 yy_load_buffer_state();
1988 }
1989
1990
1991 #ifndef YY_NO_SCAN_BUFFER
1992 #ifdef YY_USE_PROTOS
yy_scan_buffer(char * base,yy_size_t size)1993 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1994 #else
1995 YY_BUFFER_STATE yy_scan_buffer( base, size )
1996 char *base;
1997 yy_size_t size;
1998 #endif
1999 {
2000 YY_BUFFER_STATE b;
2001
2002 if ( size < 2 ||
2003 base[size-2] != YY_END_OF_BUFFER_CHAR ||
2004 base[size-1] != YY_END_OF_BUFFER_CHAR )
2005 /* They forgot to leave room for the EOB's. */
2006 return 0;
2007
2008 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2009 if ( ! b )
2010 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2011
2012 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2013 b->yy_buf_pos = b->yy_ch_buf = base;
2014 b->yy_is_our_buffer = 0;
2015 b->yy_input_file = 0;
2016 b->yy_n_chars = b->yy_buf_size;
2017 b->yy_is_interactive = 0;
2018 b->yy_at_bol = 1;
2019 b->yy_fill_buffer = 0;
2020 b->yy_buffer_status = YY_BUFFER_NEW;
2021
2022 yy_switch_to_buffer( b );
2023
2024 return b;
2025 }
2026 #endif
2027
2028
2029 #ifndef YY_NO_SCAN_STRING
2030 #ifdef YY_USE_PROTOS
yy_scan_string(yyconst char * yy_str)2031 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2032 #else
2033 YY_BUFFER_STATE yy_scan_string( yy_str )
2034 yyconst char *yy_str;
2035 #endif
2036 {
2037 int len;
2038 for ( len = 0; yy_str[len]; ++len )
2039 ;
2040
2041 return yy_scan_bytes( yy_str, len );
2042 }
2043 #endif
2044
2045
2046 #ifndef YY_NO_SCAN_BYTES
2047 #ifdef YY_USE_PROTOS
yy_scan_bytes(yyconst char * bytes,int len)2048 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2049 #else
2050 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2051 yyconst char *bytes;
2052 int len;
2053 #endif
2054 {
2055 YY_BUFFER_STATE b;
2056 char *buf;
2057 yy_size_t n;
2058 int i;
2059
2060 /* Get memory for full buffer, including space for trailing EOB's. */
2061 n = len + 2;
2062 buf = (char *) yy_flex_alloc( n );
2063 if ( ! buf )
2064 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2065
2066 for ( i = 0; i < len; ++i )
2067 buf[i] = bytes[i];
2068
2069 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2070
2071 b = yy_scan_buffer( buf, n );
2072 if ( ! b )
2073 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2074
2075 /* It's okay to grow etc. this buffer, and we should throw it
2076 * away when we're done.
2077 */
2078 b->yy_is_our_buffer = 1;
2079
2080 return b;
2081 }
2082 #endif
2083
2084
2085 #ifndef YY_NO_PUSH_STATE
2086 #ifdef YY_USE_PROTOS
yy_push_state(int new_state)2087 static void yy_push_state( int new_state )
2088 #else
2089 static void yy_push_state( new_state )
2090 int new_state;
2091 #endif
2092 {
2093 if ( yy_start_stack_ptr >= yy_start_stack_depth )
2094 {
2095 yy_size_t new_size;
2096
2097 yy_start_stack_depth += YY_START_STACK_INCR;
2098 new_size = yy_start_stack_depth * sizeof( int );
2099
2100 if ( ! yy_start_stack )
2101 yy_start_stack = (int *) yy_flex_alloc( new_size );
2102
2103 else
2104 yy_start_stack = (int *) yy_flex_realloc(
2105 (void *) yy_start_stack, new_size );
2106
2107 if ( ! yy_start_stack )
2108 YY_FATAL_ERROR(
2109 "out of memory expanding start-condition stack" );
2110 }
2111
2112 yy_start_stack[yy_start_stack_ptr++] = YY_START;
2113
2114 BEGIN(new_state);
2115 }
2116 #endif
2117
2118
2119 #ifndef YY_NO_POP_STATE
yy_pop_state()2120 static void yy_pop_state()
2121 {
2122 if ( --yy_start_stack_ptr < 0 )
2123 YY_FATAL_ERROR( "start-condition stack underflow" );
2124
2125 BEGIN(yy_start_stack[yy_start_stack_ptr]);
2126 }
2127 #endif
2128
2129
2130 #ifndef YY_NO_TOP_STATE
yy_top_state()2131 static int yy_top_state()
2132 {
2133 return yy_start_stack[yy_start_stack_ptr - 1];
2134 }
2135 #endif
2136
2137 #ifndef YY_EXIT_FAILURE
2138 #define YY_EXIT_FAILURE 2
2139 #endif
2140
2141 #ifdef YY_USE_PROTOS
yy_fatal_error(yyconst char msg[])2142 static void yy_fatal_error( yyconst char msg[] )
2143 #else
2144 static void yy_fatal_error( msg )
2145 char msg[];
2146 #endif
2147 {
2148 (void) fprintf( stderr, "%s\n", msg );
2149 exit( YY_EXIT_FAILURE );
2150 }
2151
2152
2153
2154 /* Redefine yyless() so it works in section 3 code. */
2155
2156 #undef yyless
2157 #define yyless(n) \
2158 do \
2159 { \
2160 /* Undo effects of setting up yytext. */ \
2161 yytext[yyleng] = yy_hold_char; \
2162 yy_c_buf_p = yytext + n; \
2163 yy_hold_char = *yy_c_buf_p; \
2164 *yy_c_buf_p = '\0'; \
2165 yyleng = n; \
2166 } \
2167 while ( 0 )
2168
2169
2170 /* Internal utility routines. */
2171
2172 #ifndef yytext_ptr
2173 #ifdef YY_USE_PROTOS
yy_flex_strncpy(char * s1,yyconst char * s2,int n)2174 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2175 #else
2176 static void yy_flex_strncpy( s1, s2, n )
2177 char *s1;
2178 yyconst char *s2;
2179 int n;
2180 #endif
2181 {
2182 register int i;
2183 for ( i = 0; i < n; ++i )
2184 s1[i] = s2[i];
2185 }
2186 #endif
2187
2188 #ifdef YY_NEED_STRLEN
2189 #ifdef YY_USE_PROTOS
yy_flex_strlen(yyconst char * s)2190 static int yy_flex_strlen( yyconst char *s )
2191 #else
2192 static int yy_flex_strlen( s )
2193 yyconst char *s;
2194 #endif
2195 {
2196 register int n;
2197 for ( n = 0; s[n]; ++n )
2198 ;
2199
2200 return n;
2201 }
2202 #endif
2203
2204
2205 #ifdef YY_USE_PROTOS
yy_flex_alloc(yy_size_t size)2206 static void *yy_flex_alloc( yy_size_t size )
2207 #else
2208 static void *yy_flex_alloc( size )
2209 yy_size_t size;
2210 #endif
2211 {
2212 return (void *) malloc( size );
2213 }
2214
2215 #ifdef YY_USE_PROTOS
yy_flex_realloc(void * ptr,yy_size_t size)2216 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2217 #else
2218 static void *yy_flex_realloc( ptr, size )
2219 void *ptr;
2220 yy_size_t size;
2221 #endif
2222 {
2223 /* The cast to (char *) in the following accommodates both
2224 * implementations that use char* generic pointers, and those
2225 * that use void* generic pointers. It works with the latter
2226 * because both ANSI C and C++ allow castless assignment from
2227 * any pointer type to void*, and deal with argument conversions
2228 * as though doing an assignment.
2229 */
2230 return (void *) realloc( (char *) ptr, size );
2231 }
2232
2233 #ifdef YY_USE_PROTOS
yy_flex_free(void * ptr)2234 static void yy_flex_free( void *ptr )
2235 #else
2236 static void yy_flex_free( ptr )
2237 void *ptr;
2238 #endif
2239 {
2240 free( ptr );
2241 }
2242
2243 #if YY_MAIN
main()2244 int main()
2245 {
2246 yylex();
2247 return 0;
2248 }
2249 #endif
2250 #line 176 "lex.l"
2251
2252 #ifndef hydwrap
hydwrap()2253 int hydwrap() { return 1; }
2254 #endif
2255