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