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  |