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