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