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