modules/rpsl/peer.tab.c
/* [<][>][^][v][top][bottom][index][help] */
FUNCTIONS
This source file includes following functions.
- YYTRANSLATE
- YYRECOVERING
- YYBACKUP
- __yy_memcpy
- __yy_memcpy
- __yy_memcpy
- yyparse
- peererror
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
299 #define YYBACKUP(token, value) \
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
991 {
992 yyerror(s);
993 return 0;
994 }
995