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