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