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