Source File rpsl/members_rs.tab.c

    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  |