Source File rpsl/peering.tab.c

    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)
    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)
    291  | #define YYBACKUP(token, value) \
    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)
    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)
    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)
    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)
    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)
    975  | {
    976  |     yyerror(s);
    977  |     return 0;
    978  | }
    979  |