/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following functions.
- YYSTYPE
- __yy_memcpy
- __yy_memcpy
- yyparse
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;
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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"