1    | 
2    | /*  A Bison parser, made from er.yacc
3    |     by GNU Bison version 1.28  */
4    | 
5    | #define YYBISON 1  /* Identify Bison output.  */
6    | 
7    | #define yyparse er_yyparse
8    | #define yylex er_yylex
9    | #define yyerror er_yyerror
10   | #define yylval er_yylval
11   | #define yychar er_yychar
12   | #define yydebug er_yydebug
13   | #define yynerrs er_yynerrs
14   | #define	EOL	257
15   | #define	K_SOCK	258
16   | #define	K_NAME	259
17   | #define	K_FAC	260
18   | #define	K_ADD	261
19   | #define	K_RM	262
20   | #define	K_CREATE	263
21   | #define	K_DELETE	264
22   | #define	K_MODIFY	265
23   | #define	K_AUTO	266
24   | #define	K_ASP	267
25   | #define	K_SEV	268
26   | #define	K_THR	269
27   | #define	K_FORMAT	270
28   | #define	K_SELF	271
29   | #define	K_DATE	272
30   | #define	K_ALL	273
31   | #define	K_EXEC	274
32   | #define	K_PATH	275
33   | #define	STRING	276
34   | #define	NUMBER	277
35   | #define	HEXNUM	278
36   | 
37   | 
38   | 
39   | /* NOTE: We'd like to use "rip.h", but "mm.h" defines STRING which 
40   |          collides with the STRING here */
41   | #include "erroutines.h"
42   | #include "memwrap.h"
43   | #include "bitmask.h"
44   | #include "er_yacc_helper.h"
45   | #include "er_arrays.h"
46   | #include "er_macro.h"
47   | #include "er_paths.h"
48   | 
49   | #include <stdlib.h> 
50   | #include <string.h>
51   | 
52   | #define YYPARSE_PARAM ypar
53   | #define YYLEX_PARAM   ypar
54   | #define YYDEBUG 0
55   | /* #define YYERROR_VERBOSE  */
56   | 
57   | #define er_yyerror(a) myerror(ypar,a)
58   | 
59   | #define adderr(a,b) {strcat(a->errtxt,b);}
60   | 
61   | #define myfree(mem) {lexerr_t *erst = ypar; free(mem); erst->token = NULL} 
62   | 
63   | #define MYABORT { mycleanup(ypar); YYABORT; }
64   | 
65   | 
66   | typedef union {
67   |       int inum;
68   |       char *text;
69   | } YYSTYPE;
70   | #include <stdio.h>
71   | 
72   | #ifndef __cplusplus
73   | #ifndef __STDC__
74   | #define const
75   | #endif
76   | #endif
77   | 
78   | 
79   | 
80   | #define	YYFINAL		85
81   | #define	YYFLAG		-32768
82   | #define	YYNTBASE	31
83   | 
84   | #define YYTRANSLATE(x) ((unsigned)(x) <= 278 ? yytranslate[x] : 62)
85   | 
86   | static const char yytranslate[] = {     0,
87   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
88   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
89   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
90   |      2,     2,     2,     2,     2,     2,     2,     2,     2,    28,
91   |     29,     2,     2,     2,    30,     2,     2,     2,     2,     2,
92   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
93   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
94   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
95   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
96   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
97   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
98   |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
99   |      2,     2,    25,    27,    26,     2,     2,     2,     2,     2,
100  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
101  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
102  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
103  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
104  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
105  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
106  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
107  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
108  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
109  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
110  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
111  |      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
112  |      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
113  |      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
114  |     17,    18,    19,    20,    21,    22,    23,    24
115  | };
116  | 
117  | #if YYDEBUG != 0
118  | static const short yyprhs[] = {     0,
119  |      0,     2,     5,     7,     8,    14,    17,    21,    26,    31,
120  |     33,    35,    40,    42,    44,    46,    48,    51,    53,    55,
121  |     59,    61,    64,    68,    71,    72,    74,    78,    79,    81,
122  |     83,    86,    88,    90,    93,    97,   102,   104,   107,   110,
123  |    111,   114,   115,   118,   120,   124,   126,   128,   132,   134,
124  |    135,   137,   138,   140,   142,   144,   148,   150
125  | };
126  | 
127  | static const short yyrhs[] = {    32,
128  |      0,    32,     3,     0,     1,     0,     0,     9,    34,    33,
129  |     35,    47,     0,    10,    34,     0,    11,    34,    35,     0,
130  |     11,    34,     8,    46,     0,    11,    34,     7,    47,     0,
131  |     22,     0,    12,     0,    25,    37,    36,    26,     0,    40,
132  |      0,    41,     0,    43,     0,     1,     0,    16,    38,     0,
133  |      1,     0,    39,     0,    38,    27,    39,     0,    22,     0,
134  |      4,    23,     0,     5,    22,    42,     0,     5,     1,     0,
135  |      0,    18,     0,    20,    44,    45,     0,     0,    21,     0,
136  |     22,     0,    45,    22,     0,    23,     0,    48,     0,    47,
137  |     48,     0,    28,    49,    29,     0,    50,    52,    51,    53,
138  |      0,     1,     0,     6,    54,     0,    14,    56,     0,     0,
139  |     13,    60,     0,     0,    15,    17,     0,    55,     0,    54,
140  |     27,    55,     0,    19,     0,    22,     0,    57,    30,    58,
141  |      0,    59,     0,     0,    22,     0,     0,    22,     0,    22,
142  |      0,    61,     0,    60,    27,    61,     0,    22,     0,    24,
143  |      0
144  | };
145  | 
146  | #endif
147  | 
148  | #if YYDEBUG != 0
149  | static const short yyrline[] = { 0,
150  |     80,    81,    82,    87,    92,   121,   134,   149,   165,   181,
151  |    182,   187,   192,   193,   194,   195,   200,   201,   206,   207,
152  |    210,   227,   235,   242,   247,   247,   253,   259,   259,   265,
153  |    270,   278,   281,   282,   285,   294,   295,   302,   304,   306,
154  |    307,   309,   310,   316,   317,   322,   326,   343,   344,   347,
155  |    350,   356,   359,   365,   378,   379,   384,   399
156  | };
157  | #endif
158  | 
159  | 
160  | #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
161  | 
162  | static const char * const yytname[] = {   "$","error","$undefined.","EOL","K_SOCK",
163  | "K_NAME","K_FAC","K_ADD","K_RM","K_CREATE","K_DELETE","K_MODIFY","K_AUTO","K_ASP",
164  | "K_SEV","K_THR","K_FORMAT","K_SELF","K_DATE","K_ALL","K_EXEC","K_PATH","STRING",
165  | "NUMBER","HEXNUM","'{'","'}'","'|'","'('","')'","'-'","fullline","stmt","@1",
166  | "pathid","path","pathspec","formatspec","formlist","oneform","sockspec","namespec",
167  | "nameoptions","execspec","opt_path","execwords","filterid","filters","filter",
168  | "filtspec","mand_fac","mand_sev","opt_asp","opt_thr","facspec","onefac","sevspec",
169  | "sevmin","sevmax","seveql","aspspec","oneasp", NULL
170  | };
171  | #endif
172  | 
173  | static const short yyr1[] = {     0,
174  |     31,    31,    31,    33,    32,    32,    32,    32,    32,    34,
175  |     34,    35,    36,    36,    36,    36,    37,    37,    38,    38,
176  |     39,    40,    41,    41,    42,    42,    43,    44,    44,    45,
177  |     45,    46,    47,    47,    48,    49,    49,    50,    51,    52,
178  |     52,    53,    53,    54,    54,    55,    55,    56,    56,    57,
179  |     57,    58,    58,    59,    60,    60,    61,    61
180  | };
181  | 
182  | static const short yyr2[] = {     0,
183  |      1,     2,     1,     0,     5,     2,     3,     4,     4,     1,
184  |      1,     4,     1,     1,     1,     1,     2,     1,     1,     3,
185  |      1,     2,     3,     2,     0,     1,     3,     0,     1,     1,
186  |      2,     1,     1,     2,     3,     4,     1,     2,     2,     0,
187  |      2,     0,     2,     1,     3,     1,     1,     3,     1,     0,
188  |      1,     0,     1,     1,     1,     3,     1,     1
189  | };
190  | 
191  | static const short yydefact[] = {     0,
192  |      3,     0,     0,     0,     1,    11,    10,     4,     6,     0,
193  |      2,     0,     0,     0,     0,     7,     0,     0,     9,    33,
194  |     32,     8,    18,     0,     0,     5,    37,     0,     0,    40,
195  |     34,    21,    17,    19,    16,     0,     0,    28,     0,    13,
196  |     14,    15,    46,    47,    38,    44,    35,     0,     0,     0,
197  |     22,    24,    25,    29,     0,    12,     0,    57,    58,    41,
198  |     55,    50,    42,    20,    26,    23,    30,    27,    45,     0,
199  |     54,    39,     0,    49,     0,    36,    31,    56,    52,    43,
200  |     53,    48,     0,     0,     0
201  | };
202  | 
203  | static const short yydefgoto[] = {    83,
204  |      5,    12,     8,    16,    39,    25,    33,    34,    40,    41,
205  |     66,    42,    55,    68,    22,    19,    20,    29,    30,    63,
206  |     49,    76,    45,    46,    72,    73,    82,    74,    60,    61
207  | };
208  | 
209  | static const short yypact[] = {     5,
210  | -32768,   -10,   -10,   -10,     4,-32768,-32768,-32768,-32768,     1,
211  | -32768,    -2,     6,     7,     2,-32768,     6,    18,     6,-32768,
212  | -32768,-32768,-32768,     9,     0,     6,-32768,     3,     8,    16,
213  | -32768,-32768,    11,-32768,-32768,    10,    -1,    14,    13,-32768,
214  | -32768,-32768,-32768,-32768,    15,-32768,-32768,   -11,    22,     9,
215  | -32768,-32768,    23,-32768,    21,-32768,     3,-32768,-32768,    17,
216  | -32768,    25,    30,-32768,-32768,-32768,-32768,    26,-32768,   -11,
217  |     19,-32768,    20,-32768,    29,-32768,-32768,-32768,    31,-32768,
218  | -32768,-32768,    32,    40,-32768
219  | };
220  | 
221  | static const short yypgoto[] = {-32768,
222  | -32768,-32768,    24,    39,-32768,-32768,-32768,    12,-32768,-32768,
223  | -32768,-32768,-32768,-32768,-32768,    35,    -9,-32768,-32768,-32768,
224  | -32768,-32768,-32768,    -3,-32768,-32768,-32768,-32768,-32768,   -15
225  | };
226  | 
227  | 
228  | #define	YYLAST		62
229  | 
230  | 
231  | static const short yytable[] = {    52,
232  |     35,     6,    23,    36,    37,     1,    11,    13,    14,    31,
233  |     58,     7,    59,     2,     3,     4,    31,    24,    27,    38,
234  |     53,    43,    15,    28,    44,    15,     9,    10,    48,    21,
235  |     32,    84,    51,    18,    54,    62,    47,    50,    56,    85,
236  |     65,    57,    67,    70,    75,    80,    71,    77,   -51,    79,
237  |     17,    26,    81,    69,    78,     0,     0,     0,     0,     0,
238  |      0,    64
239  | };
240  | 
241  | static const short yycheck[] = {     1,
242  |      1,    12,     1,     4,     5,     1,     3,     7,     8,    19,
243  |     22,    22,    24,     9,    10,    11,    26,    16,     1,    20,
244  |     22,    19,    25,     6,    22,    25,     3,     4,    13,    23,
245  |     22,     0,    23,    28,    21,    14,    29,    27,    26,     0,
246  |     18,    27,    22,    27,    15,    17,    22,    22,    30,    30,
247  |     12,    17,    22,    57,    70,    -1,    -1,    -1,    -1,    -1,
248  |     -1,    50
249  | };
250  | #define YYPURE 1
251  | 
252  | /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
253  | 
254  | /* This file comes from bison-1.28.  */
255  | 
256  | /* Skeleton output parser for bison,
257  |    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
258  | 
259  |    This program is free software; you can redistribute it and/or modify
260  |    it under the terms of the GNU General Public License as published by
261  |    the Free Software Foundation; either version 2, or (at your option)
262  |    any later version.
263  | 
264  |    This program is distributed in the hope that it will be useful,
265  |    but WITHOUT ANY WARRANTY; without even the implied warranty of
266  |    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
267  |    GNU General Public License for more details.
268  | 
269  |    You should have received a copy of the GNU General Public License
270  |    along with this program; if not, write to the Free Software
271  |    Foundation, Inc., 59 Temple Place - Suite 330,
272  |    Boston, MA 02111-1307, USA.  */
273  | 
274  | /* As a special exception, when this file is copied by Bison into a
275  |    Bison output file, you may use that output file without restriction.
276  |    This special exception was added by the Free Software Foundation
277  |    in version 1.24 of Bison.  */
278  | 
279  | /* This is the parser code that is written into each bison parser
280  |   when the %semantic_parser declaration is not specified in the grammar.
281  |   It was written by Richard Stallman by simplifying the hairy parser
282  |   used when %semantic_parser is specified.  */
283  | 
284  | #ifndef YYSTACK_USE_ALLOCA
285  | #ifdef alloca
286  | #define YYSTACK_USE_ALLOCA
287  | #else /* alloca not defined */
288  | #ifdef __GNUC__
289  | #define YYSTACK_USE_ALLOCA
290  | #define alloca __builtin_alloca
291  | #else /* not GNU C.  */
292  | #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
293  | #define YYSTACK_USE_ALLOCA
294  | #include <alloca.h>
295  | #else /* not sparc */
296  | /* We think this test detects Watcom and Microsoft C.  */
297  | /* This used to test MSDOS, but that is a bad idea
298  |    since that symbol is in the user namespace.  */
299  | #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
300  | #if 0 /* No need for malloc.h, which pollutes the namespace;
301  | 	 instead, just don't use alloca.  */
302  | #include <malloc.h>
303  | #endif
304  | #else /* not MSDOS, or __TURBOC__ */
305  | #if defined(_AIX)
306  | /* I don't know what this was needed for, but it pollutes the namespace.
307  |    So I turned it off.   rms, 2 May 1997.  */
308  | /* #include <malloc.h>  */
309  |  #pragma alloca
310  | #define YYSTACK_USE_ALLOCA
311  | #else /* not MSDOS, or __TURBOC__, or _AIX */
312  | #if 0
313  | #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
314  | 		 and on HPUX 10.  Eventually we can turn this on.  */
315  | #define YYSTACK_USE_ALLOCA
316  | #define alloca __builtin_alloca
317  | #endif /* __hpux */
318  | #endif
319  | #endif /* not _AIX */
320  | #endif /* not MSDOS, or __TURBOC__ */
321  | #endif /* not sparc */
322  | #endif /* not GNU C */
323  | #endif /* alloca not defined */
324  | #endif /* YYSTACK_USE_ALLOCA not defined */
325  | 
326  | #ifdef YYSTACK_USE_ALLOCA
327  | #define YYSTACK_ALLOC alloca
328  | #else
329  | #define YYSTACK_ALLOC malloc
330  | #endif
331  | 
332  | /* Note: there must be only one dollar sign in this file.
333  |    It is replaced by the list of actions, each action
334  |    as one case of the switch.  */
335  | 
336  | #define yyerrok		(yyerrstatus = 0)
337  | #define yyclearin	(yychar = YYEMPTY)
338  | #define YYEMPTY		-2
339  | #define YYEOF		0
340  | #define YYACCEPT	goto yyacceptlab
341  | #define YYABORT 	goto yyabortlab
342  | #define YYERROR		goto yyerrlab1
343  | /* Like YYERROR except do call yyerror.
344  |    This remains here temporarily to ease the
345  |    transition to the new meaning of YYERROR, for GCC.
346  |    Once GCC version 2 has supplanted version 1, this can go.  */
347  | #define YYFAIL		goto yyerrlab
348  | #define YYRECOVERING()  (!!yyerrstatus)
349  | #define YYBACKUP(token, value) \
350  | do								\
351  |   if (yychar == YYEMPTY && yylen == 1)				\
352  |     { yychar = (token), yylval = (value);			\
353  |       yychar1 = YYTRANSLATE (yychar);				\
354  |       YYPOPSTACK;						\
355  |       goto yybackup;						\
356  |     }								\
357  |   else								\
358  |     { yyerror ("syntax error: cannot back up"); YYERROR; }	\
359  | while (0)
360  | 
361  | #define YYTERROR	1
362  | #define YYERRCODE	256
363  | 
364  | #ifndef YYPURE
365  | #define YYLEX		yylex()
366  | #endif
367  | 
368  | #ifdef YYPURE
369  | #ifdef YYLSP_NEEDED
370  | #ifdef YYLEX_PARAM
371  | #define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)
372  | #else
373  | #define YYLEX		yylex(&yylval, &yylloc)
374  | #endif
375  | #else /* not YYLSP_NEEDED */
376  | #ifdef YYLEX_PARAM
377  | #define YYLEX		yylex(&yylval, YYLEX_PARAM)
378  | #else
379  | #define YYLEX		yylex(&yylval)
380  | #endif
381  | #endif /* not YYLSP_NEEDED */
382  | #endif
383  | 
384  | /* If nonreentrant, generate the variables here */
385  | 
386  | #ifndef YYPURE
387  | 
388  | int	yychar;			/*  the lookahead symbol		*/
389  | YYSTYPE	yylval;			/*  the semantic value of the		*/
390  | 				/*  lookahead symbol			*/
391  | 
392  | #ifdef YYLSP_NEEDED
393  | YYLTYPE yylloc;			/*  location data for the lookahead	*/
394  | 				/*  symbol				*/
395  | #endif
396  | 
397  | int yynerrs;			/*  number of parse errors so far       */
398  | #endif  /* not YYPURE */
399  | 
400  | #if YYDEBUG != 0
401  | int yydebug;			/*  nonzero means print parse trace	*/
402  | /* Since this is uninitialized, it does not stop multiple parsers
403  |    from coexisting.  */
404  | #endif
405  | 
406  | /*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
407  | 
408  | #ifndef	YYINITDEPTH
409  | #define YYINITDEPTH 200
410  | #endif
411  | 
412  | /*  YYMAXDEPTH is the maximum size the stacks can grow to
413  |     (effective only if the built-in stack extension method is used).  */
414  | 
415  | #if YYMAXDEPTH == 0
416  | #undef YYMAXDEPTH
417  | #endif
418  | 
419  | #ifndef YYMAXDEPTH
420  | #define YYMAXDEPTH 10000
421  | #endif
422  | 
423  | /* Define __yy_memcpy.  Note that the size argument
424  |    should be passed with type unsigned int, because that is what the non-GCC
425  |    definitions require.  With GCC, __builtin_memcpy takes an arg
426  |    of type size_t, but it can handle unsigned int.  */
427  | 
428  | #if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
429  | #define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
430  | #else				/* not GNU C or C++ */
431  | #ifndef __cplusplus
432  | 
433  | /* This is the most reliable way to avoid incompatibilities
434  |    in available built-in functions on various systems.  */
435  | static void
436  | __yy_memcpy (to, from, count)
437  |      char *to;
438  |      char *from;
439  |      unsigned int count;
440  | {
441  |   register char *f = from;
442  |   register char *t = to;
443  |   register int i = count;
444  | 
445  |   while (i-- > 0)
446  |     *t++ = *f++;
447  | }
448  | 
449  | #else /* __cplusplus */
450  | 
451  | /* This is the most reliable way to avoid incompatibilities
452  |    in available built-in functions on various systems.  */
453  | static void
454  | __yy_memcpy (char *to, char *from, unsigned int count)
455  | {
456  |   register char *t = to;
457  |   register char *f = from;
458  |   register int i = count;
459  | 
460  |   while (i-- > 0)
461  |     *t++ = *f++;
462  | }
463  | 
464  | #endif
465  | #endif
466  | 
467  | 
468  | 
469  | /* The user can define YYPARSE_PARAM as the name of an argument to be passed
470  |    into yyparse.  The argument should have type void *.
471  |    It should actually point to an object.
472  |    Grammar actions can access the variable by casting it
473  |    to the proper pointer type.  */
474  | 
475  | #ifdef YYPARSE_PARAM
476  | #ifdef __cplusplus
477  | #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
478  | #define YYPARSE_PARAM_DECL
479  | #else /* not __cplusplus */
480  | #define YYPARSE_PARAM_ARG YYPARSE_PARAM
481  | #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
482  | #endif /* not __cplusplus */
483  | #else /* not YYPARSE_PARAM */
484  | #define YYPARSE_PARAM_ARG
485  | #define YYPARSE_PARAM_DECL
486  | #endif /* not YYPARSE_PARAM */
487  | 
488  | /* Prevent warning if -Wstrict-prototypes.  */
489  | #ifdef __GNUC__
490  | #ifdef YYPARSE_PARAM
491  | int yyparse (void *);
492  | #else
493  | int yyparse (void);
494  | #endif
495  | #endif
496  | 
497  | int
498  | yyparse(YYPARSE_PARAM_ARG)
499  |      YYPARSE_PARAM_DECL
500  | {
501  |   register int yystate;
502  |   register int yyn;
503  |   register short *yyssp;
504  |   register YYSTYPE *yyvsp;
505  |   int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
506  |   int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
507  | 
508  |   short	yyssa[YYINITDEPTH];	/*  the state stack			*/
509  |   YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
510  | 
511  |   short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
512  |   YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
513  | 
514  | #ifdef YYLSP_NEEDED
515  |   YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
516  |   YYLTYPE *yyls = yylsa;
517  |   YYLTYPE *yylsp;
518  | 
519  | #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
520  | #else
521  | #define YYPOPSTACK   (yyvsp--, yyssp--)
522  | #endif
523  | 
524  |   int yystacksize = YYINITDEPTH;
525  |   int yyfree_stacks = 0;
526  | 
527  | #ifdef YYPURE
528  |   int yychar;
529  |   YYSTYPE yylval;
530  |   int yynerrs;
531  | #ifdef YYLSP_NEEDED
532  |   YYLTYPE yylloc;
533  | #endif
534  | #endif
535  | 
536  |   YYSTYPE yyval;		/*  the variable used to return		*/
537  | 				/*  semantic values from the action	*/
538  | 				/*  routines				*/
539  | 
540  |   int yylen;
541  | 
542  | #if YYDEBUG != 0
543  |   if (yydebug)
544  |     fprintf(stderr, "Starting parse\n");
545  | #endif
546  | 
547  |   yystate = 0;
548  |   yyerrstatus = 0;
549  |   yynerrs = 0;
550  |   yychar = YYEMPTY;		/* Cause a token to be read.  */
551  | 
552  |   /* Initialize stack pointers.
553  |      Waste one element of value and location stack
554  |      so that they stay on the same level as the state stack.
555  |      The wasted elements are never initialized.  */
556  | 
557  |   yyssp = yyss - 1;
558  |   yyvsp = yyvs;
559  | #ifdef YYLSP_NEEDED
560  |   yylsp = yyls;
561  | #endif
562  | 
563  | /* Push a new state, which is found in  yystate  .  */
564  | /* In all cases, when you get here, the value and location stacks
565  |    have just been pushed. so pushing a state here evens the stacks.  */
566  | yynewstate:
567  | 
568  |   *++yyssp = yystate;
569  | 
570  |   if (yyssp >= yyss + yystacksize - 1)
571  |     {
572  |       /* Give user a chance to reallocate the stack */
573  |       /* Use copies of these so that the &'s don't force the real ones into memory. */
574  |       YYSTYPE *yyvs1 = yyvs;
575  |       short *yyss1 = yyss;
576  | #ifdef YYLSP_NEEDED
577  |       YYLTYPE *yyls1 = yyls;
578  | #endif
579  | 
580  |       /* Get the current used size of the three stacks, in elements.  */
581  |       int size = yyssp - yyss + 1;
582  | 
583  | #ifdef yyoverflow
584  |       /* Each stack pointer address is followed by the size of
585  | 	 the data in use in that stack, in bytes.  */
586  | #ifdef YYLSP_NEEDED
587  |       /* This used to be a conditional around just the two extra args,
588  | 	 but that might be undefined if yyoverflow is a macro.  */
589  |       yyoverflow("parser stack overflow",
590  | 		 &yyss1, size * sizeof (*yyssp),
591  | 		 &yyvs1, size * sizeof (*yyvsp),
592  | 		 &yyls1, size * sizeof (*yylsp),
593  | 		 &yystacksize);
594  | #else
595  |       yyoverflow("parser stack overflow",
596  | 		 &yyss1, size * sizeof (*yyssp),
597  | 		 &yyvs1, size * sizeof (*yyvsp),
598  | 		 &yystacksize);
599  | #endif
600  | 
601  |       yyss = yyss1; yyvs = yyvs1;
602  | #ifdef YYLSP_NEEDED
603  |       yyls = yyls1;
604  | #endif
605  | #else /* no yyoverflow */
606  |       /* Extend the stack our own way.  */
607  |       if (yystacksize >= YYMAXDEPTH)
608  | 	{
609  | 	  yyerror("parser stack overflow");
610  | 	  if (yyfree_stacks)
611  | 	    {
612  | 	      free (yyss);
613  | 	      free (yyvs);
614  | #ifdef YYLSP_NEEDED
615  | 	      free (yyls);
616  | #endif
617  | 	    }
618  | 	  return 2;
619  | 	}
620  |       yystacksize *= 2;
621  |       if (yystacksize > YYMAXDEPTH)
622  | 	yystacksize = YYMAXDEPTH;
623  | #ifndef YYSTACK_USE_ALLOCA
624  |       yyfree_stacks = 1;
625  | #endif
626  |       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
627  |       __yy_memcpy ((char *)yyss, (char *)yyss1,
628  | 		   size * (unsigned int) sizeof (*yyssp));
629  |       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
630  |       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
631  | 		   size * (unsigned int) sizeof (*yyvsp));
632  | #ifdef YYLSP_NEEDED
633  |       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
634  |       __yy_memcpy ((char *)yyls, (char *)yyls1,
635  | 		   size * (unsigned int) sizeof (*yylsp));
636  | #endif
637  | #endif /* no yyoverflow */
638  | 
639  |       yyssp = yyss + size - 1;
640  |       yyvsp = yyvs + size - 1;
641  | #ifdef YYLSP_NEEDED
642  |       yylsp = yyls + size - 1;
643  | #endif
644  | 
645  | #if YYDEBUG != 0
646  |       if (yydebug)
647  | 	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
648  | #endif
649  | 
650  |       if (yyssp >= yyss + yystacksize - 1)
651  | 	YYABORT;
652  |     }
653  | 
654  | #if YYDEBUG != 0
655  |   if (yydebug)
656  |     fprintf(stderr, "Entering state %d\n", yystate);
657  | #endif
658  | 
659  |   goto yybackup;
660  |  yybackup:
661  | 
662  | /* Do appropriate processing given the current state.  */
663  | /* Read a lookahead token if we need one and don't already have one.  */
664  | /* yyresume: */
665  | 
666  |   /* First try to decide what to do without reference to lookahead token.  */
667  | 
668  |   yyn = yypact[yystate];
669  |   if (yyn == YYFLAG)
670  |     goto yydefault;
671  | 
672  |   /* Not known => get a lookahead token if don't already have one.  */
673  | 
674  |   /* yychar is either YYEMPTY or YYEOF
675  |      or a valid token in external form.  */
676  | 
677  |   if (yychar == YYEMPTY)
678  |     {
679  | #if YYDEBUG != 0
680  |       if (yydebug)
681  | 	fprintf(stderr, "Reading a token: ");
682  | #endif
683  |       yychar = YYLEX;
684  |     }
685  | 
686  |   /* Convert token to internal form (in yychar1) for indexing tables with */
687  | 
688  |   if (yychar <= 0)		/* This means end of input. */
689  |     {
690  |       yychar1 = 0;
691  |       yychar = YYEOF;		/* Don't call YYLEX any more */
692  | 
693  | #if YYDEBUG != 0
694  |       if (yydebug)
695  | 	fprintf(stderr, "Now at end of input.\n");
696  | #endif
697  |     }
698  |   else
699  |     {
700  |       yychar1 = YYTRANSLATE(yychar);
701  | 
702  | #if YYDEBUG != 0
703  |       if (yydebug)
704  | 	{
705  | 	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
706  | 	  /* Give the individual parser a way to print the precise meaning
707  | 	     of a token, for further debugging info.  */
708  | #ifdef YYPRINT
709  | 	  YYPRINT (stderr, yychar, yylval);
710  | #endif
711  | 	  fprintf (stderr, ")\n");
712  | 	}
713  | #endif
714  |     }
715  | 
716  |   yyn += yychar1;
717  |   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
718  |     goto yydefault;
719  | 
720  |   yyn = yytable[yyn];
721  | 
722  |   /* yyn is what to do for this token type in this state.
723  |      Negative => reduce, -yyn is rule number.
724  |      Positive => shift, yyn is new state.
725  |        New state is final state => don't bother to shift,
726  |        just return success.
727  |      0, or most negative number => error.  */
728  | 
729  |   if (yyn < 0)
730  |     {
731  |       if (yyn == YYFLAG)
732  | 	goto yyerrlab;
733  |       yyn = -yyn;
734  |       goto yyreduce;
735  |     }
736  |   else if (yyn == 0)
737  |     goto yyerrlab;
738  | 
739  |   if (yyn == YYFINAL)
740  |     YYACCEPT;
741  | 
742  |   /* Shift the lookahead token.  */
743  | 
744  | #if YYDEBUG != 0
745  |   if (yydebug)
746  |     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
747  | #endif
748  | 
749  |   /* Discard the token being shifted unless it is eof.  */
750  |   if (yychar != YYEOF)
751  |     yychar = YYEMPTY;
752  | 
753  |   *++yyvsp = yylval;
754  | #ifdef YYLSP_NEEDED
755  |   *++yylsp = yylloc;
756  | #endif
757  | 
758  |   /* count tokens shifted since error; after three, turn off error status.  */
759  |   if (yyerrstatus) yyerrstatus--;
760  | 
761  |   yystate = yyn;
762  |   goto yynewstate;
763  | 
764  | /* Do the default action for the current state.  */
765  | yydefault:
766  | 
767  |   yyn = yydefact[yystate];
768  |   if (yyn == 0)
769  |     goto yyerrlab;
770  | 
771  | /* Do a reduction.  yyn is the number of a rule to reduce with.  */
772  | yyreduce:
773  |   yylen = yyr2[yyn];
774  |   if (yylen > 0)
775  |     yyval = yyvsp[1-yylen]; /* implement default value of the action */
776  | 
777  | #if YYDEBUG != 0
778  |   if (yydebug)
779  |     {
780  |       int i;
781  | 
782  |       fprintf (stderr, "Reducing via rule %d (line %d), ",
783  | 	       yyn, yyrline[yyn]);
784  | 
785  |       /* Print the symbols being reduced, and their result.  */
786  |       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
787  | 	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
788  |       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
789  |     }
790  | #endif
791  | 
792  | 
793  |   switch (yyn) {
794  | 
795  | case 2:
796  | { er_yy_tracelog("parsed something\n"); ;
797  |     break;}
798  | case 3:
799  | {
800  | 		  MYABORT;
801  |  		;
802  |     break;}
803  | case 4:
804  | {	
805  | 			lexerr_t *erst = ypar;
806  | 			strncpy(erst->path.name, yyvsp[0].text, 31);
807  | 			mycleanup(ypar);
808  | 			;
809  |     break;}
810  | case 5:
811  | { 
812  | 			lexerr_t *erst = ypar;
813  | 			er_ret_t err;
814  | 
815  | 			erst->path.active = 1;
816  | 			err=er_register_path(&(erst->path), erst->path.name);
817  | 			mycleanup(ypar);
818  | 
819  | 			if( NOERR(err)) {
820  | 				adderr(erst, "created path ");
821  | 				adderr(erst, erst->path.name); 
822  | 			
823  | 			} 
824  | 			else {
825  | 				adderr(erst, "COULD NOT create path ");
826  | 				adderr(erst, erst->path.name);
827  | 				switch( err ) {
828  | 				    case ER_DUPENT:
829  | 					adderr(erst, " - duplicate entry");
830  | 					break;
831  | 				    case ER_INSANE:
832  | 					adderr(erst, " - sanity check not passed");
833  | 					break;
834  | 				}
835  | 				mycleanup(ypar);
836  | 				MYABORT;
837  | 			}
838  | 		     ;
839  |     break;}
840  | case 6:
841  | { 
842  | 			lexerr_t *erst = ypar;
843  | 	
844  | 			if( NOERR(er_delete_path(yyvsp[0].text)) ) {
845  | 			  adderr(erst, " path removed");
846  | 			  mycleanup(ypar);	
847  | 			}
848  | 			else {
849  | 			  adderr(erst, " COULD NOT remove path ");
850  | 			  MYABORT;
851  | 			}
852  | 				
853  | 		      ;
854  |     break;}
855  | case 7:
856  | {
857  | 		lexerr_t *erst = ypar;
858  | 
859  | 		erst->path.active = 1;
860  | 		if( NOERR(er_modify_path(&(erst->path), yyvsp[-1].text))) {
861  | 				adderr(erst, "modified path ");
862  | 				adderr(erst, yyvsp[-1].text); 
863  | 				mycleanup(ypar);
864  | 			} 
865  | 			else {
866  | 				adderr(erst, " COULD NOT modify path ");
867  | 				adderr(erst, yyvsp[-1].text);
868  | 				MYABORT;
869  | 			}
870  | 		;
871  |     break;}
872  | case 8:
873  | { 
874  | 			lexerr_t *erst = ypar;
875  | 			
876  | 			if( NOERR(er_delete_filter(yyvsp[-2].text, (unsigned) yyvsp[0].inum))) {	
877  | 				adderr(erst, "modified path ");
878  | 				adderr(erst, yyvsp[-2].text); 
879  | 				mycleanup(ypar);
880  | 			}
881  | 			else {
882  | 				adderr(erst, " COULD NOT remove filter ");
883  | 				adderr(erst, "from path ");
884  | 				adderr(erst, yyvsp[-2].text);
885  | 				MYABORT;	
886  | 			}
887  | 
888  | 		 ;
889  |     break;}
890  | case 9:
891  | {
892  | 	lexerr_t *erst = ypar;
893  | 			
894  | 	if( NOERR(er_attach_filter_chain(yyvsp[-2].text, erst->path.filters ))) {	
895  | 			adderr(erst, "modified path ");
896  | 			adderr(erst, yyvsp[-2].text); 
897  | 			mycleanup(ypar);
898  | 		}
899  | 	else {
900  | 	 		adderr(erst, " COULD NOT attach filters to path ");
901  | 			adderr(erst, yyvsp[-2].text);
902  | 			MYABORT;	
903  | 	}
904  |     ;
905  |     break;}
906  | case 10:
907  | { yyval.text = yyvsp[0].text; ;
908  |     break;}
909  | case 11:
910  | { yyval.text = "AUTO"/* if AUTO then generate a new one */ ;
911  |     break;}
912  | case 12:
913  | {
914  | 			 	  er_yy_tracelog("set path");
915  | 		                  ;
916  |     break;}
917  | case 13:
918  | { ;
919  |     break;}
920  | case 14:
921  | { ;
922  |     break;}
923  | case 15:
924  | { ;
925  |     break;}
926  | case 16:
927  | { lexerr_t *erst = ypar; 
928  | 			  adderr(erst, " - wrong PATH keyword"); 
929  | 			  MYABORT; ;
930  |     break;}
931  | case 18:
932  | { lexerr_t *erst = ypar;
933  | 			adderr(erst, " - format spec missing"); 
934  | 			MYABORT; ;
935  |     break;}
936  | case 21:
937  | { 
938  | 		lexerr_t *erst = ypar;
939  | 		int mod = er_getformatval(yyvsp[0].text); 
940  | 
941  | 		if( mod ) {
942  | 			erst->path.format |= mod;
943  | 			er_yy_tracelog("mode %s = 0x%x\n", yyvsp[0].text, mod); 
944  | 			mycleanup(ypar);
945  | 		} else {
946  | 			adderr(erst, " incorrect mode specification: ");
947  | 			adderr(erst, yyvsp[0].text);
948  | 			mycleanup(ypar);
949  | 			MYABORT; 
950  | 		}
951  | 	   ;
952  |     break;}
953  | case 22:
954  | { 
955  | 		lexerr_t *erst = ypar;
956  | 		erst->path.type = ER_PATH_SOCK;
957  | 		erst->path.descr.sock.fd = yyvsp[0].inum;
958  | 		er_yy_tracelog("socket. Now check the associated socket\n"); 
959  | 	;
960  |     break;}
961  | case 23:
962  | {
963  | 			lexerr_t *erst = ypar;
964  | 			erst->path.type = ER_PATH_NAME;
965  | 			er_yy_tracelog("namespec is %s\n", yyvsp[-1].text); 
966  | 			strcpy(erst->path.descr.name.filename, yyvsp[-1].text);
967  | 			mycleanup(ypar); 
968  | 			;
969  |     break;}
970  | case 24:
971  | { lexerr_t *erst = ypar;
972  | 				adderr(erst, " - filename missing"); 
973  | 				MYABORT; ;
974  |     break;}
975  | case 26:
976  | {
977  | 			lexerr_t *erst = ypar;
978  | 			erst->path.descr.name.date = 1;
979  | 		;
980  |     break;}
981  | case 27:
982  | {
983  | 			lexerr_t *erst = ypar;
984  | 			erst->path.type = ER_PATH_EXEC;	
985  | 		 ;
986  |     break;}
987  | case 29:
988  | {
989  | 			lexerr_t *erst = ypar;
990  | 			erst->path.descr.exec.usepath = 1;
991  | 			;
992  |     break;}
993  | case 30:
994  | { /* first element */
995  | 		  lexerr_t *erst = ypar;
996  | 		  er_add_exec_arg( &(erst->path), erst->token);
997  | 		  mycleanup(ypar); 
998  | 		  ;
999  |     break;}
1000 | case 31:
1001 | { /* next elements */
1002 | 		  lexerr_t *erst = ypar;
1003 | 		  er_add_exec_arg( &(erst->path), erst->token);
1004 | 		  mycleanup(ypar);
1005 | 		  ;
1006 |     break;}
1007 | case 34:
1008 | { er_yy_tracelog("one more filter done\n"); ;
1009 |     break;}
1010 | case 35:
1011 | { 
1012 | 			lexerr_t *erst = ypar;
1013 | 			/* add to list */
1014 | 			er_add_filter( &erst->path,  &(erst->curfilt)); 
1015 | 			er_yy_tracelog("added a filter\n"); 	
1016 | 			memset( &(erst->curfilt), 0, sizeof(er_filter_t) );
1017 | 			;
1018 |     break;}
1019 | case 36:
1020 | {;
1021 |     break;}
1022 | case 37:
1023 | { lexerr_t *erst = ypar;
1024 | 			adderr(erst, " - bad filter spec"); 
1025 | 			MYABORT; 
1026 | 		;
1027 |     break;}
1028 | case 38:
1029 | {;
1030 |     break;}
1031 | case 39:
1032 | {;
1033 |     break;}
1034 | case 41:
1035 | {;
1036 |     break;}
1037 | case 43:
1038 | {
1039 | 			lexerr_t *erst = ypar;
1040 | 			erst->curfilt.thr_id = pthread_self();
1041 | 			;
1042 |     break;}
1043 | case 45:
1044 | { 
1045 | 		er_yy_tracelog("added fac to mask\n"); 
1046 | 		;
1047 |     break;}
1048 | case 46:
1049 | {   
1050 | 		  lexerr_t *erst = ypar;
1051 | 		  erst->curfilt.fac_mask = er_getfacallmask();
1052 | 		;
1053 |     break;}
1054 | case 47:
1055 | { 
1056 | 		lexerr_t *erst = ypar;
1057 | 		er_ret_t ef = er_getfacval(yyvsp[0].text); 
1058 | 
1059 | 		if( ef ) {
1060 | 			MA_set( &(erst->curfilt.fac_mask), (unsigned) ef, 1);
1061 | 			er_yy_tracelog("fac %s = %x\n", yyvsp[0].text, ef);
1062 | 			mycleanup(ypar);
1063 | 		} else {
1064 | 			adderr(erst, " incorrect fac specification: ");
1065 | 			adderr(erst, yyvsp[0].text);
1066 | 			mycleanup(ypar);
1067 | 			MYABORT; 
1068 | 		}
1069 | 	   ;
1070 |     break;}
1071 | case 50:
1072 | {
1073 | 			mysetsev(ypar, 0, "D")
1074 | 			;
1075 |     break;}
1076 | case 51:
1077 | { if( mysetsev(ypar, 0, yyvsp[0].text) == 0 ) {
1078 | 			MYABORT; 
1079 | 		   }
1080 | 		 ;
1081 |     break;}
1082 | case 52:
1083 | {
1084 | 			mysetsev(ypar, 1, "F")
1085 |          		;
1086 |     break;}
1087 | case 53:
1088 | { if( mysetsev(ypar, 1, yyvsp[0].text) == 0 ) {
1089 | 			MYABORT; 	
1090 | 		   } 
1091 | 		 ;
1092 |     break;}
1093 | case 54:
1094 | {
1095 | 		  char *cp = strdup(yyvsp[0].text);
1096 | 		  if( mysetsev(ypar, 0, yyvsp[0].text) != 0 ) {
1097 | 		      mysetsev(ypar, 1, cp);
1098 | 		      mycleanup(ypar);	
1099 | 		  }
1100 | 		  else {
1101 | 			free(cp);
1102 | 			MYABORT; 	
1103 | 		   } 
1104 | 		;
1105 |     break;}
1106 | case 56:
1107 | { 
1108 | 			er_yy_tracelog("added onefac\n");
1109 | 			;
1110 |     break;}
1111 | case 57:
1112 | { lexerr_t *erst = ypar;
1113 | 		 er_mask_t em = er_getaspval(yyvsp[0].text);
1114 | 
1115 | 		 if(em != 0) {
1116 | 			erst->curfilt.asp_mask |= em;
1117 | 			er_yy_tracelog("asp %s = %x\n", yyvsp[0].text, em);
1118 | 			mycleanup(ypar);
1119 | 		 } 
1120 | 		 else {
1121 | 			adderr(erst, " incorrect asp specification: ");
1122 | 			adderr(erst, yyvsp[0].text);
1123 | 			mycleanup(ypar);
1124 | 			MYABORT; 
1125 | 		      }
1126 | 		;
1127 |     break;}
1128 | case 58:
1129 | {
1130 | 		lexerr_t *erst = ypar;
1131 | 		erst->curfilt.asp_mask |= yyvsp[0].inum;
1132 | 		mycleanup(ypar);
1133 | 		;
1134 |     break;}
1135 | }
1136 |    /* the action file gets copied in in place of this dollarsign */
1137 | 
1138 | 
1139 |   yyvsp -= yylen;
1140 |   yyssp -= yylen;
1141 | #ifdef YYLSP_NEEDED
1142 |   yylsp -= yylen;
1143 | #endif
1144 | 
1145 | #if YYDEBUG != 0
1146 |   if (yydebug)
1147 |     {
1148 |       short *ssp1 = yyss - 1;
1149 |       fprintf (stderr, "state stack now");
1150 |       while (ssp1 != yyssp)
1151 | 	fprintf (stderr, " %d", *++ssp1);
1152 |       fprintf (stderr, "\n");
1153 |     }
1154 | #endif
1155 | 
1156 |   *++yyvsp = yyval;
1157 | 
1158 | #ifdef YYLSP_NEEDED
1159 |   yylsp++;
1160 |   if (yylen == 0)
1161 |     {
1162 |       yylsp->first_line = yylloc.first_line;
1163 |       yylsp->first_column = yylloc.first_column;
1164 |       yylsp->last_line = (yylsp-1)->last_line;
1165 |       yylsp->last_column = (yylsp-1)->last_column;
1166 |       yylsp->text = 0;
1167 |     }
1168 |   else
1169 |     {
1170 |       yylsp->last_line = (yylsp+yylen-1)->last_line;
1171 |       yylsp->last_column = (yylsp+yylen-1)->last_column;
1172 |     }
1173 | #endif
1174 | 
1175 |   /* Now "shift" the result of the reduction.
1176 |      Determine what state that goes to,
1177 |      based on the state we popped back to
1178 |      and the rule number reduced by.  */
1179 | 
1180 |   yyn = yyr1[yyn];
1181 | 
1182 |   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1183 |   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1184 |     yystate = yytable[yystate];
1185 |   else
1186 |     yystate = yydefgoto[yyn - YYNTBASE];
1187 | 
1188 |   goto yynewstate;
1189 | 
1190 | yyerrlab:   /* here on detecting error */
1191 | 
1192 |   if (! yyerrstatus)
1193 |     /* If not already recovering from an error, report this error.  */
1194 |     {
1195 |       ++yynerrs;
1196 | 
1197 | #ifdef YYERROR_VERBOSE
1198 |       yyn = yypact[yystate];
1199 | 
1200 |       if (yyn > YYFLAG && yyn < YYLAST)
1201 | 	{
1202 | 	  int size = 0;
1203 | 	  char *msg;
1204 | 	  int x, count;
1205 | 
1206 | 	  count = 0;
1207 | 	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1208 | 	  for (x = (yyn < 0 ? -yyn : 0);
1209 | 	       x < (sizeof(yytname) / sizeof(char *)); x++)
1210 | 	    if (yycheck[x + yyn] == x)
1211 | 	      size += strlen(yytname[x]) + 15, count++;
1212 | 	  msg = (char *) malloc(size + 15);
1213 | 	  if (msg != 0)
1214 | 	    {
1215 | 	      strcpy(msg, "parse error");
1216 | 
1217 | 	      if (count < 5)
1218 | 		{
1219 | 		  count = 0;
1220 | 		  for (x = (yyn < 0 ? -yyn : 0);
1221 | 		       x < (sizeof(yytname) / sizeof(char *)); x++)
1222 | 		    if (yycheck[x + yyn] == x)
1223 | 		      {
1224 | 			strcat(msg, count == 0 ? ", expecting `" : " or `");
1225 | 			strcat(msg, yytname[x]);
1226 | 			strcat(msg, "'");
1227 | 			count++;
1228 | 		      }
1229 | 		}
1230 | 	      yyerror(msg);
1231 | 	      free(msg);
1232 | 	    }
1233 | 	  else
1234 | 	    yyerror ("parse error; also virtual memory exceeded");
1235 | 	}
1236 |       else
1237 | #endif /* YYERROR_VERBOSE */
1238 | 	yyerror("parse error");
1239 |     }
1240 | 
1241 |   goto yyerrlab1;
1242 | yyerrlab1:   /* here on error raised explicitly by an action */
1243 | 
1244 |   if (yyerrstatus == 3)
1245 |     {
1246 |       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1247 | 
1248 |       /* return failure if at end of input */
1249 |       if (yychar == YYEOF)
1250 | 	YYABORT;
1251 | 
1252 | #if YYDEBUG != 0
1253 |       if (yydebug)
1254 | 	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1255 | #endif
1256 | 
1257 |       yychar = YYEMPTY;
1258 |     }
1259 | 
1260 |   /* Else will try to reuse lookahead token
1261 |      after shifting the error token.  */
1262 | 
1263 |   yyerrstatus = 3;		/* Each real token shifted decrements this */
1264 | 
1265 |   goto yyerrhandle;
1266 | 
1267 | yyerrdefault:  /* current state does not do anything special for the error token. */
1268 | 
1269 | #if 0
1270 |   /* This is wrong; only states that explicitly want error tokens
1271 |      should shift them.  */
1272 |   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1273 |   if (yyn) goto yydefault;
1274 | #endif
1275 | 
1276 | yyerrpop:   /* pop the current state because it cannot handle the error token */
1277 | 
1278 |   if (yyssp == yyss) YYABORT;
1279 |   yyvsp--;
1280 |   yystate = *--yyssp;
1281 | #ifdef YYLSP_NEEDED
1282 |   yylsp--;
1283 | #endif
1284 | 
1285 | #if YYDEBUG != 0
1286 |   if (yydebug)
1287 |     {
1288 |       short *ssp1 = yyss - 1;
1289 |       fprintf (stderr, "Error: state stack now");
1290 |       while (ssp1 != yyssp)
1291 | 	fprintf (stderr, " %d", *++ssp1);
1292 |       fprintf (stderr, "\n");
1293 |     }
1294 | #endif
1295 | 
1296 | yyerrhandle:
1297 | 
1298 |   yyn = yypact[yystate];
1299 |   if (yyn == YYFLAG)
1300 |     goto yyerrdefault;
1301 | 
1302 |   yyn += YYTERROR;
1303 |   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1304 |     goto yyerrdefault;
1305 | 
1306 |   yyn = yytable[yyn];
1307 |   if (yyn < 0)
1308 |     {
1309 |       if (yyn == YYFLAG)
1310 | 	goto yyerrpop;
1311 |       yyn = -yyn;
1312 |       goto yyreduce;
1313 |     }
1314 |   else if (yyn == 0)
1315 |     goto yyerrpop;
1316 | 
1317 |   if (yyn == YYFINAL)
1318 |     YYACCEPT;
1319 | 
1320 | #if YYDEBUG != 0
1321 |   if (yydebug)
1322 |     fprintf(stderr, "Shifting error token, ");
1323 | #endif
1324 | 
1325 |   *++yyvsp = yylval;
1326 | #ifdef YYLSP_NEEDED
1327 |   *++yylsp = yylloc;
1328 | #endif
1329 | 
1330 |   yystate = yyn;
1331 |   goto yynewstate;
1332 | 
1333 |  yyacceptlab:
1334 |   /* YYACCEPT comes here.  */
1335 |   if (yyfree_stacks)
1336 |     {
1337 |       free (yyss);
1338 |       free (yyvs);
1339 | #ifdef YYLSP_NEEDED
1340 |       free (yyls);
1341 | #endif
1342 |     }
1343 |   return 0;
1344 | 
1345 |  yyabortlab:
1346 |   /* YYABORT comes here.  */
1347 |   if (yyfree_stacks)
1348 |     {
1349 |       free (yyss);
1350 |       free (yyvs);
1351 | #ifdef YYLSP_NEEDED
1352 |       free (yyls);
1353 | #endif
1354 |     }
1355 |   return 1;
1356 | }
1357 | 
1358 | 
1359 | #include "er_yacc_helper.inc"