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