modules/rpsl/aggr_mtd.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_mtderror

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

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