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