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