modules/rpsl/peering.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. peeringerror

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

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