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

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

## DEFINITIONS

This source file includes following functions.

1. YYSTYPE
2. __yy_memcpy
3. __yy_memcpy
4. yyparse

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

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