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