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