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  |