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