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