## modules/rpsl/peer.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. peererror

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

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