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  |