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