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