modules/rpsl/filter.tab.c
/* [<][>][^][v][top][bottom][index][help] */
FUNCTIONS
This source file includes following functions.
- YYTRANSLATE
- YYRECOVERING
- YYBACKUP
- __yy_memcpy
- __yy_memcpy
- __yy_memcpy
- yyparse
- filtererror
- yyerror
- syntax_error
- yywrap
- min
- yy_input
- main
1
2 /* A Bison parser, made from filter.y
3 by GNU Bison version 1.28 */
4
5 #define YYBISON 1 /* Identify Bison output. */
6
7 #define yyparse filterparse
8 #define yylex filterlex
9 #define yyerror filtererror
10 #define yylval filterlval
11 #define yychar filterchar
12 #define yydebug filterdebug
13 #define yynerrs filternerrs
14 #define OP_OR 257
15 #define OP_AND 258
16 #define OP_NOT 259
17 #define OP_MS 260
18 #define OP_EQUAL 261
19 #define OP_APPEND 262
20 #define OP_COMPARE 263
21 #define KEYW_ANY 264
22 #define KEYW_PEERAS 265
23 #define KEYW_IGP_COST 266
24 #define KEYW_PREPEND 267
25 #define KEYW_APPEND 268
26 #define KEYW_DELETE 269
27 #define KEYW_CONTAINS 270
28 #define KEYW_INTERNET 271
29 #define KEYW_NO_EXPORT 272
30 #define KEYW_NO_ADVERTISE 273
31 #define KEYW_SELF 274
32 #define ASPATH_POSTFIX 275
33 #define TKN_FLTRNAME 276
34 #define TKN_ASNO 277
35 #define TKN_RSNAME 278
36 #define TKN_ASNAME 279
37 #define TKN_PRFXV4 280
38 #define TKN_PRFXV4RNG 281
39 #define TKN_PREF 282
40 #define TKN_MED 283
41 #define TKN_DPA 284
42 #define TKN_ASPATH 285
43 #define TKN_COMMUNITY 286
44 #define TKN_COMM_NO 287
45 #define TKN_NEXT_HOP 288
46 #define TKN_IPV4 289
47 #define TKN_COST 290
48 #define TKN_INT 291
49
50 #line 1 "filter.y"
51
52 /*
53 filename: filter.y
54
55 description:
56 Defines the grammar for an RPSL filter attribute. It was mostly
57 stolen from the IRRToolSet, simplified by removing ability to parse
58 things defined by a dictionary (we use XML for extensibility rather
59 than a dictionary).
60
61 notes:
62 Defines tokens for the associated lexer, filter.l.
63 */
64
65 #line 16 "filter.y"
66 typedef union {
67 char *sval;
68 } YYSTYPE;
69 #line 30 "filter.y"
70
71 #include <stdio.h>
72 #include <stdarg.h>
73 #include <stdlib.h>
74
75 int yyerror(const char *s);
76
77 /* defines for unit testing */
78 #ifdef UNIT_TEST
79 int main();
80 #endif /* UNIT_TEST */
81 #include <stdio.h>
82
83 #ifndef __cplusplus
84 #ifndef __STDC__
85 #define const
86 #endif
87 #endif
88
89
90
91 #define YYFINAL 137
92 #define YYFLAG -32768
93 #define YYNTBASE 56
94
95 #define YYTRANSLATE(x) ((unsigned)(x) <= 291 ? yytranslate[x] : 83)
/* [<][>][^][v][top][bottom][index][help] */
96
97 static const char yytranslate[] = { 0,
98 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101 2, 2, 2, 2, 2, 50, 2, 2, 2, 38,
102 39, 46, 48, 44, 54, 51, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 55, 40,
104 2, 41, 47, 2, 2, 2, 2, 2, 2, 2,
105 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107 52, 2, 53, 49, 2, 2, 2, 2, 2, 2,
108 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
109 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
110 2, 2, 42, 45, 43, 2, 2, 2, 2, 2,
111 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
112 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
113 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
114 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
115 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
116 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
117 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
118 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
119 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
120 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
121 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
122 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
123 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
124 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
125 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
126 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
127 37
128 };
129
130 #if YYDEBUG != 0
131 static const short yyprhs[] = { 0,
132 0, 4, 7, 9, 13, 15, 18, 22, 24, 26,
133 30, 32, 34, 36, 39, 41, 43, 45, 47, 49,
134 53, 54, 56, 58, 62, 64, 66, 70, 72, 75,
135 77, 80, 83, 86, 89, 91, 93, 95, 99, 101,
136 103, 105, 107, 109, 113, 118, 119, 122, 125, 128,
137 133, 136, 139, 143, 145, 147, 149, 151, 153, 155,
138 157, 161, 165, 169, 173, 180, 182, 186, 190, 194,
139 201, 208, 215, 220, 224, 228, 230, 234, 236, 238,
140 240, 242, 244, 248, 252
141 };
142
143 static const short yyrhs[] = { 56,
144 3, 57, 0, 56, 57, 0, 57, 0, 57, 4,
145 58, 0, 58, 0, 5, 58, 0, 38, 56, 39,
146 0, 59, 0, 10, 0, 40, 65, 41, 0, 71,
147 0, 22, 0, 60, 0, 61, 6, 0, 61, 0,
148 23, 0, 11, 0, 25, 0, 24, 0, 42, 62,
149 43, 0, 0, 63, 0, 64, 0, 63, 44, 64,
150 0, 26, 0, 27, 0, 65, 45, 66, 0, 66,
151 0, 66, 67, 0, 67, 0, 67, 46, 0, 67,
152 47, 0, 67, 48, 0, 67, 21, 0, 68, 0,
153 49, 0, 50, 0, 38, 65, 39, 0, 69, 0,
154 23, 0, 11, 0, 25, 0, 51, 0, 52, 70,
155 53, 0, 52, 49, 70, 53, 0, 0, 70, 23,
156 0, 70, 11, 0, 70, 51, 0, 70, 23, 54,
157 23, 0, 70, 25, 0, 71, 55, 0, 0, 71,
158 55, 0, 72, 0, 73, 0, 74, 0, 75, 0,
159 77, 0, 81, 0, 82, 0, 28, 7, 37, 0,
160 29, 7, 37, 0, 29, 7, 12, 0, 30, 7,
161 37, 0, 31, 51, 13, 38, 76, 39, 0, 23,
162 0, 76, 44, 23, 0, 32, 7, 78, 0, 32,
163 8, 78, 0, 32, 51, 14, 38, 79, 39, 0,
164 32, 51, 15, 38, 79, 39, 0, 32, 51, 16,
165 38, 79, 39, 0, 32, 38, 79, 39, 0, 32,
166 9, 78, 0, 42, 79, 43, 0, 80, 0, 79,
167 44, 80, 0, 17, 0, 18, 0, 19, 0, 37,
168 0, 33, 0, 34, 7, 35, 0, 34, 7, 20,
169 0, 36, 7, 37, 0
170 };
171
172 #endif
173
174 #if YYDEBUG != 0
175 static const short yyrline[] = { 0,
176 45, 46, 47, 50, 51, 54, 55, 56, 59, 60,
177 61, 62, 63, 66, 67, 70, 71, 72, 73, 74,
178 77, 78, 81, 82, 85, 86, 89, 90, 93, 94,
179 97, 98, 99, 100, 101, 104, 105, 106, 107, 110,
180 111, 112, 113, 114, 115, 118, 119, 120, 121, 122,
181 123, 126, 127, 130, 131, 132, 133, 134, 135, 136,
182 139, 150, 159, 162, 173, 176, 177, 180, 181, 182,
183 183, 184, 185, 186, 189, 192, 193, 196, 197, 198,
184 199, 209, 212, 213, 216
185 };
186 #endif
187
188
189 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
190
191 static const char * const yytname[] = { "$","error","$undefined.","OP_OR",
192 "OP_AND","OP_NOT","OP_MS","OP_EQUAL","OP_APPEND","OP_COMPARE","KEYW_ANY","KEYW_PEERAS",
193 "KEYW_IGP_COST","KEYW_PREPEND","KEYW_APPEND","KEYW_DELETE","KEYW_CONTAINS","KEYW_INTERNET",
194 "KEYW_NO_EXPORT","KEYW_NO_ADVERTISE","KEYW_SELF","ASPATH_POSTFIX","TKN_FLTRNAME",
195 "TKN_ASNO","TKN_RSNAME","TKN_ASNAME","TKN_PRFXV4","TKN_PRFXV4RNG","TKN_PREF",
196 "TKN_MED","TKN_DPA","TKN_ASPATH","TKN_COMMUNITY","TKN_COMM_NO","TKN_NEXT_HOP",
197 "TKN_IPV4","TKN_COST","TKN_INT","'('","')'","'<'","'>'","'{'","'}'","','","'|'",
198 "'*'","'?'","'+'","'^'","'$'","'.'","'['","']'","'-'","';'","filter","filter_term",
199 "filter_factor","filter_operand","filter_prefix","filter_prefix_operand","opt_filter_prefix_list",
200 "filter_prefix_list","filter_prefix_list_prefix","filter_aspath","filter_aspath_term",
201 "filter_aspath_closure","filter_aspath_factor","filter_aspath_no","filter_aspath_range",
202 "rp_attribute","pref","med","dpa","aspath","asno_list","community","community_list",
203 "community_elm_list","community_elm","next_hop","cost", NULL
204 };
205 #endif
206
207 static const short yyr1[] = { 0,
208 56, 56, 56, 57, 57, 58, 58, 58, 59, 59,
209 59, 59, 59, 60, 60, 61, 61, 61, 61, 61,
210 62, 62, 63, 63, 64, 64, 65, 65, 66, 66,
211 67, 67, 67, 67, 67, 68, 68, 68, 68, 69,
212 69, 69, 69, 69, 69, 70, 70, 70, 70, 70,
213 70, -1, -1, 71, 71, 71, 71, 71, 71, 71,
214 72, 73, 73, 74, 75, 76, 76, 77, 77, 77,
215 77, 77, 77, 77, 78, 79, 79, 80, 80, 80,
216 80, 80, 81, 81, 82
217 };
218
219 static const short yyr2[] = { 0,
220 3, 2, 1, 3, 1, 2, 3, 1, 1, 3,
221 1, 1, 1, 2, 1, 1, 1, 1, 1, 3,
222 0, 1, 1, 3, 1, 1, 3, 1, 2, 1,
223 2, 2, 2, 2, 1, 1, 1, 3, 1, 1,
224 1, 1, 1, 3, 4, 0, 2, 2, 2, 4,
225 2, 2, 3, 1, 1, 1, 1, 1, 1, 1,
226 3, 3, 3, 3, 6, 1, 3, 3, 3, 6,
227 6, 6, 4, 3, 3, 1, 3, 1, 1, 1,
228 1, 1, 3, 3, 3
229 };
230
231 static const short yydefact[] = { 0,
232 0, 9, 17, 12, 16, 19, 18, 0, 0, 0,
233 0, 0, 0, 0, 0, 0, 21, 0, 3, 5,
234 8, 13, 15, 11, 54, 55, 56, 57, 58, 59,
235 60, 6, 0, 0, 0, 0, 0, 0, 0, 0,
236 0, 0, 0, 0, 41, 40, 42, 0, 36, 37,
237 43, 46, 0, 28, 30, 35, 39, 25, 26, 0,
238 22, 23, 0, 2, 0, 14, 61, 63, 62, 64,
239 0, 0, 68, 69, 74, 78, 79, 80, 82, 81,
240 0, 76, 0, 0, 0, 84, 83, 85, 7, 0,
241 46, 0, 10, 0, 29, 34, 31, 32, 33, 20,
242 0, 1, 4, 0, 0, 73, 0, 0, 0, 0,
243 38, 0, 48, 47, 51, 49, 44, 27, 24, 66,
244 0, 75, 77, 0, 0, 0, 45, 0, 65, 0,
245 70, 71, 72, 50, 67, 0, 0
246 };
247
248 static const short yydefgoto[] = { 18,
249 19, 20, 21, 22, 23, 60, 61, 62, 53, 54,
250 55, 56, 57, 92, 24, 25, 26, 27, 28, 121,
251 29, 73, 81, 82, 30, 31
252 };
253
254 static const short yypact[] = { 114,
255 114,-32768,-32768,-32768,-32768,-32768,-32768, 9, 29, 33,
256 -13, -3, 53, 55, 114, 47, 60, 21, 64,-32768,
257 -32768,-32768, 74,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
258 -32768,-32768, 57, -4, 76, 98, 73, 73, 73, -8,
259 63, -17, 84, 78,-32768,-32768,-32768, 47,-32768,-32768,
260 -32768, 77, -11, 47, 45,-32768,-32768,-32768,-32768, 79,
261 83,-32768, 114, 64, 114,-32768,-32768,-32768,-32768,-32768,
262 85, -8,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
263 -27,-32768, 90, 91, 92,-32768,-32768,-32768,-32768, -32,
264 -32768, 16,-32768, 47, 45,-32768,-32768,-32768,-32768,-32768,
265 60, 64,-32768, 108, -21,-32768, -8, -8, -8, -8,
266 -32768, 31,-32768, 80,-32768,-32768,-32768, 47,-32768,-32768,
267 -25,-32768,-32768, -24, 32, 51,-32768, 109,-32768, 110,
268 -32768,-32768,-32768,-32768,-32768, 135,-32768
269 };
270
271 static const short yypgoto[] = { 125,
272 -16, -1,-32768,-32768,-32768,-32768,-32768, 40, 99, 59,
273 -53,-32768,-32768, 58,-32768,-32768,-32768,-32768,-32768,-32768,
274 -32768, 66, -35, 44,-32768,-32768
275 };
276
277
278 #define YYLAST 156
279
280
281 static const short yytable[] = { 32,
282 95, 64, 86, 37, 38, 39, 111, 68, 76, 77,
283 78, 106, 94, 129, 131, 33, 107, 87, 130, 107,
284 136, 122, 107, 63, 79, 1, 113, 64, 80, 93,
285 2, 3, 69, 94, 40, 34, 105, 36, 114, 35,
286 115, 113, 4, 5, 6, 7, 102, 41, 8, 9,
287 10, 11, 12, 114, 13, 115, 14, 45, 15, 42,
288 16, 43, 17, 103, 95, 96, 116, 65, 117, 46,
289 132, 47, 124, 125, 126, 107, 83, 84, 85, 66,
290 63, 116, 1, 127, 48, 58, 59, 2, 3, 133,
291 97, 98, 99, 67, 107, 49, 50, 51, 52, 4,
292 5, 6, 7, 74, 75, 8, 9, 10, 11, 12,
293 71, 13, 70, 14, 72, 15, 89, 16, 1, 17,
294 88, 100, 104, 2, 3, 91, 101, 108, 109, 110,
295 120, 134, 135, 128, 137, 4, 5, 6, 7, 44,
296 119, 8, 9, 10, 11, 12, 90, 13, 112, 14,
297 123, 15, 118, 16, 0, 17
298 };
299
300 static const short yycheck[] = { 1,
301 54, 18, 20, 7, 8, 9, 39, 12, 17, 18,
302 19, 39, 45, 39, 39, 7, 44, 35, 44, 44,
303 0, 43, 44, 3, 33, 5, 11, 44, 37, 41,
304 10, 11, 37, 45, 38, 7, 72, 51, 23, 7,
305 25, 11, 22, 23, 24, 25, 63, 51, 28, 29,
306 30, 31, 32, 23, 34, 25, 36, 11, 38, 7,
307 40, 7, 42, 65, 118, 21, 51, 4, 53, 23,
308 39, 25, 108, 109, 110, 44, 14, 15, 16, 6,
309 3, 51, 5, 53, 38, 26, 27, 10, 11, 39,
310 46, 47, 48, 37, 44, 49, 50, 51, 52, 22,
311 23, 24, 25, 38, 39, 28, 29, 30, 31, 32,
312 13, 34, 37, 36, 42, 38, 39, 40, 5, 42,
313 37, 43, 38, 10, 11, 49, 44, 38, 38, 38,
314 23, 23, 23, 54, 0, 22, 23, 24, 25, 15,
315 101, 28, 29, 30, 31, 32, 48, 34, 91, 36,
316 107, 38, 94, 40, -1, 42
317 };
318 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
319 #line 3 "/usr/local/share/bison.simple"
320 /* This file comes from bison-1.28. */
321
322 /* Skeleton output parser for bison,
323 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
324
325 This program is free software; you can redistribute it and/or modify
326 it under the terms of the GNU General Public License as published by
327 the Free Software Foundation; either version 2, or (at your option)
328 any later version.
329
330 This program is distributed in the hope that it will be useful,
331 but WITHOUT ANY WARRANTY; without even the implied warranty of
332 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
333 GNU General Public License for more details.
334
335 You should have received a copy of the GNU General Public License
336 along with this program; if not, write to the Free Software
337 Foundation, Inc., 59 Temple Place - Suite 330,
338 Boston, MA 02111-1307, USA. */
339
340 /* As a special exception, when this file is copied by Bison into a
341 Bison output file, you may use that output file without restriction.
342 This special exception was added by the Free Software Foundation
343 in version 1.24 of Bison. */
344
345 /* This is the parser code that is written into each bison parser
346 when the %semantic_parser declaration is not specified in the grammar.
347 It was written by Richard Stallman by simplifying the hairy parser
348 used when %semantic_parser is specified. */
349
350 #ifndef YYSTACK_USE_ALLOCA
351 #ifdef alloca
352 #define YYSTACK_USE_ALLOCA
353 #else /* alloca not defined */
354 #ifdef __GNUC__
355 #define YYSTACK_USE_ALLOCA
356 #define alloca __builtin_alloca
357 #else /* not GNU C. */
358 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
359 #define YYSTACK_USE_ALLOCA
360 #include <alloca.h>
361 #else /* not sparc */
362 /* We think this test detects Watcom and Microsoft C. */
363 /* This used to test MSDOS, but that is a bad idea
364 since that symbol is in the user namespace. */
365 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
366 #if 0 /* No need for malloc.h, which pollutes the namespace;
367 instead, just don't use alloca. */
368 #include <malloc.h>
369 #endif
370 #else /* not MSDOS, or __TURBOC__ */
371 #if defined(_AIX)
372 /* I don't know what this was needed for, but it pollutes the namespace.
373 So I turned it off. rms, 2 May 1997. */
374 /* #include <malloc.h> */
375 #pragma alloca
376 #define YYSTACK_USE_ALLOCA
377 #else /* not MSDOS, or __TURBOC__, or _AIX */
378 #if 0
379 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
380 and on HPUX 10. Eventually we can turn this on. */
381 #define YYSTACK_USE_ALLOCA
382 #define alloca __builtin_alloca
383 #endif /* __hpux */
384 #endif
385 #endif /* not _AIX */
386 #endif /* not MSDOS, or __TURBOC__ */
387 #endif /* not sparc */
388 #endif /* not GNU C */
389 #endif /* alloca not defined */
390 #endif /* YYSTACK_USE_ALLOCA not defined */
391
392 #ifdef YYSTACK_USE_ALLOCA
393 #define YYSTACK_ALLOC alloca
394 #else
395 #define YYSTACK_ALLOC malloc
396 #endif
397
398 /* Note: there must be only one dollar sign in this file.
399 It is replaced by the list of actions, each action
400 as one case of the switch. */
401
402 #define yyerrok (yyerrstatus = 0)
403 #define yyclearin (yychar = YYEMPTY)
404 #define YYEMPTY -2
405 #define YYEOF 0
406 #define YYACCEPT goto yyacceptlab
407 #define YYABORT goto yyabortlab
408 #define YYERROR goto yyerrlab1
409 /* Like YYERROR except do call yyerror.
410 This remains here temporarily to ease the
411 transition to the new meaning of YYERROR, for GCC.
412 Once GCC version 2 has supplanted version 1, this can go. */
413 #define YYFAIL goto yyerrlab
414 #define YYRECOVERING() (!!yyerrstatus)
/* [<][>][^][v][top][bottom][index][help] */
415 #define YYBACKUP(token, value) \
/* [<][>][^][v][top][bottom][index][help] */
416 do \
417 if (yychar == YYEMPTY && yylen == 1) \
418 { yychar = (token), yylval = (value); \
419 yychar1 = YYTRANSLATE (yychar); \
420 YYPOPSTACK; \
421 goto yybackup; \
422 } \
423 else \
424 { yyerror ("syntax error: cannot back up"); YYERROR; } \
425 while (0)
426
427 #define YYTERROR 1
428 #define YYERRCODE 256
429
430 #ifndef YYPURE
431 #define YYLEX yylex()
432 #endif
433
434 #ifdef YYPURE
435 #ifdef YYLSP_NEEDED
436 #ifdef YYLEX_PARAM
437 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
438 #else
439 #define YYLEX yylex(&yylval, &yylloc)
440 #endif
441 #else /* not YYLSP_NEEDED */
442 #ifdef YYLEX_PARAM
443 #define YYLEX yylex(&yylval, YYLEX_PARAM)
444 #else
445 #define YYLEX yylex(&yylval)
446 #endif
447 #endif /* not YYLSP_NEEDED */
448 #endif
449
450 /* If nonreentrant, generate the variables here */
451
452 #ifndef YYPURE
453
454 int yychar; /* the lookahead symbol */
455 YYSTYPE yylval; /* the semantic value of the */
456 /* lookahead symbol */
457
458 #ifdef YYLSP_NEEDED
459 YYLTYPE yylloc; /* location data for the lookahead */
460 /* symbol */
461 #endif
462
463 int yynerrs; /* number of parse errors so far */
464 #endif /* not YYPURE */
465
466 #if YYDEBUG != 0
467 int yydebug; /* nonzero means print parse trace */
468 /* Since this is uninitialized, it does not stop multiple parsers
469 from coexisting. */
470 #endif
471
472 /* YYINITDEPTH indicates the initial size of the parser's stacks */
473
474 #ifndef YYINITDEPTH
475 #define YYINITDEPTH 200
476 #endif
477
478 /* YYMAXDEPTH is the maximum size the stacks can grow to
479 (effective only if the built-in stack extension method is used). */
480
481 #if YYMAXDEPTH == 0
482 #undef YYMAXDEPTH
483 #endif
484
485 #ifndef YYMAXDEPTH
486 #define YYMAXDEPTH 10000
487 #endif
488
489 /* Define __yy_memcpy. Note that the size argument
490 should be passed with type unsigned int, because that is what the non-GCC
491 definitions require. With GCC, __builtin_memcpy takes an arg
492 of type size_t, but it can handle unsigned int. */
493
494 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
495 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
/* [<][>][^][v][top][bottom][index][help] */
496 #else /* not GNU C or C++ */
497 #ifndef __cplusplus
498
499 /* This is the most reliable way to avoid incompatibilities
500 in available built-in functions on various systems. */
501 static void
502 __yy_memcpy (to, from, count)
/* [<][>][^][v][top][bottom][index][help] */
503 char *to;
504 char *from;
505 unsigned int count;
506 {
507 register char *f = from;
508 register char *t = to;
509 register int i = count;
510
511 while (i-- > 0)
512 *t++ = *f++;
513 }
514
515 #else /* __cplusplus */
516
517 /* This is the most reliable way to avoid incompatibilities
518 in available built-in functions on various systems. */
519 static void
520 __yy_memcpy (char *to, char *from, unsigned int count)
/* [<][>][^][v][top][bottom][index][help] */
521 {
522 register char *t = to;
523 register char *f = from;
524 register int i = count;
525
526 while (i-- > 0)
527 *t++ = *f++;
528 }
529
530 #endif
531 #endif
532
533 #line 217 "/usr/local/share/bison.simple"
534
535 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
536 into yyparse. The argument should have type void *.
537 It should actually point to an object.
538 Grammar actions can access the variable by casting it
539 to the proper pointer type. */
540
541 #ifdef YYPARSE_PARAM
542 #ifdef __cplusplus
543 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
544 #define YYPARSE_PARAM_DECL
545 #else /* not __cplusplus */
546 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
547 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
548 #endif /* not __cplusplus */
549 #else /* not YYPARSE_PARAM */
550 #define YYPARSE_PARAM_ARG
551 #define YYPARSE_PARAM_DECL
552 #endif /* not YYPARSE_PARAM */
553
554 /* Prevent warning if -Wstrict-prototypes. */
555 #ifdef __GNUC__
556 #ifdef YYPARSE_PARAM
557 int yyparse (void *);
558 #else
559 int yyparse (void);
560 #endif
561 #endif
562
563 int
564 yyparse(YYPARSE_PARAM_ARG)
/* [<][>][^][v][top][bottom][index][help] */
565 YYPARSE_PARAM_DECL
566 {
567 register int yystate;
568 register int yyn;
569 register short *yyssp;
570 register YYSTYPE *yyvsp;
571 int yyerrstatus; /* number of tokens to shift before error messages enabled */
572 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
573
574 short yyssa[YYINITDEPTH]; /* the state stack */
575 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
576
577 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
578 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
579
580 #ifdef YYLSP_NEEDED
581 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
582 YYLTYPE *yyls = yylsa;
583 YYLTYPE *yylsp;
584
585 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
586 #else
587 #define YYPOPSTACK (yyvsp--, yyssp--)
588 #endif
589
590 int yystacksize = YYINITDEPTH;
591 int yyfree_stacks = 0;
592
593 #ifdef YYPURE
594 int yychar;
595 YYSTYPE yylval;
596 int yynerrs;
597 #ifdef YYLSP_NEEDED
598 YYLTYPE yylloc;
599 #endif
600 #endif
601
602 YYSTYPE yyval; /* the variable used to return */
603 /* semantic values from the action */
604 /* routines */
605
606 int yylen;
607
608 #if YYDEBUG != 0
609 if (yydebug)
610 fprintf(stderr, "Starting parse\n");
611 #endif
612
613 yystate = 0;
614 yyerrstatus = 0;
615 yynerrs = 0;
616 yychar = YYEMPTY; /* Cause a token to be read. */
617
618 /* Initialize stack pointers.
619 Waste one element of value and location stack
620 so that they stay on the same level as the state stack.
621 The wasted elements are never initialized. */
622
623 yyssp = yyss - 1;
624 yyvsp = yyvs;
625 #ifdef YYLSP_NEEDED
626 yylsp = yyls;
627 #endif
628
629 /* Push a new state, which is found in yystate . */
630 /* In all cases, when you get here, the value and location stacks
631 have just been pushed. so pushing a state here evens the stacks. */
632 yynewstate:
633
634 *++yyssp = yystate;
635
636 if (yyssp >= yyss + yystacksize - 1)
637 {
638 /* Give user a chance to reallocate the stack */
639 /* Use copies of these so that the &'s don't force the real ones into memory. */
640 YYSTYPE *yyvs1 = yyvs;
641 short *yyss1 = yyss;
642 #ifdef YYLSP_NEEDED
643 YYLTYPE *yyls1 = yyls;
644 #endif
645
646 /* Get the current used size of the three stacks, in elements. */
647 int size = yyssp - yyss + 1;
648
649 #ifdef yyoverflow
650 /* Each stack pointer address is followed by the size of
651 the data in use in that stack, in bytes. */
652 #ifdef YYLSP_NEEDED
653 /* This used to be a conditional around just the two extra args,
654 but that might be undefined if yyoverflow is a macro. */
655 yyoverflow("parser stack overflow",
656 &yyss1, size * sizeof (*yyssp),
657 &yyvs1, size * sizeof (*yyvsp),
658 &yyls1, size * sizeof (*yylsp),
659 &yystacksize);
660 #else
661 yyoverflow("parser stack overflow",
662 &yyss1, size * sizeof (*yyssp),
663 &yyvs1, size * sizeof (*yyvsp),
664 &yystacksize);
665 #endif
666
667 yyss = yyss1; yyvs = yyvs1;
668 #ifdef YYLSP_NEEDED
669 yyls = yyls1;
670 #endif
671 #else /* no yyoverflow */
672 /* Extend the stack our own way. */
673 if (yystacksize >= YYMAXDEPTH)
674 {
675 yyerror("parser stack overflow");
676 if (yyfree_stacks)
677 {
678 free (yyss);
679 free (yyvs);
680 #ifdef YYLSP_NEEDED
681 free (yyls);
682 #endif
683 }
684 return 2;
685 }
686 yystacksize *= 2;
687 if (yystacksize > YYMAXDEPTH)
688 yystacksize = YYMAXDEPTH;
689 #ifndef YYSTACK_USE_ALLOCA
690 yyfree_stacks = 1;
691 #endif
692 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
693 __yy_memcpy ((char *)yyss, (char *)yyss1,
694 size * (unsigned int) sizeof (*yyssp));
695 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
696 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
697 size * (unsigned int) sizeof (*yyvsp));
698 #ifdef YYLSP_NEEDED
699 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
700 __yy_memcpy ((char *)yyls, (char *)yyls1,
701 size * (unsigned int) sizeof (*yylsp));
702 #endif
703 #endif /* no yyoverflow */
704
705 yyssp = yyss + size - 1;
706 yyvsp = yyvs + size - 1;
707 #ifdef YYLSP_NEEDED
708 yylsp = yyls + size - 1;
709 #endif
710
711 #if YYDEBUG != 0
712 if (yydebug)
713 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
714 #endif
715
716 if (yyssp >= yyss + yystacksize - 1)
717 YYABORT;
718 }
719
720 #if YYDEBUG != 0
721 if (yydebug)
722 fprintf(stderr, "Entering state %d\n", yystate);
723 #endif
724
725 goto yybackup;
726 yybackup:
727
728 /* Do appropriate processing given the current state. */
729 /* Read a lookahead token if we need one and don't already have one. */
730 /* yyresume: */
731
732 /* First try to decide what to do without reference to lookahead token. */
733
734 yyn = yypact[yystate];
735 if (yyn == YYFLAG)
736 goto yydefault;
737
738 /* Not known => get a lookahead token if don't already have one. */
739
740 /* yychar is either YYEMPTY or YYEOF
741 or a valid token in external form. */
742
743 if (yychar == YYEMPTY)
744 {
745 #if YYDEBUG != 0
746 if (yydebug)
747 fprintf(stderr, "Reading a token: ");
748 #endif
749 yychar = YYLEX;
750 }
751
752 /* Convert token to internal form (in yychar1) for indexing tables with */
753
754 if (yychar <= 0) /* This means end of input. */
755 {
756 yychar1 = 0;
757 yychar = YYEOF; /* Don't call YYLEX any more */
758
759 #if YYDEBUG != 0
760 if (yydebug)
761 fprintf(stderr, "Now at end of input.\n");
762 #endif
763 }
764 else
765 {
766 yychar1 = YYTRANSLATE(yychar);
767
768 #if YYDEBUG != 0
769 if (yydebug)
770 {
771 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
772 /* Give the individual parser a way to print the precise meaning
773 of a token, for further debugging info. */
774 #ifdef YYPRINT
775 YYPRINT (stderr, yychar, yylval);
776 #endif
777 fprintf (stderr, ")\n");
778 }
779 #endif
780 }
781
782 yyn += yychar1;
783 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
784 goto yydefault;
785
786 yyn = yytable[yyn];
787
788 /* yyn is what to do for this token type in this state.
789 Negative => reduce, -yyn is rule number.
790 Positive => shift, yyn is new state.
791 New state is final state => don't bother to shift,
792 just return success.
793 0, or most negative number => error. */
794
795 if (yyn < 0)
796 {
797 if (yyn == YYFLAG)
798 goto yyerrlab;
799 yyn = -yyn;
800 goto yyreduce;
801 }
802 else if (yyn == 0)
803 goto yyerrlab;
804
805 if (yyn == YYFINAL)
806 YYACCEPT;
807
808 /* Shift the lookahead token. */
809
810 #if YYDEBUG != 0
811 if (yydebug)
812 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
813 #endif
814
815 /* Discard the token being shifted unless it is eof. */
816 if (yychar != YYEOF)
817 yychar = YYEMPTY;
818
819 *++yyvsp = yylval;
820 #ifdef YYLSP_NEEDED
821 *++yylsp = yylloc;
822 #endif
823
824 /* count tokens shifted since error; after three, turn off error status. */
825 if (yyerrstatus) yyerrstatus--;
826
827 yystate = yyn;
828 goto yynewstate;
829
830 /* Do the default action for the current state. */
831 yydefault:
832
833 yyn = yydefact[yystate];
834 if (yyn == 0)
835 goto yyerrlab;
836
837 /* Do a reduction. yyn is the number of a rule to reduce with. */
838 yyreduce:
839 yylen = yyr2[yyn];
840 if (yylen > 0)
841 yyval = yyvsp[1-yylen]; /* implement default value of the action */
842
843 #if YYDEBUG != 0
844 if (yydebug)
845 {
846 int i;
847
848 fprintf (stderr, "Reducing via rule %d (line %d), ",
849 yyn, yyrline[yyn]);
850
851 /* Print the symbols being reduced, and their result. */
852 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
853 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
854 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
855 }
856 #endif
857
858
859 switch (yyn) {
860
861 case 61:
862 #line 139 "filter.y"
863 {
864 long int val;
865 char *s, *p;
866 p = yyvsp[0].sval;
867 val = strtol(p, &s, 10);
868 if ((val < 0) || (val > 65535)) {
869 syntax_error("pref value \"%s\" is not between 0 and 65535", p);
870 }
871 ;
872 break;}
873 case 62:
874 #line 150 "filter.y"
875 {
876 long int val;
877 char *s, *p;
878 p = yyvsp[0].sval;
879 val = strtol(p, &s, 10);
880 if ((val < 0) || (val > 65535)) {
881 syntax_error("med value \"%s\" is not between 0 and 65535", p);
882 }
883 ;
884 break;}
885 case 64:
886 #line 162 "filter.y"
887 {
888 long int val;
889 char *s, *p;
890 p = yyvsp[0].sval;
891 val = strtol(p, &s, 10);
892 if ((val < 0) || (val > 65535)) {
893 syntax_error("dpa value \"%s\" is not between 0 and 65535", p);
894 }
895 ;
896 break;}
897 case 81:
898 #line 199 "filter.y"
899 {
900 unsigned long int val;
901 char *s, *p;
902 p = yyvsp[0].sval;
903 val = strtoul(p, &s, 10);
904 if ((val < 1) || (val > 4294967295UL) || (*s != '\0')) {
905 syntax_error("community element \"%s\" is not between 1 and 4294967295",
906 p);
907 }
908 ;
909 break;}
910 case 85:
911 #line 216 "filter.y"
912 {
913 long int val;
914 char *s, *p;
915 p = yyvsp[0].sval;
916 val = strtol(p, &s, 10);
917 if ((val < 0) || (val > 65535)) {
918 syntax_error("cost value \"%s\" is not between 0 and 65535", p);
919 }
920 ;
921 break;}
922 }
923 /* the action file gets copied in in place of this dollarsign */
924 #line 543 "/usr/local/share/bison.simple"
925
926 yyvsp -= yylen;
927 yyssp -= yylen;
928 #ifdef YYLSP_NEEDED
929 yylsp -= yylen;
930 #endif
931
932 #if YYDEBUG != 0
933 if (yydebug)
934 {
935 short *ssp1 = yyss - 1;
936 fprintf (stderr, "state stack now");
937 while (ssp1 != yyssp)
938 fprintf (stderr, " %d", *++ssp1);
939 fprintf (stderr, "\n");
940 }
941 #endif
942
943 *++yyvsp = yyval;
944
945 #ifdef YYLSP_NEEDED
946 yylsp++;
947 if (yylen == 0)
948 {
949 yylsp->first_line = yylloc.first_line;
950 yylsp->first_column = yylloc.first_column;
951 yylsp->last_line = (yylsp-1)->last_line;
952 yylsp->last_column = (yylsp-1)->last_column;
953 yylsp->text = 0;
954 }
955 else
956 {
957 yylsp->last_line = (yylsp+yylen-1)->last_line;
958 yylsp->last_column = (yylsp+yylen-1)->last_column;
959 }
960 #endif
961
962 /* Now "shift" the result of the reduction.
963 Determine what state that goes to,
964 based on the state we popped back to
965 and the rule number reduced by. */
966
967 yyn = yyr1[yyn];
968
969 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
970 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
971 yystate = yytable[yystate];
972 else
973 yystate = yydefgoto[yyn - YYNTBASE];
974
975 goto yynewstate;
976
977 yyerrlab: /* here on detecting error */
978
979 if (! yyerrstatus)
980 /* If not already recovering from an error, report this error. */
981 {
982 ++yynerrs;
983
984 #ifdef YYERROR_VERBOSE
985 yyn = yypact[yystate];
986
987 if (yyn > YYFLAG && yyn < YYLAST)
988 {
989 int size = 0;
990 char *msg;
991 int x, count;
992
993 count = 0;
994 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
995 for (x = (yyn < 0 ? -yyn : 0);
996 x < (sizeof(yytname) / sizeof(char *)); x++)
997 if (yycheck[x + yyn] == x)
998 size += strlen(yytname[x]) + 15, count++;
999 msg = (char *) malloc(size + 15);
1000 if (msg != 0)
1001 {
1002 strcpy(msg, "parse error");
1003
1004 if (count < 5)
1005 {
1006 count = 0;
1007 for (x = (yyn < 0 ? -yyn : 0);
1008 x < (sizeof(yytname) / sizeof(char *)); x++)
1009 if (yycheck[x + yyn] == x)
1010 {
1011 strcat(msg, count == 0 ? ", expecting `" : " or `");
1012 strcat(msg, yytname[x]);
1013 strcat(msg, "'");
1014 count++;
1015 }
1016 }
1017 yyerror(msg);
1018 free(msg);
1019 }
1020 else
1021 yyerror ("parse error; also virtual memory exceeded");
1022 }
1023 else
1024 #endif /* YYERROR_VERBOSE */
1025 yyerror("parse error");
1026 }
1027
1028 goto yyerrlab1;
1029 yyerrlab1: /* here on error raised explicitly by an action */
1030
1031 if (yyerrstatus == 3)
1032 {
1033 /* if just tried and failed to reuse lookahead token after an error, discard it. */
1034
1035 /* return failure if at end of input */
1036 if (yychar == YYEOF)
1037 YYABORT;
1038
1039 #if YYDEBUG != 0
1040 if (yydebug)
1041 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1042 #endif
1043
1044 yychar = YYEMPTY;
1045 }
1046
1047 /* Else will try to reuse lookahead token
1048 after shifting the error token. */
1049
1050 yyerrstatus = 3; /* Each real token shifted decrements this */
1051
1052 goto yyerrhandle;
1053
1054 yyerrdefault: /* current state does not do anything special for the error token. */
1055
1056 #if 0
1057 /* This is wrong; only states that explicitly want error tokens
1058 should shift them. */
1059 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1060 if (yyn) goto yydefault;
1061 #endif
1062
1063 yyerrpop: /* pop the current state because it cannot handle the error token */
1064
1065 if (yyssp == yyss) YYABORT;
1066 yyvsp--;
1067 yystate = *--yyssp;
1068 #ifdef YYLSP_NEEDED
1069 yylsp--;
1070 #endif
1071
1072 #if YYDEBUG != 0
1073 if (yydebug)
1074 {
1075 short *ssp1 = yyss - 1;
1076 fprintf (stderr, "Error: state stack now");
1077 while (ssp1 != yyssp)
1078 fprintf (stderr, " %d", *++ssp1);
1079 fprintf (stderr, "\n");
1080 }
1081 #endif
1082
1083 yyerrhandle:
1084
1085 yyn = yypact[yystate];
1086 if (yyn == YYFLAG)
1087 goto yyerrdefault;
1088
1089 yyn += YYTERROR;
1090 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1091 goto yyerrdefault;
1092
1093 yyn = yytable[yyn];
1094 if (yyn < 0)
1095 {
1096 if (yyn == YYFLAG)
1097 goto yyerrpop;
1098 yyn = -yyn;
1099 goto yyreduce;
1100 }
1101 else if (yyn == 0)
1102 goto yyerrpop;
1103
1104 if (yyn == YYFINAL)
1105 YYACCEPT;
1106
1107 #if YYDEBUG != 0
1108 if (yydebug)
1109 fprintf(stderr, "Shifting error token, ");
1110 #endif
1111
1112 *++yyvsp = yylval;
1113 #ifdef YYLSP_NEEDED
1114 *++yylsp = yylloc;
1115 #endif
1116
1117 yystate = yyn;
1118 goto yynewstate;
1119
1120 yyacceptlab:
1121 /* YYACCEPT comes here. */
1122 if (yyfree_stacks)
1123 {
1124 free (yyss);
1125 free (yyvs);
1126 #ifdef YYLSP_NEEDED
1127 free (yyls);
1128 #endif
1129 }
1130 return 0;
1131
1132 yyabortlab:
1133 /* YYABORT comes here. */
1134 if (yyfree_stacks)
1135 {
1136 free (yyss);
1137 free (yyvs);
1138 #ifdef YYLSP_NEEDED
1139 free (yyls);
1140 #endif
1141 }
1142 return 1;
1143 }
1144 #line 228 "filter.y"
1145
1146
1147 /* define a unit test that simply returns "yes" or "no" for filter input */
1148 #ifndef UNIT_TEST
1149
1150 #undef filtererror
1151 #undef yyerror
1152
1153 int
1154 filtererror (const char *s)
/* [<][>][^][v][top][bottom][index][help] */
1155 {
1156 yyerror(s);
1157 return 0;
1158 }
1159 #else /* UNIT_TEST */
1160
1161 int parse_error_count;
1162
1163 /* parse error */
1164 void
1165 yyerror(const char *s)
/* [<][>][^][v][top][bottom][index][help] */
1166 {
1167 fputs(s, stderr);
1168 putc('\n', stderr);
1169 parse_error_count++;
1170 }
1171
1172 /* syntax error */
1173 void
1174 syntax_error(const char *fmt, ...)
/* [<][>][^][v][top][bottom][index][help] */
1175 {
1176 va_list args;
1177 char buf[1024];
1178
1179 va_start(args, fmt);
1180 vsnprintf(buf, sizeof(buf), fmt, args);
1181 va_end(args);
1182 yyerror(buf);
1183 }
1184
1185 int
1186 yywrap()
/* [<][>][^][v][top][bottom][index][help] */
1187 {
1188 return 1;
1189 }
1190
1191 /* taken from _lex & yacc_ p.157, by Levine, Mason, & Brown (corrected) */
1192 char *myinputptr;
1193 char *myinputlim;
1194
1195 #undef min
1196 #define min(a, b) (((a) < (b)) ? (a) : (b))
/* [<][>][^][v][top][bottom][index][help] */
1197
1198 void
1199 yy_input(char *buf, int *result, int max_size)
/* [<][>][^][v][top][bottom][index][help] */
1200 {
1201 int n = min(max_size, myinputlim - myinputptr);
1202
1203 if (n > 0) {
1204 memcpy(buf, myinputptr, n);
1205 myinputptr += n;
1206 }
1207 *result = n;
1208 }
1209
1210 /* program entry point */
1211 int
1212 main()
/* [<][>][^][v][top][bottom][index][help] */
1213 {
1214 char buf[4096];
1215
1216 setbuf(stdout, NULL);
1217 for (;;) {
1218 printf("filter> ");
1219 if (gets(buf) == NULL) {
1220 printf("\n");
1221 return(0);
1222 }
1223 parse_error_count = 0;
1224 myinputptr = buf;
1225 myinputlim = buf + strlen(buf);
1226 filterparse();
1227 printf("%d parse errors\n", parse_error_count);
1228 }
1229 }
1230 #endif /* UNIT_TEST */