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