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)
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)
415 | #define YYBACKUP(token, value) \
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)
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)
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)
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)
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)
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)
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, ...)
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()
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))
1197 |
1198 | void
1199 | yy_input(char *buf, int *result, int max_size)
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()
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 */