perly.c

   1 /*    perly.c
   2  *
   3  *    Copyright (c) 2004, 2005, 2006 Larry Wall and others
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  *    Note that this file was originally generated as an output from
   9  *    GNU bison version 1.875, but now the code is statically maintained
  10  *    and edited; the bits that are dependent on perly.y/madly.y are now
  11  *    #included from the files perly.tab/madly.tab and perly.act/madly.act.
  12  *
  13  *    Here is an important copyright statement from the original, generated
  14  *    file:
  15  *
  16  *      As a special exception, when this file is copied by Bison into a
  17  *      Bison output file, you may use that output file without
  18  *      restriction.  This special exception was added by the Free
  19  *      Software Foundation in version 1.24 of Bison.
  20  *
  21  * Note that this file is also #included in madly.c, to allow compilation
  22  * of a second parser, Perl_madparse, that is identical to Perl_yyparse,
  23  * but which includes the parser tables from madly.{tab,act} rather than
  24  * perly.{tab,act}. This is controlled by the PERL_IN_MADLY_C define.
  25  */
  26
  27
  28
  29 /* allow stack size to grow effectively without limit */
  30 #define YYMAXDEPTH 10000000
  31
  32 #include "EXTERN.h"
  33 #define PERL_IN_PERLY_C
  34 #include "perl.h"
  35
  36 typedef unsigned char yytype_uint8;
  37 typedef signed char yytype_int8;
  38 typedef unsigned short int yytype_uint16;
  39 typedef short int yytype_int16;
  40 typedef signed char yysigned_char;
  41
  42 #ifdef DEBUGGING
  43 #  define YYDEBUG 1
  44 #else
  45 #  define YYDEBUG 0
  46 #endif
  47
  48 /* contains all the parser state tables; auto-generated from perly.y/madly.y */
  49 #ifdef PERL_IN_MADLY_C
  50 #  include "madly.tab"
  51 #else
  52 #  include "perly.tab"
  53 #endif
  54
  55 # define YYSIZE_T size_t
  56
  57 #define yyerrok         (yyerrstatus = 0)
  58 #define yyclearin       (yychar = YYEMPTY)
  59 #define YYEMPTY         (-2)
  60 #define YYEOF           0
  61
  62 #define YYACCEPT        goto yyacceptlab
  63 #define YYABORT         goto yyabortlab
  64 #define YYERROR         goto yyerrlab1
  65
  66
  67 /* Like YYERROR except do call yyerror.  This remains here temporarily
  68    to ease the transition to the new meaning of YYERROR, for GCC.
  69    Once GCC version 2 has supplanted version 1, this can go.  */
  70
  71 #define YYFAIL          goto yyerrlab
  72
  73 #define YYRECOVERING()  (!!yyerrstatus)
  74
  75 #define YYBACKUP(Token, Value)                                  \
  76 do                                                              \
  77     if (yychar == YYEMPTY && yylen == 1) {                      \
  78         yychar = (Token);                                       \
  79         yylval = (Value);                                       \
  80         yytoken = YYTRANSLATE (yychar);                         \
  81         YYPOPSTACK;                                             \
  82         goto yybackup;                                          \
  83     }                                                           \
  84     else {                                                      \
  85         yyerror ("syntax error: cannot back up");               \
  86         YYERROR;                                                \
  87     }                                                           \
  88 while (0)
  89
  90 #define YYTERROR        1
  91 #define YYERRCODE       256
  92
  93 /* Enable debugging if requested.  */
  94 #ifdef DEBUGGING
  95
  96 #  define yydebug (DEBUG_p_TEST)
  97
  98 #  define YYFPRINTF PerlIO_printf
  99
 100 #  define YYDPRINTF(Args)                       \
 101 do {                                            \
 102     if (yydebug)                                \
 103         YYFPRINTF Args;                         \
 104 } while (0)
 105
 106 #  define YYDSYMPRINTF(Title, Token, Value)                     \
 107 do {                                                            \
 108     if (yydebug) {                                              \
 109         YYFPRINTF (Perl_debug_log, "%s ", Title);               \
 110         yysymprint (aTHX_ Perl_debug_log,  Token, Value);       \
 111         YYFPRINTF (Perl_debug_log, "\n");                       \
 112     }                                                           \
 113 } while (0)
 114
 115 /*--------------------------------.
 116 | Print this symbol on YYOUTPUT.  |
 117 `--------------------------------*/
 118
 119 static void
 120 yysymprint(pTHX_ PerlIO * const yyoutput, int yytype, const YYSTYPE * const yyvaluep)
 121 {
 122     if (yytype < YYNTOKENS) {
 123         YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
 124 #   ifdef YYPRINT
 125         YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 126 #   else
 127         YYFPRINTF (yyoutput, "0x%"UVxf, (UV)yyvaluep->ival);
 128 #   endif
 129     }
 130     else
 131         YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
 132
 133     YYFPRINTF (yyoutput, ")");
 134 }
 135
 136
 137 /*  yy_stack_print()
 138  *  print the top 8 items on the parse stack.  The args have the same
 139  *  meanings as the local vars in yyparse() of the same name */
 140
 141 static void
 142 yy_stack_print (pTHX_ const short *yyss, const short *yyssp, const YYSTYPE *yyvs, const char**yyns)
 143 {
 144     int i;
 145     int start = 1;
 146     int count = (int)(yyssp - yyss);
 147
 148     if (count > 8) {
 149         start = count - 8 + 1;
 150         count = 8;
 151     }
 152
 153     PerlIO_printf(Perl_debug_log, "\nindex:");
 154     for (i=0; i < count; i++)
 155         PerlIO_printf(Perl_debug_log, " %8d", start+i);
 156     PerlIO_printf(Perl_debug_log, "\nstate:");
 157     for (i=0; i < count; i++)
 158         PerlIO_printf(Perl_debug_log, " %8d", yyss[start+i]);
 159     PerlIO_printf(Perl_debug_log, "\ntoken:");
 160     for (i=0; i < count; i++)
 161         PerlIO_printf(Perl_debug_log, " %8.8s", yyns[start+i]);
 162     PerlIO_printf(Perl_debug_log, "\nvalue:");
 163     for (i=0; i < count; i++) {
 164         if (yy_is_opval[yystos[yyss[start+i]]]) {
 165             PerlIO_printf(Perl_debug_log, " %8.8s",
 166                   yyvs[start+i].opval
 167                     ? PL_op_name[yyvs[start+i].opval->op_type]
 168                     : "NULL"
 169             );
 170         }
 171         else
 172             PerlIO_printf(Perl_debug_log, " %8"UVxf, (UV)yyvs[start+i].ival);
 173     }
 174     PerlIO_printf(Perl_debug_log, "\n\n");
 175 }
 176
 177 #  define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns)               \
 178 do {                                                            \
 179     if (yydebug && DEBUG_v_TEST)                                \
 180         yy_stack_print (aTHX_ (yyss), (yyssp), (yyvs), (yyns)); \
 181 } while (0)
 182
 183
 184 /*------------------------------------------------.
 185 | Report that the YYRULE is going to be reduced.  |
 186 `------------------------------------------------*/
 187
 188 static void
 189 yy_reduce_print (pTHX_ int yyrule)
 190 {
 191     int yyi;
 192     const unsigned int yylineno = yyrline[yyrule];
 193     YYFPRINTF (Perl_debug_log, "Reducing stack by rule %d (line %u), ",
 194                           yyrule - 1, yylineno);
 195     /* Print the symbols being reduced, and their result.  */
 196     for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
 197         YYFPRINTF (Perl_debug_log, "%s ", yytname [yyrhs[yyi]]);
 198     YYFPRINTF (Perl_debug_log, "-> %s\n", yytname [yyr1[yyrule]]);
 199 }
 200
 201 #  define YY_REDUCE_PRINT(Rule)         \
 202 do {                                    \
 203     if (yydebug)                        \
 204         yy_reduce_print (aTHX_ Rule);           \
 205 } while (0)
 206
 207 #else /* !DEBUGGING */
 208 #  define YYDPRINTF(Args)
 209 #  define YYDSYMPRINTF(Title, Token, Value)
 210 #  define YY_STACK_PRINT(yyss, yyssp, yyvs, yyns)
 211 #  define YY_REDUCE_PRINT(Rule)
 212 #endif /* !DEBUGGING */
 213
 214
 215 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 216 #ifndef YYINITDEPTH
 217 # define YYINITDEPTH 200
 218 #endif
 219
 220
 221 #if YYERROR_VERBOSE
 222 #  ifndef yystrlen
 223 #    if defined (__GLIBC__) && defined (_STRING_H)
 224 #      define yystrlen strlen
 225 #    else
 226 /* Return the length of YYSTR.  */
 227 static YYSIZE_T
 228 yystrlen (const char *yystr)
 229 {
 230     register const char *yys = yystr;
 231
 232     while (*yys++ != '\0')
 233         continue;
 234
 235     return yys - yystr - 1;
 236 }
 237 #    endif
 238 #  endif
 239
 240 #  ifndef yystpcpy
 241 #    if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 242 #      define yystpcpy stpcpy
 243 #    else
 244 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 245    YYDEST.  */
 246 static char *
 247 yystpcpy (pTHX_ char *yydest, const char *yysrc)
 248 {
 249     register char *yyd = yydest;
 250     register const char *yys = yysrc;
 251
 252     while ((*yyd++ = *yys++) != '\0')
 253         continue;
 254
 255     return yyd - 1;
 256 }
 257 #    endif
 258 #  endif
 259
 260 #endif /* !YYERROR_VERBOSE */
 261
 262 /*----------.
 263 | yyparse.  |
 264 `----------*/
 265
 266 int
 267 #ifdef PERL_IN_MADLY_C
 268 Perl_madparse (pTHX)
 269 #else
 270 Perl_yyparse (pTHX)
 271 #endif
 272 {
 273     dVAR;
 274     int yychar; /* The lookahead symbol.  */
 275     YYSTYPE yylval; /* The semantic value of the lookahead symbol.  */
 276     int yynerrs; /* Number of syntax errors so far.  */
 277     register int yystate;
 278     register int yyn;
 279     int yyresult;
 280
 281     /* Number of tokens to shift before error messages enabled.  */
 282     int yyerrstatus;
 283     /* Lookahead token as an internal (translated) token number.  */
 284     int yytoken = 0;
 285
 286     /* two stacks and their tools:
 287           yyss: related to states,
 288           yyvs: related to semantic values,
 289
 290           Refer to the stacks thru separate pointers, to allow yyoverflow
 291           to reallocate them elsewhere.  */
 292
 293     /* The state stack.  */
 294     short *yyss;
 295     register short *yyssp;
 296
 297     /* The semantic value stack.  */
 298     YYSTYPE *yyvs;
 299     register YYSTYPE *yyvsp;
 300
 301     /* for ease of re-allocation and automatic freeing, have two SVs whose
 302       * SvPVX points to the stacks */
 303     SV *yyss_sv, *yyvs_sv;
 304
 305 #ifdef DEBUGGING
 306     /* maintain also a stack of token/rule names for debugging with -Dpv */
 307     const char **yyns, **yynsp;
 308     SV *yyns_sv;
 309 #  define YYPOPSTACK   (yyvsp--, yyssp--, yynsp--)
 310 #else
 311 #  define YYPOPSTACK   (yyvsp--, yyssp--)
 312 #endif
 313
 314
 315     YYSIZE_T yystacksize = YYINITDEPTH;
 316
 317     /* The variables used to return semantic value and location from the
 318           action routines.  */
 319     YYSTYPE yyval;
 320
 321
 322     /* When reducing, the number of symbols on the RHS of the reduced
 323           rule.  */
 324     int yylen;
 325
 326 #ifndef PERL_IN_MADLY_C
 327 #  ifdef PERL_MAD
 328     if (PL_madskills)
 329         return madparse();
 330 #  endif
 331 #endif
 332
 333     YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
 334
 335     ENTER;                      /* force stack free before we return */
 336     SAVEVPTR(PL_yycharp);
 337     SAVEVPTR(PL_yylvalp);
 338     PL_yycharp = &yychar; /* so PL_yyerror() can access it */
 339     PL_yylvalp = &yylval; /* so various functions in toke.c can access it */
 340
 341     yyss_sv = newSV(YYINITDEPTH * sizeof(short));
 342     yyvs_sv = newSV(YYINITDEPTH * sizeof(YYSTYPE));
 343     SAVEFREESV(yyss_sv);
 344     SAVEFREESV(yyvs_sv);
 345     yyss = (short *) SvPVX(yyss_sv);
 346     yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
 347     /* note that elements zero of yyvs and yyns are not used */
 348     yyssp = yyss;
 349     yyvsp = yyvs;
 350 #ifdef DEBUGGING
 351     yyns_sv = newSV(YYINITDEPTH * sizeof(char *));
 352     SAVEFREESV(yyns_sv);
 353     /* XXX This seems strange to cast char * to char ** */
 354     yyns = (const char **) SvPVX(yyns_sv);
 355     yynsp = yyns;
 356 #endif
 357
 358     yystate = 0;
 359     yyerrstatus = 0;
 360     yynerrs = 0;
 361     yychar = YYEMPTY;           /* Cause a token to be read.  */
 362
 363     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 364
 365     goto yysetstate;
 366
 367 /*------------------------------------------------------------.
 368 | yynewstate -- Push a new state, which is found in yystate.  |
 369 `------------------------------------------------------------*/
 370   yynewstate:
 371     /* In all cases, when you get here, the value and location stacks
 372           have just been pushed. so pushing a state here evens the stacks.
 373           */
 374     yyssp++;
 375
 376   yysetstate:
 377     *yyssp = yystate;
 378
 379     if (yyss + yystacksize - 1 <= yyssp) {
 380          /* Get the current used size of the three stacks, in elements.  */
 381          const YYSIZE_T yysize = yyssp - yyss + 1;
 382
 383          /* Extend the stack our own way.  */
 384          if (YYMAXDEPTH <= yystacksize)
 385                goto yyoverflowlab;
 386          yystacksize *= 2;
 387          if (YYMAXDEPTH < yystacksize)
 388                yystacksize = YYMAXDEPTH;
 389
 390          SvGROW(yyss_sv, yystacksize * sizeof(short));
 391          SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE));
 392          yyss = (short *) SvPVX(yyss_sv);
 393          yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
 394 #ifdef DEBUGGING
 395          SvGROW(yyns_sv, yystacksize * sizeof(char *));
 396          /* XXX This seems strange to cast char * to char ** */
 397          yyns = (const char **) SvPVX(yyns_sv);
 398          if (! yyns)
 399                goto yyoverflowlab;
 400          yynsp = yyns + yysize - 1;
 401 #endif
 402          if (!yyss || ! yyvs)
 403                goto yyoverflowlab;
 404
 405          yyssp = yyss + yysize - 1;
 406          yyvsp = yyvs + yysize - 1;
 407
 408
 409          YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
 410                                    (unsigned long int) yystacksize));
 411
 412          if (yyss + yystacksize - 1 <= yyssp)
 413                YYABORT;
 414     }
 415
 416     goto yybackup;
 417
 418   /*-----------.
 419   | yybackup.  |
 420   `-----------*/
 421   yybackup:
 422
 423 /* Do appropriate processing given the current state.  */
 424 /* Read a lookahead token if we need one and don't already have one.  */
 425 /* yyresume: */
 426
 427     /* First try to decide what to do without reference to lookahead token.  */
 428
 429     yyn = yypact[yystate];
 430     if (yyn == YYPACT_NINF)
 431         goto yydefault;
 432
 433     /* Not known => get a lookahead token if don't already have one.  */
 434
 435     /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
 436     if (yychar == YYEMPTY) {
 437         YYDPRINTF ((Perl_debug_log, "Reading a token: "));
 438 #ifndef PERL_IN_MADLY_C
 439 #  ifdef PERL_MAD
 440         yychar = PL_madskills ? madlex() : yylex();
 441 #  else
 442         yychar = yylex();
 443 #  endif
 444 #endif
 445
 446 #  ifdef EBCDIC
 447         if (yychar >= 0 && yychar < 255) {
 448             yychar = NATIVE_TO_ASCII(yychar);
 449         }
 450 #  endif
 451     }
 452
 453     if (yychar <= YYEOF) {
 454         yychar = yytoken = YYEOF;
 455         YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
 456     }
 457     else {
 458         yytoken = YYTRANSLATE (yychar);
 459         YYDSYMPRINTF ("Next token is", yytoken, &yylval);
 460     }
 461
 462     /* If the proper action on seeing token YYTOKEN is to reduce or to
 463           detect an error, take that action.  */
 464     yyn += yytoken;
 465     if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
 466         goto yydefault;
 467     yyn = yytable[yyn];
 468     if (yyn <= 0) {
 469         if (yyn == 0 || yyn == YYTABLE_NINF)
 470             goto yyerrlab;
 471         yyn = -yyn;
 472         goto yyreduce;
 473     }
 474
 475     if (yyn == YYFINAL)
 476         YYACCEPT;
 477
 478     /* Shift the lookahead token.  */
 479     YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
 480
 481     /* Discard the token being shifted unless it is eof.  */
 482     if (yychar != YYEOF)
 483         yychar = YYEMPTY;
 484
 485     *++yyvsp = yylval;
 486 #ifdef DEBUGGING
 487     *++yynsp = (const char *)(yytname[yytoken]);
 488 #endif
 489
 490
 491     /* Count tokens shifted since error; after three, turn off error
 492           status.  */
 493     if (yyerrstatus)
 494         yyerrstatus--;
 495
 496     yystate = yyn;
 497     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 498
 499     goto yynewstate;
 500
 501
 502   /*-----------------------------------------------------------.
 503   | yydefault -- do the default action for the current state.  |
 504   `-----------------------------------------------------------*/
 505   yydefault:
 506     yyn = yydefact[yystate];
 507     if (yyn == 0)
 508         goto yyerrlab;
 509     goto yyreduce;
 510
 511
 512   /*-----------------------------.
 513   | yyreduce -- Do a reduction.  |
 514   `-----------------------------*/
 515   yyreduce:
 516     /* yyn is the number of a rule to reduce with.  */
 517     yylen = yyr2[yyn];
 518
 519     /* If YYLEN is nonzero, implement the default value of the action:
 520       "$$ = $1".
 521
 522       Otherwise, the following line sets YYVAL to garbage.
 523       This behavior is undocumented and Bison
 524       users should not rely upon it.  Assigning to YYVAL
 525       unconditionally makes the parser a bit smaller, and it avoids a
 526       GCC warning that YYVAL may be used uninitialized.  */
 527     yyval = yyvsp[1-yylen];
 528
 529
 530     YY_REDUCE_PRINT (yyn);
 531     switch (yyn) {
 532
 533 /* contains all the rule actions; auto-generated from perly.y or madly.y */
 534
 535 #define dep() deprecate("\"do\" to call subroutines")
 536 #ifdef PERL_IN_MADLY_C
 537 #  include "madly.act"
 538 #else
 539 #  include "perly.act"
 540 #endif
 541
 542     }
 543
 544     yyvsp -= yylen;
 545     yyssp -= yylen;
 546 #ifdef DEBUGGING
 547     yynsp -= yylen;
 548 #endif
 549
 550
 551     *++yyvsp = yyval;
 552 #ifdef DEBUGGING
 553     *++yynsp = (const char *)(yytname [yyr1[yyn]]);
 554 #endif
 555
 556     /* Now shift the result of the reduction.  Determine what state
 557           that goes to, based on the state we popped back to and the rule
 558           number reduced by.  */
 559
 560     yyn = yyr1[yyn];
 561
 562     yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
 563     if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 564         yystate = yytable[yystate];
 565     else
 566         yystate = yydefgoto[yyn - YYNTOKENS];
 567
 568     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 569
 570 #ifdef DEBUGGING
 571     /* tmp push yystate for stack print; this is normally pushed later in
 572      * yynewstate */
 573     yyssp++;
 574     *yyssp = yystate;
 575     YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
 576     yyssp--;
 577 #endif
 578
 579     goto yynewstate;
 580
 581
 582   /*------------------------------------.
 583   | yyerrlab -- here on detecting error |
 584   `------------------------------------*/
 585   yyerrlab:
 586     /* If not already recovering from an error, report this error.  */
 587     if (!yyerrstatus) {
 588         ++yynerrs;
 589 #if YYERROR_VERBOSE
 590         yyn = yypact[yystate];
 591
 592         if (YYPACT_NINF < yyn && yyn < YYLAST) {
 593             YYSIZE_T yysize = 0;
 594             const int yytype = YYTRANSLATE (yychar);
 595             char *yymsg;
 596             int yyx, yycount;
 597
 598             yycount = 0;
 599             /* Start YYX at -YYN if negative to avoid negative indexes in
 600                   YYCHECK.  */
 601             for (yyx = yyn < 0 ? -yyn : 0;
 602                       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
 603                 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
 604                     yysize += yystrlen (yytname[yyx]) + 15, yycount++;
 605             yysize += yystrlen ("syntax error, unexpected ") + 1;
 606             yysize += yystrlen (yytname[yytype]);
 607             Newx(yymsg, yysize, char *);
 608             if (yymsg != 0) {
 609                 const char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
 610                 yyp = yystpcpy (yyp, yytname[yytype]);
 611
 612                 if (yycount < 5) {
 613                     yycount = 0;
 614                     for (yyx = yyn < 0 ? -yyn : 0;
 615                               yyx < (int) (sizeof (yytname) / sizeof (char *));
 616                               yyx++)
 617                     {
 618                         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) {
 619                             const char *yyq = ! yycount ?
 620                                                     ", expecting " : " or ";
 621                             yyp = yystpcpy (yyp, yyq);
 622                             yyp = yystpcpy (yyp, yytname[yyx]);
 623                             yycount++;
 624                         }
 625                     }
 626                 }
 627                 yyerror (yymsg);
 628                 YYSTACK_FREE (yymsg);
 629             }
 630             else
 631                 yyerror ("syntax error; also virtual memory exhausted");
 632         }
 633         else
 634 #endif /* YYERROR_VERBOSE */
 635             yyerror ("syntax error");
 636     }
 637
 638
 639     if (yyerrstatus == 3) {
 640         /* If just tried and failed to reuse lookahead token after an
 641               error, discard it.  */
 642
 643         /* Return failure if at end of input.  */
 644         if (yychar == YYEOF) {
 645             /* Pop the error token.  */
 646             YYPOPSTACK;
 647             /* Pop the rest of the stack.  */
 648             while (yyss < yyssp) {
 649                 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
 650                 if (yy_is_opval[yystos[*yyssp]]) {
 651                     YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
 652                     op_free(yyvsp->opval);
 653                 }
 654                 YYPOPSTACK;
 655             }
 656             YYABORT;
 657         }
 658
 659         YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
 660         yychar = YYEMPTY;
 661
 662     }
 663
 664     /* Else will try to reuse lookahead token after shifting the error
 665           token.  */
 666     goto yyerrlab1;
 667
 668
 669   /*----------------------------------------------------.
 670   | yyerrlab1 -- error raised explicitly by an action.  |
 671   `----------------------------------------------------*/
 672   yyerrlab1:
 673     yyerrstatus = 3;    /* Each real token shifted decrements this.  */
 674
 675     for (;;) {
 676         yyn = yypact[yystate];
 677         if (yyn != YYPACT_NINF) {
 678             yyn += YYTERROR;
 679             if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
 680                 yyn = yytable[yyn];
 681                 if (0 < yyn)
 682                     break;
 683             }
 684         }
 685
 686         /* Pop the current state because it cannot handle the error token.  */
 687         if (yyssp == yyss)
 688             YYABORT;
 689
 690         YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
 691         if (yy_is_opval[yystos[*yyssp]]) {
 692             YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
 693             op_free(yyvsp->opval);
 694         }
 695         yyvsp--;
 696 #ifdef DEBUGGING
 697         yynsp--;
 698 #endif
 699         yystate = *--yyssp;
 700
 701         YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
 702     }
 703
 704     if (yyn == YYFINAL)
 705         YYACCEPT;
 706
 707     YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
 708
 709     *++yyvsp = yylval;
 710 #ifdef DEBUGGING
 711     *++yynsp ="<err>";
 712 #endif
 713
 714     yystate = yyn;
 715     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 716
 717     goto yynewstate;
 718
 719
 720   /*-------------------------------------.
 721   | yyacceptlab -- YYACCEPT comes here.  |
 722   `-------------------------------------*/
 723   yyacceptlab:
 724     yyresult = 0;
 725     goto yyreturn;
 726
 727   /*-----------------------------------.
 728   | yyabortlab -- YYABORT comes here.  |
 729   `-----------------------------------*/
 730   yyabortlab:
 731     yyresult = 1;
 732     goto yyreturn;
 733
 734   /*----------------------------------------------.
 735   | yyoverflowlab -- parser overflow comes here.  |
 736   `----------------------------------------------*/
 737   yyoverflowlab:
 738     yyerror ("parser stack overflow");
 739     yyresult = 2;
 740     /* Fall through.  */
 741
 742   yyreturn:
 743
 744     LEAVE;                      /* force stack free before we return */
 745
 746     return yyresult;
 747 }
 748
 749 /*
 750  * Local variables:
 751  * c-indentation-style: bsd
 752  * c-basic-offset: 4
 753  * indent-tabs-mode: t
 754  * End:
 755  *
 756  * ex: set ts=8 sts=4 sw=4 noet:
 757  */