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