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