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_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)
     /* [<][>][^][v][top][bottom][index][help] */
  54 
  55 #define adderr(a,b) {strcat(a->errtxt,b);}
     /* [<][>][^][v][top][bottom][index][help] */
  56 
  57 #define myfree(mem) {lexerr_t *erst = ypar; free(mem); erst->token = NULL} 
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
  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)
     /* [<][>][^][v][top][bottom][index][help] */
 345 #define YYBACKUP(token, value) \
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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)
     /* [<][>][^][v][top][bottom][index][help] */
 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"

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