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