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