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