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