Source File rpsl/ifaddr.tab.c

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