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