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