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

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

## FUNCTIONS

This source file includes following functions.

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

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

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