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