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] */