Source File rpsl/members_is.tab.c

    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  |