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"