## modules/er/er.yacc.tab.c

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

## FUNCTIONS

This source file includes following functions.

1. er_yyerror
2. adderr
3. myfree
4. YYTRANSLATE
5. YYRECOVERING
6. YYBACKUP
7. __yy_memcpy
8. __yy_memcpy
9. __yy_memcpy
10. yyparse

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

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