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