modules/er/er.yacc.tab.c

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. er_yyerror
  2. adderr
  3. myfree
  4. YYTRANSLATE
  5. YYRECOVERING
  6. YYBACKUP
  7. __yy_memcpy
  8. __yy_memcpy
  9. __yy_memcpy
  10. 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 #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)
     /* [<][>][^][v][top][bottom][index][help] */
  52 
  53 #define adderr(a,b) {strcat(a->errtxt,b);}
     /* [<][>][^][v][top][bottom][index][help] */
  54 
  55 #define myfree(mem) {lexerr_t *erst = ypar; free(mem); erst->token = NULL} 
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
 343 #define YYBACKUP(token, value) \
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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"

/* [<][>][^][v][top][bottom][index][help] */