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