Source File rpsl/aggr_mtd.tab.c

    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)
    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)
    264  | #define YYBACKUP(token, value) \
    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)
    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)
    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)
    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)
    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)
    940  | {
    941  |     yyerror(s);
    942  |     return 0;
    943  | }
    944  |
    945  |