## modules/rpsl/refer.tab.c

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

## FUNCTIONS

This source file includes following functions.

1. YYTRANSLATE
2. YYRECOVERING
3. YYBACKUP
4. __yy_memcpy
5. __yy_memcpy
6. __yy_memcpy
7. yyparse
8. refererror

       1
       2 /*  A Bison parser, made from refer.y
       3     by GNU Bison version 1.28  */
       4
       5 #define YYBISON 1  /* Identify Bison output.  */
       6
       7 #define yyparse referparse
       8 #define yylex referlex
       9 #define yyerror refererror
      10 #define yylval referlval
      11 #define yychar referchar
      12 #define yydebug referdebug
      13 #define yynerrs refernerrs
      14 #define TKN_TYPE        257
      15 #define TKN_IPV4        258
      16 #define TKN_HOSTNAME    259
      17 #define TKN_PORT        260
      18
      19 #line 1 "refer.y"
      20
      21 /*
      22   filename: refer.y
      23
      24   description:
      25     Defines the grammar for an RPSL refer attribute.
      26
      27   notes:
      28     Defines tokens for the associated lexer, refer.l.
      29 */
      30
      31 /******************
      32   Copyright (c) 2002                                        RIPE NCC
      33
      34   All Rights Reserved
      35
      36   Permission to use, copy, modify, and distribute this software and its
      37   documentation for any purpose and without fee is hereby granted,
      38   provided that the above copyright notice appear in all copies and that
      39   both that copyright notice and this permission notice appear in
      40   supporting documentation, and that the name of the author not be
      41   used in advertising or publicity pertaining to distribution of the
      42   software without specific, written prior permission.
      43
      44   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
      45   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
      46   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
      47   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
      48   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
      49   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
      50   ***************************************/
      51
      52 #include <stdlib.h>
      53
      54 int yyerror(const char *s);
      55 #ifndef YYSTYPE
      56 #define YYSTYPE int
      57 #endif
      58 #include <stdio.h>
      59
      60 #ifndef __cplusplus
      61 #ifndef __STDC__
      62 #define const
      63 #endif
      64 #endif
      65
      66
      67
      68 #define YYFINAL         8
      69 #define YYFLAG          -32768
      70 #define YYNTBASE        7
      71
      72 #define YYTRANSLATE(x) ((unsigned)(x) <= 260 ? yytranslate[x] : 8)
         /* [<][>][^][v][top][bottom][index][help] */
      73
      74 static const char yytranslate[] = {     0,
      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,     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,     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,     2,     2,     2,     2,     2,
     100      2,     2,     2,     2,     2,     1,     3,     4,     5,     6
     101 };
     102
     103 #if YYDEBUG != 0
     104 static const short yyprhs[] = {     0,
     105      0,     3,     6,    10
     106 };
     107
     108 static const short yyrhs[] = {     3,
     109      4,     0,     3,     5,     0,     3,     4,     6,     0,     3,
     110      5,     6,     0
     111 };
     112
     113 #endif
     114
     115 #if YYDEBUG != 0
     116 static const short yyrline[] = { 0,
     117     42,    43,    44,    45
     118 };
     119 #endif
     120
     121
     122 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
     123
     124 static const char * const yytname[] = {   "$","error","$undefined.","TKN_TYPE",
     125 "TKN_IPV4","TKN_HOSTNAME","TKN_PORT","refer", NULL
     126 };
     127 #endif
     128
     129 static const short yyr1[] = {     0,
     130      7,     7,     7,     7
     131 };
     132
     133 static const short yyr2[] = {     0,
     134      2,     2,     3,     3
     135 };
     136
     137 static const short yydefact[] = {     0,
     138      0,     1,     2,     3,     4,     0,     0,     0
     139 };
     140
     141 static const short yydefgoto[] = {     6
     142 };
     143
     144 static const short yypact[] = {    -1,
     145     -4,    -3,    -2,-32768,-32768,     5,     6,-32768
     146 };
     147
     148 static const short yypgoto[] = {-32768
     149 };
     150
     151
     152 #define YYLAST          6
     153
     154
     155 static const short yytable[] = {     2,
     156      3,     1,     4,     5,     7,     8
     157 };
     158
     159 static const short yycheck[] = {     4,
     160      5,     3,     6,     6,     0,     0
     161 };
     162 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
     163 #line 3 "/usr/local/share/bison.simple"
     164 /* This file comes from bison-1.28.  */
     165
     166 /* Skeleton output parser for bison,
     167    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
     168
     169    This program is free software; you can redistribute it and/or modify
     170    it under the terms of the GNU General Public License as published by
     171    the Free Software Foundation; either version 2, or (at your option)
     172    any later version.
     173
     174    This program is distributed in the hope that it will be useful,
     175    but WITHOUT ANY WARRANTY; without even the implied warranty of
     176    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     177    GNU General Public License for more details.
     178
     179    You should have received a copy of the GNU General Public License
     180    along with this program; if not, write to the Free Software
     181    Foundation, Inc., 59 Temple Place - Suite 330,
     182    Boston, MA 02111-1307, USA.  */
     183
     184 /* As a special exception, when this file is copied by Bison into a
     185    Bison output file, you may use that output file without restriction.
     186    This special exception was added by the Free Software Foundation
     187    in version 1.24 of Bison.  */
     188
     189 /* This is the parser code that is written into each bison parser
     190   when the %semantic_parser declaration is not specified in the grammar.
     191   It was written by Richard Stallman by simplifying the hairy parser
     192   used when %semantic_parser is specified.  */
     193
     194 #ifndef YYSTACK_USE_ALLOCA
     195 #ifdef alloca
     196 #define YYSTACK_USE_ALLOCA
     197 #else /* alloca not defined */
     198 #ifdef __GNUC__
     199 #define YYSTACK_USE_ALLOCA
     200 #define alloca __builtin_alloca
     201 #else /* not GNU C.  */
     202 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
     203 #define YYSTACK_USE_ALLOCA
     204 #include <alloca.h>
     205 #else /* not sparc */
     206 /* We think this test detects Watcom and Microsoft C.  */
     207 /* This used to test MSDOS, but that is a bad idea
     208    since that symbol is in the user namespace.  */
     209 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
     210 #if 0 /* No need for malloc.h, which pollutes the namespace;
     211          instead, just don't use alloca.  */
     212 #include <malloc.h>
     213 #endif
     214 #else /* not MSDOS, or __TURBOC__ */
     215 #if defined(_AIX)
     216 /* I don't know what this was needed for, but it pollutes the namespace.
     217    So I turned it off.   rms, 2 May 1997.  */
     218 /* #include <malloc.h>  */
     219  #pragma alloca
     220 #define YYSTACK_USE_ALLOCA
     221 #else /* not MSDOS, or __TURBOC__, or _AIX */
     222 #if 0
     223 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
     224                  and on HPUX 10.  Eventually we can turn this on.  */
     225 #define YYSTACK_USE_ALLOCA
     226 #define alloca __builtin_alloca
     227 #endif /* __hpux */
     228 #endif
     229 #endif /* not _AIX */
     230 #endif /* not MSDOS, or __TURBOC__ */
     231 #endif /* not sparc */
     232 #endif /* not GNU C */
     233 #endif /* alloca not defined */
     234 #endif /* YYSTACK_USE_ALLOCA not defined */
     235
     236 #ifdef YYSTACK_USE_ALLOCA
     237 #define YYSTACK_ALLOC alloca
     238 #else
     239 #define YYSTACK_ALLOC malloc
     240 #endif
     241
     242 /* Note: there must be only one dollar sign in this file.
     243    It is replaced by the list of actions, each action
     244    as one case of the switch.  */
     245
     246 #define yyerrok         (yyerrstatus = 0)
     247 #define yyclearin       (yychar = YYEMPTY)
     248 #define YYEMPTY         -2
     249 #define YYEOF           0
     250 #define YYACCEPT        goto yyacceptlab
     251 #define YYABORT         goto yyabortlab
     252 #define YYERROR         goto yyerrlab1
     253 /* Like YYERROR except do call yyerror.
     254    This remains here temporarily to ease the
     255    transition to the new meaning of YYERROR, for GCC.
     256    Once GCC version 2 has supplanted version 1, this can go.  */
     257 #define YYFAIL          goto yyerrlab
     258 #define YYRECOVERING()  (!!yyerrstatus)
         /* [<][>][^][v][top][bottom][index][help] */
     259 #define YYBACKUP(token, value) \
         /* [<][>][^][v][top][bottom][index][help] */
     260 do                                                              \
     261   if (yychar == YYEMPTY && yylen == 1)                          \
     262     { yychar = (token), yylval = (value);                       \
     263       yychar1 = YYTRANSLATE (yychar);                           \
     264       YYPOPSTACK;                                               \
     265       goto yybackup;                                            \
     266     }                                                           \
     267   else                                                          \
     268     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
     269 while (0)
     270
     271 #define YYTERROR        1
     272 #define YYERRCODE       256
     273
     274 #ifndef YYPURE
     275 #define YYLEX           yylex()
     276 #endif
     277
     278 #ifdef YYPURE
     279 #ifdef YYLSP_NEEDED
     280 #ifdef YYLEX_PARAM
     281 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
     282 #else
     283 #define YYLEX           yylex(&yylval, &yylloc)
     284 #endif
     285 #else /* not YYLSP_NEEDED */
     286 #ifdef YYLEX_PARAM
     287 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
     288 #else
     289 #define YYLEX           yylex(&yylval)
     290 #endif
     291 #endif /* not YYLSP_NEEDED */
     292 #endif
     293
     294 /* If nonreentrant, generate the variables here */
     295
     296 #ifndef YYPURE
     297
     298 int     yychar;                 /*  the lookahead symbol                */
     299 YYSTYPE yylval;                 /*  the semantic value of the           */
     300                                 /*  lookahead symbol                    */
     301
     302 #ifdef YYLSP_NEEDED
     303 YYLTYPE yylloc;                 /*  location data for the lookahead     */
     304                                 /*  symbol                              */
     305 #endif
     306
     307 int yynerrs;                    /*  number of parse errors so far       */
     308 #endif  /* not YYPURE */
     309
     310 #if YYDEBUG != 0
     311 int yydebug;                    /*  nonzero means print parse trace     */
     312 /* Since this is uninitialized, it does not stop multiple parsers
     313    from coexisting.  */
     314 #endif
     315
     316 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
     317
     318 #ifndef YYINITDEPTH
     319 #define YYINITDEPTH 200
     320 #endif
     321
     322 /*  YYMAXDEPTH is the maximum size the stacks can grow to
     323     (effective only if the built-in stack extension method is used).  */
     324
     325 #if YYMAXDEPTH == 0
     326 #undef YYMAXDEPTH
     327 #endif
     328
     329 #ifndef YYMAXDEPTH
     330 #define YYMAXDEPTH 10000
     331 #endif
     332
     333 /* Define __yy_memcpy.  Note that the size argument
     334    should be passed with type unsigned int, because that is what the non-GCC
     335    definitions require.  With GCC, __builtin_memcpy takes an arg
     336    of type size_t, but it can handle unsigned int.  */
     337
     338 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
     339 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
         /* [<][>][^][v][top][bottom][index][help] */
     340 #else                           /* not GNU C or C++ */
     341 #ifndef __cplusplus
     342
     343 /* This is the most reliable way to avoid incompatibilities
     344    in available built-in functions on various systems.  */
     345 static void
     346 __yy_memcpy (to, from, count)
         /* [<][>][^][v][top][bottom][index][help] */
     347      char *to;
     348      char *from;
     349      unsigned int count;
     350 {
     351   register char *f = from;
     352   register char *t = to;
     353   register int i = count;
     354
     355   while (i-- > 0)
     356     *t++ = *f++;
     357 }
     358
     359 #else /* __cplusplus */
     360
     361 /* This is the most reliable way to avoid incompatibilities
     362    in available built-in functions on various systems.  */
     363 static void
     364 __yy_memcpy (char *to, char *from, unsigned int count)
         /* [<][>][^][v][top][bottom][index][help] */
     365 {
     366   register char *t = to;
     367   register char *f = from;
     368   register int i = count;
     369
     370   while (i-- > 0)
     371     *t++ = *f++;
     372 }
     373
     374 #endif
     375 #endif
     376
     377 #line 217 "/usr/local/share/bison.simple"
     378
     379 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
     380    into yyparse.  The argument should have type void *.
     381    It should actually point to an object.
     382    Grammar actions can access the variable by casting it
     383    to the proper pointer type.  */
     384
     385 #ifdef YYPARSE_PARAM
     386 #ifdef __cplusplus
     387 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
     388 #define YYPARSE_PARAM_DECL
     389 #else /* not __cplusplus */
     390 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
     391 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
     392 #endif /* not __cplusplus */
     393 #else /* not YYPARSE_PARAM */
     394 #define YYPARSE_PARAM_ARG
     395 #define YYPARSE_PARAM_DECL
     396 #endif /* not YYPARSE_PARAM */
     397
     398 /* Prevent warning if -Wstrict-prototypes.  */
     399 #ifdef __GNUC__
     400 #ifdef YYPARSE_PARAM
     401 int yyparse (void *);
     402 #else
     403 int yyparse (void);
     404 #endif
     405 #endif
     406
     407 int
     408 yyparse(YYPARSE_PARAM_ARG)
         /* [<][>][^][v][top][bottom][index][help] */
     409      YYPARSE_PARAM_DECL
     410 {
     411   register int yystate;
     412   register int yyn;
     413   register short *yyssp;
     414   register YYSTYPE *yyvsp;
     415   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
     416   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
     417
     418   short yyssa[YYINITDEPTH];     /*  the state stack                     */
     419   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
     420
     421   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
     422   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
     423
     424 #ifdef YYLSP_NEEDED
     425   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
     426   YYLTYPE *yyls = yylsa;
     427   YYLTYPE *yylsp;
     428
     429 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
     430 #else
     431 #define YYPOPSTACK   (yyvsp--, yyssp--)
     432 #endif
     433
     434   int yystacksize = YYINITDEPTH;
     435   int yyfree_stacks = 0;
     436
     437 #ifdef YYPURE
     438   int yychar;
     439   YYSTYPE yylval;
     440   int yynerrs;
     441 #ifdef YYLSP_NEEDED
     442   YYLTYPE yylloc;
     443 #endif
     444 #endif
     445
     446   YYSTYPE yyval;                /*  the variable used to return         */
     447                                 /*  semantic values from the action     */
     448                                 /*  routines                            */
     449
     450   int yylen;
     451
     452 #if YYDEBUG != 0
     453   if (yydebug)
     454     fprintf(stderr, "Starting parse\n");
     455 #endif
     456
     457   yystate = 0;
     458   yyerrstatus = 0;
     459   yynerrs = 0;
     460   yychar = YYEMPTY;             /* Cause a token to be read.  */
     461
     462   /* Initialize stack pointers.
     463      Waste one element of value and location stack
     464      so that they stay on the same level as the state stack.
     465      The wasted elements are never initialized.  */
     466
     467   yyssp = yyss - 1;
     468   yyvsp = yyvs;
     469 #ifdef YYLSP_NEEDED
     470   yylsp = yyls;
     471 #endif
     472
     473 /* Push a new state, which is found in  yystate  .  */
     474 /* In all cases, when you get here, the value and location stacks
     475    have just been pushed. so pushing a state here evens the stacks.  */
     476 yynewstate:
     477
     478   *++yyssp = yystate;
     479
     480   if (yyssp >= yyss + yystacksize - 1)
     481     {
     482       /* Give user a chance to reallocate the stack */
     483       /* Use copies of these so that the &'s don't force the real ones into memory. */
     484       YYSTYPE *yyvs1 = yyvs;
     485       short *yyss1 = yyss;
     486 #ifdef YYLSP_NEEDED
     487       YYLTYPE *yyls1 = yyls;
     488 #endif
     489
     490       /* Get the current used size of the three stacks, in elements.  */
     491       int size = yyssp - yyss + 1;
     492
     493 #ifdef yyoverflow
     494       /* Each stack pointer address is followed by the size of
     495          the data in use in that stack, in bytes.  */
     496 #ifdef YYLSP_NEEDED
     497       /* This used to be a conditional around just the two extra args,
     498          but that might be undefined if yyoverflow is a macro.  */
     499       yyoverflow("parser stack overflow",
     500                  &yyss1, size * sizeof (*yyssp),
     501                  &yyvs1, size * sizeof (*yyvsp),
     502                  &yyls1, size * sizeof (*yylsp),
     503                  &yystacksize);
     504 #else
     505       yyoverflow("parser stack overflow",
     506                  &yyss1, size * sizeof (*yyssp),
     507                  &yyvs1, size * sizeof (*yyvsp),
     508                  &yystacksize);
     509 #endif
     510
     511       yyss = yyss1; yyvs = yyvs1;
     512 #ifdef YYLSP_NEEDED
     513       yyls = yyls1;
     514 #endif
     515 #else /* no yyoverflow */
     516       /* Extend the stack our own way.  */
     517       if (yystacksize >= YYMAXDEPTH)
     518         {
     519           yyerror("parser stack overflow");
     520           if (yyfree_stacks)
     521             {
     522               free (yyss);
     523               free (yyvs);
     524 #ifdef YYLSP_NEEDED
     525               free (yyls);
     526 #endif
     527             }
     528           return 2;
     529         }
     530       yystacksize *= 2;
     531       if (yystacksize > YYMAXDEPTH)
     532         yystacksize = YYMAXDEPTH;
     533 #ifndef YYSTACK_USE_ALLOCA
     534       yyfree_stacks = 1;
     535 #endif
     536       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
     537       __yy_memcpy ((char *)yyss, (char *)yyss1,
     538                    size * (unsigned int) sizeof (*yyssp));
     539       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
     540       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
     541                    size * (unsigned int) sizeof (*yyvsp));
     542 #ifdef YYLSP_NEEDED
     543       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
     544       __yy_memcpy ((char *)yyls, (char *)yyls1,
     545                    size * (unsigned int) sizeof (*yylsp));
     546 #endif
     547 #endif /* no yyoverflow */
     548
     549       yyssp = yyss + size - 1;
     550       yyvsp = yyvs + size - 1;
     551 #ifdef YYLSP_NEEDED
     552       yylsp = yyls + size - 1;
     553 #endif
     554
     555 #if YYDEBUG != 0
     556       if (yydebug)
     557         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
     558 #endif
     559
     560       if (yyssp >= yyss + yystacksize - 1)
     561         YYABORT;
     562     }
     563
     564 #if YYDEBUG != 0
     565   if (yydebug)
     566     fprintf(stderr, "Entering state %d\n", yystate);
     567 #endif
     568
     569   goto yybackup;
     570  yybackup:
     571
     572 /* Do appropriate processing given the current state.  */
     573 /* Read a lookahead token if we need one and don't already have one.  */
     574 /* yyresume: */
     575
     576   /* First try to decide what to do without reference to lookahead token.  */
     577
     578   yyn = yypact[yystate];
     579   if (yyn == YYFLAG)
     580     goto yydefault;
     581
     582   /* Not known => get a lookahead token if don't already have one.  */
     583
     584   /* yychar is either YYEMPTY or YYEOF
     585      or a valid token in external form.  */
     586
     587   if (yychar == YYEMPTY)
     588     {
     589 #if YYDEBUG != 0
     590       if (yydebug)
     591         fprintf(stderr, "Reading a token: ");
     592 #endif
     593       yychar = YYLEX;
     594     }
     595
     596   /* Convert token to internal form (in yychar1) for indexing tables with */
     597
     598   if (yychar <= 0)              /* This means end of input. */
     599     {
     600       yychar1 = 0;
     601       yychar = YYEOF;           /* Don't call YYLEX any more */
     602
     603 #if YYDEBUG != 0
     604       if (yydebug)
     605         fprintf(stderr, "Now at end of input.\n");
     606 #endif
     607     }
     608   else
     609     {
     610       yychar1 = YYTRANSLATE(yychar);
     611
     612 #if YYDEBUG != 0
     613       if (yydebug)
     614         {
     615           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
     616           /* Give the individual parser a way to print the precise meaning
     617              of a token, for further debugging info.  */
     618 #ifdef YYPRINT
     619           YYPRINT (stderr, yychar, yylval);
     620 #endif
     621           fprintf (stderr, ")\n");
     622         }
     623 #endif
     624     }
     625
     626   yyn += yychar1;
     627   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
     628     goto yydefault;
     629
     630   yyn = yytable[yyn];
     631
     632   /* yyn is what to do for this token type in this state.
     633      Negative => reduce, -yyn is rule number.
     634      Positive => shift, yyn is new state.
     635        New state is final state => don't bother to shift,
     636        just return success.
     637      0, or most negative number => error.  */
     638
     639   if (yyn < 0)
     640     {
     641       if (yyn == YYFLAG)
     642         goto yyerrlab;
     643       yyn = -yyn;
     644       goto yyreduce;
     645     }
     646   else if (yyn == 0)
     647     goto yyerrlab;
     648
     649   if (yyn == YYFINAL)
     650     YYACCEPT;
     651
     652   /* Shift the lookahead token.  */
     653
     654 #if YYDEBUG != 0
     655   if (yydebug)
     656     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
     657 #endif
     658
     659   /* Discard the token being shifted unless it is eof.  */
     660   if (yychar != YYEOF)
     661     yychar = YYEMPTY;
     662
     663   *++yyvsp = yylval;
     664 #ifdef YYLSP_NEEDED
     665   *++yylsp = yylloc;
     666 #endif
     667
     668   /* count tokens shifted since error; after three, turn off error status.  */
     669   if (yyerrstatus) yyerrstatus--;
     670
     671   yystate = yyn;
     672   goto yynewstate;
     673
     674 /* Do the default action for the current state.  */
     675 yydefault:
     676
     677   yyn = yydefact[yystate];
     678   if (yyn == 0)
     679     goto yyerrlab;
     680
     681 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
     682 yyreduce:
     683   yylen = yyr2[yyn];
     684   if (yylen > 0)
     685     yyval = yyvsp[1-yylen]; /* implement default value of the action */
     686
     687 #if YYDEBUG != 0
     688   if (yydebug)
     689     {
     690       int i;
     691
     692       fprintf (stderr, "Reducing via rule %d (line %d), ",
     693                yyn, yyrline[yyn]);
     694
     695       /* Print the symbols being reduced, and their result.  */
     696       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
     697         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
     698       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     699     }
     700 #endif
     701
     702
     703   switch (yyn) {
     704
     705 }
     706    /* the action file gets copied in in place of this dollarsign */
     707 #line 543 "/usr/local/share/bison.simple"
     708
     709   yyvsp -= yylen;
     710   yyssp -= yylen;
     711 #ifdef YYLSP_NEEDED
     712   yylsp -= yylen;
     713 #endif
     714
     715 #if YYDEBUG != 0
     716   if (yydebug)
     717     {
     718       short *ssp1 = yyss - 1;
     719       fprintf (stderr, "state stack now");
     720       while (ssp1 != yyssp)
     721         fprintf (stderr, " %d", *++ssp1);
     722       fprintf (stderr, "\n");
     723     }
     724 #endif
     725
     726   *++yyvsp = yyval;
     727
     728 #ifdef YYLSP_NEEDED
     729   yylsp++;
     730   if (yylen == 0)
     731     {
     732       yylsp->first_line = yylloc.first_line;
     733       yylsp->first_column = yylloc.first_column;
     734       yylsp->last_line = (yylsp-1)->last_line;
     735       yylsp->last_column = (yylsp-1)->last_column;
     736       yylsp->text = 0;
     737     }
     738   else
     739     {
     740       yylsp->last_line = (yylsp+yylen-1)->last_line;
     741       yylsp->last_column = (yylsp+yylen-1)->last_column;
     742     }
     743 #endif
     744
     745   /* Now "shift" the result of the reduction.
     746      Determine what state that goes to,
     747      based on the state we popped back to
     748      and the rule number reduced by.  */
     749
     750   yyn = yyr1[yyn];
     751
     752   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
     753   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
     754     yystate = yytable[yystate];
     755   else
     756     yystate = yydefgoto[yyn - YYNTBASE];
     757
     758   goto yynewstate;
     759
     760 yyerrlab:   /* here on detecting error */
     761
     762   if (! yyerrstatus)
     763     /* If not already recovering from an error, report this error.  */
     764     {
     765       ++yynerrs;
     766
     767 #ifdef YYERROR_VERBOSE
     768       yyn = yypact[yystate];
     769
     770       if (yyn > YYFLAG && yyn < YYLAST)
     771         {
     772           int size = 0;
     773           char *msg;
     774           int x, count;
     775
     776           count = 0;
     777           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
     778           for (x = (yyn < 0 ? -yyn : 0);
     779                x < (sizeof(yytname) / sizeof(char *)); x++)
     780             if (yycheck[x + yyn] == x)
     781               size += strlen(yytname[x]) + 15, count++;
     782           msg = (char *) malloc(size + 15);
     783           if (msg != 0)
     784             {
     785               strcpy(msg, "parse error");
     786
     787               if (count < 5)
     788                 {
     789                   count = 0;
     790                   for (x = (yyn < 0 ? -yyn : 0);
     791                        x < (sizeof(yytname) / sizeof(char *)); x++)
     792                     if (yycheck[x + yyn] == x)
     793                       {
     794                         strcat(msg, count == 0 ? ", expecting `" : " or `");
     795                         strcat(msg, yytname[x]);
     796                         strcat(msg, "'");
     797                         count++;
     798                       }
     799                 }
     800               yyerror(msg);
     801               free(msg);
     802             }
     803           else
     804             yyerror ("parse error; also virtual memory exceeded");
     805         }
     806       else
     807 #endif /* YYERROR_VERBOSE */
     808         yyerror("parse error");
     809     }
     810
     811   goto yyerrlab1;
     812 yyerrlab1:   /* here on error raised explicitly by an action */
     813
     814   if (yyerrstatus == 3)
     815     {
     816       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
     817
     818       /* return failure if at end of input */
     819       if (yychar == YYEOF)
     820         YYABORT;
     821
     822 #if YYDEBUG != 0
     823       if (yydebug)
     824         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
     825 #endif
     826
     827       yychar = YYEMPTY;
     828     }
     829
     830   /* Else will try to reuse lookahead token
     831      after shifting the error token.  */
     832
     833   yyerrstatus = 3;              /* Each real token shifted decrements this */
     834
     835   goto yyerrhandle;
     836
     837 yyerrdefault:  /* current state does not do anything special for the error token. */
     838
     839 #if 0
     840   /* This is wrong; only states that explicitly want error tokens
     841      should shift them.  */
     842   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
     843   if (yyn) goto yydefault;
     844 #endif
     845
     846 yyerrpop:   /* pop the current state because it cannot handle the error token */
     847
     848   if (yyssp == yyss) YYABORT;
     849   yyvsp--;
     850   yystate = *--yyssp;
     851 #ifdef YYLSP_NEEDED
     852   yylsp--;
     853 #endif
     854
     855 #if YYDEBUG != 0
     856   if (yydebug)
     857     {
     858       short *ssp1 = yyss - 1;
     859       fprintf (stderr, "Error: state stack now");
     860       while (ssp1 != yyssp)
     861         fprintf (stderr, " %d", *++ssp1);
     862       fprintf (stderr, "\n");
     863     }
     864 #endif
     865
     866 yyerrhandle:
     867
     868   yyn = yypact[yystate];
     869   if (yyn == YYFLAG)
     870     goto yyerrdefault;
     871
     872   yyn += YYTERROR;
     873   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
     874     goto yyerrdefault;
     875
     876   yyn = yytable[yyn];
     877   if (yyn < 0)
     878     {
     879       if (yyn == YYFLAG)
     880         goto yyerrpop;
     881       yyn = -yyn;
     882       goto yyreduce;
     883     }
     884   else if (yyn == 0)
     885     goto yyerrpop;
     886
     887   if (yyn == YYFINAL)
     888     YYACCEPT;
     889
     890 #if YYDEBUG != 0
     891   if (yydebug)
     892     fprintf(stderr, "Shifting error token, ");
     893 #endif
     894
     895   *++yyvsp = yylval;
     896 #ifdef YYLSP_NEEDED
     897   *++yylsp = yylloc;
     898 #endif
     899
     900   yystate = yyn;
     901   goto yynewstate;
     902
     903  yyacceptlab:
     904   /* YYACCEPT comes here.  */
     905   if (yyfree_stacks)
     906     {
     907       free (yyss);
     908       free (yyvs);
     909 #ifdef YYLSP_NEEDED
     910       free (yyls);
     911 #endif
     912     }
     913   return 0;
     914
     915  yyabortlab:
     916   /* YYABORT comes here.  */
     917   if (yyfree_stacks)
     918     {
     919       free (yyss);
     920       free (yyvs);
     921 #ifdef YYLSP_NEEDED
     922       free (yyls);
     923 #endif
     924     }
     925   return 1;
     926 }
     927 #line 48 "refer.y"
     928
     929
     930 #undef refererror
     931 #undef yyerror
     932
     933 int
     934 refererror (const char *s)
         /* [<][>][^][v][top][bottom][index][help] */
     935 {
     936     yyerror(s);
     937     return 0;
     938 }
     939

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