## modules/rpsl/members_is.tab.c

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

## DEFINITIONS

This source file includes following functions.

1. __yy_memcpy
2. __yy_memcpy
3. yyparse
4. members_iserror

       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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     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)
         /* [<][>][^][v][top][bottom][index][help] */
     936 {
     937     yyerror(s);
     938     return 0;
     939 }
     940

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