## modules/rpsl/members_rs.tab.c

/* [<][>][^][v][top][bottom][index][help] */

## DEFINITIONS

This source file includes following functions.

1. __yy_memcpy
2. __yy_memcpy
3. yyparse
4. members_rserror

       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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     946 {
     947     yyerror(s);
     948     return 0;
     949 }
     950

/* [<][>][^][v][top][bottom][index][help] */