## modules/rpsl/peer.tab.c

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

## DEFINITIONS

This source file includes following functions.

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

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