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