modules/er/er.yacc.tab.c

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

DEFINITIONS

This source file includes following functions.
  1. YYSTYPE
  2. __yy_memcpy
  3. __yy_memcpy
  4. yyparse

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

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