modules/rpsl/aggr_bndry.tab.c

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. YYTRANSLATE
  2. YYRECOVERING
  3. YYBACKUP
  4. __yy_memcpy
  5. __yy_memcpy
  6. __yy_memcpy
  7. yyparse
  8. aggr_bndryerror

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

/* [<][>][^][v][top][bottom][index][help] */