madly.c

   1 /*    madly.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
  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/madly.y */
  39 #include "madly.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 (aTHX_ 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(pTHX_ 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_madparse (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     YYDPRINTF ((Perl_debug_log, "Starting parse\n"));
 309
 310     ENTER;                      /* force stack free before we return */
 311     SAVEVPTR(PL_yycharp);
 312     SAVEVPTR(PL_yylvalp);
 313     PL_yycharp = &yychar; /* so PL_yyerror() can access it */
 314     PL_yylvalp = &yylval; /* so various functions in toke.c can access it */
 315
 316     yyss_sv = newSV(YYINITDEPTH * sizeof(short));
 317     yyvs_sv = newSV(YYINITDEPTH * sizeof(YYSTYPE));
 318     SAVEFREESV(yyss_sv);
 319     SAVEFREESV(yyvs_sv);
 320     yyss = (short *) SvPVX(yyss_sv);
 321     yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
 322     /* note that elements zero of yyvs and yyns are not used */
 323     yyssp = yyss;
 324     yyvsp = yyvs;
 325 #ifdef DEBUGGING
 326     yyns_sv = newSV(YYINITDEPTH * sizeof(char *));
 327     SAVEFREESV(yyns_sv);
 328     /* XXX This seems strange to cast char * to char ** */
 329     yyns = (const char **) SvPVX(yyns_sv);
 330     yynsp = yyns;
 331 #endif
 332
 333     yystate = 0;
 334     yyerrstatus = 0;
 335     yynerrs = 0;
 336     yychar = YYEMPTY;           /* Cause a token to be read.  */
 337
 338     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 339
 340     goto yysetstate;
 341
 342 /*------------------------------------------------------------.
 343 | yynewstate -- Push a new state, which is found in yystate.  |
 344 `------------------------------------------------------------*/
 345   yynewstate:
 346     /* In all cases, when you get here, the value and location stacks
 347           have just been pushed. so pushing a state here evens the stacks.
 348           */
 349     yyssp++;
 350
 351   yysetstate:
 352     *yyssp = yystate;
 353
 354     if (yyss + yystacksize - 1 <= yyssp) {
 355          /* Get the current used size of the three stacks, in elements.  */
 356          const YYSIZE_T yysize = yyssp - yyss + 1;
 357
 358          /* Extend the stack our own way.  */
 359          if (YYMAXDEPTH <= yystacksize)
 360                goto yyoverflowlab;
 361          yystacksize *= 2;
 362          if (YYMAXDEPTH < yystacksize)
 363                yystacksize = YYMAXDEPTH;
 364
 365          SvGROW(yyss_sv, yystacksize * sizeof(short));
 366          SvGROW(yyvs_sv, yystacksize * sizeof(YYSTYPE));
 367          yyss = (short *) SvPVX(yyss_sv);
 368          yyvs = (YYSTYPE *) SvPVX(yyvs_sv);
 369 #ifdef DEBUGGING
 370          SvGROW(yyns_sv, yystacksize * sizeof(char *));
 371          /* XXX This seems strange to cast char * to char ** */
 372          yyns = (const char **) SvPVX(yyns_sv);
 373          if (! yyns)
 374                goto yyoverflowlab;
 375          yynsp = yyns + yysize - 1;
 376 #endif
 377          if (!yyss || ! yyvs)
 378                goto yyoverflowlab;
 379
 380          yyssp = yyss + yysize - 1;
 381          yyvsp = yyvs + yysize - 1;
 382
 383
 384          YYDPRINTF ((Perl_debug_log, "Stack size increased to %lu\n",
 385                                    (unsigned long int) yystacksize));
 386
 387          if (yyss + yystacksize - 1 <= yyssp)
 388                YYABORT;
 389     }
 390
 391     goto yybackup;
 392
 393   /*-----------.
 394   | yybackup.  |
 395   `-----------*/
 396   yybackup:
 397
 398 /* Do appropriate processing given the current state.  */
 399 /* Read a lookahead token if we need one and don't already have one.  */
 400 /* yyresume: */
 401
 402     /* First try to decide what to do without reference to lookahead token.  */
 403
 404     yyn = yypact[yystate];
 405     if (yyn == YYPACT_NINF)
 406         goto yydefault;
 407
 408     /* Not known => get a lookahead token if don't already have one.  */
 409
 410     /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
 411     if (yychar == YYEMPTY) {
 412         YYDPRINTF ((Perl_debug_log, "Reading a token: "));
 413         yychar = madlex();
 414 #  ifdef EBCDIC
 415         if (yychar >= 0 && yychar < 255) {
 416             yychar = NATIVE_TO_ASCII(yychar);
 417         }
 418 #  endif
 419     }
 420
 421     if (yychar <= YYEOF) {
 422         yychar = yytoken = YYEOF;
 423         YYDPRINTF ((Perl_debug_log, "Now at end of input.\n"));
 424     }
 425     else {
 426         yytoken = YYTRANSLATE (yychar);
 427         YYDSYMPRINTF ("Next token is", yytoken, &yylval);
 428     }
 429
 430     /* If the proper action on seeing token YYTOKEN is to reduce or to
 431           detect an error, take that action.  */
 432     yyn += yytoken;
 433     if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
 434         goto yydefault;
 435     yyn = yytable[yyn];
 436     if (yyn <= 0) {
 437         if (yyn == 0 || yyn == YYTABLE_NINF)
 438             goto yyerrlab;
 439         yyn = -yyn;
 440         goto yyreduce;
 441     }
 442
 443     if (yyn == YYFINAL)
 444         YYACCEPT;
 445
 446     /* Shift the lookahead token.  */
 447     YYDPRINTF ((Perl_debug_log, "Shifting token %s, ", yytname[yytoken]));
 448
 449     /* Discard the token being shifted unless it is eof.  */
 450     if (yychar != YYEOF)
 451         yychar = YYEMPTY;
 452
 453     *++yyvsp = yylval;
 454 #ifdef DEBUGGING
 455     *++yynsp = (const char *)(yytname[yytoken]);
 456 #endif
 457
 458
 459     /* Count tokens shifted since error; after three, turn off error
 460           status.  */
 461     if (yyerrstatus)
 462         yyerrstatus--;
 463
 464     yystate = yyn;
 465     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 466
 467     goto yynewstate;
 468
 469
 470   /*-----------------------------------------------------------.
 471   | yydefault -- do the default action for the current state.  |
 472   `-----------------------------------------------------------*/
 473   yydefault:
 474     yyn = yydefact[yystate];
 475     if (yyn == 0)
 476         goto yyerrlab;
 477     goto yyreduce;
 478
 479
 480   /*-----------------------------.
 481   | yyreduce -- Do a reduction.  |
 482   `-----------------------------*/
 483   yyreduce:
 484     /* yyn is the number of a rule to reduce with.  */
 485     yylen = yyr2[yyn];
 486
 487     /* If YYLEN is nonzero, implement the default value of the action:
 488       "$$ = $1".
 489
 490       Otherwise, the following line sets YYVAL to garbage.
 491       This behavior is undocumented and Bison
 492       users should not rely upon it.  Assigning to YYVAL
 493       unconditionally makes the parser a bit smaller, and it avoids a
 494       GCC warning that YYVAL may be used uninitialized.  */
 495     yyval = yyvsp[1-yylen];
 496
 497
 498     YY_REDUCE_PRINT (yyn);
 499     switch (yyn) {
 500
 501 /* contains all the rule actions; auto-generated from perly.y or madly.y */
 502
 503 #define dep() deprecate("\"do\" to call subroutines")
 504 #include "madly.act"
 505
 506     }
 507
 508     yyvsp -= yylen;
 509     yyssp -= yylen;
 510 #ifdef DEBUGGING
 511     yynsp -= yylen;
 512 #endif
 513
 514
 515     *++yyvsp = yyval;
 516 #ifdef DEBUGGING
 517     *++yynsp = (const char *)(yytname [yyr1[yyn]]);
 518 #endif
 519
 520     /* Now shift the result of the reduction.  Determine what state
 521           that goes to, based on the state we popped back to and the rule
 522           number reduced by.  */
 523
 524     yyn = yyr1[yyn];
 525
 526     yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
 527     if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
 528         yystate = yytable[yystate];
 529     else
 530         yystate = yydefgoto[yyn - YYNTOKENS];
 531
 532     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 533
 534 #ifdef DEBUGGING
 535     /* tmp push yystate for stack print; this is normally pushed later in
 536      * yynewstate */
 537     yyssp++;
 538     *yyssp = yystate;
 539     YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
 540     yyssp--;
 541 #endif
 542
 543     goto yynewstate;
 544
 545
 546   /*------------------------------------.
 547   | yyerrlab -- here on detecting error |
 548   `------------------------------------*/
 549   yyerrlab:
 550     /* If not already recovering from an error, report this error.  */
 551     if (!yyerrstatus) {
 552         ++yynerrs;
 553 #if YYERROR_VERBOSE
 554         yyn = yypact[yystate];
 555
 556         if (YYPACT_NINF < yyn && yyn < YYLAST) {
 557             YYSIZE_T yysize = 0;
 558             const int yytype = YYTRANSLATE (yychar);
 559             char *yymsg;
 560             int yyx, yycount;
 561
 562             yycount = 0;
 563             /* Start YYX at -YYN if negative to avoid negative indexes in
 564                   YYCHECK.  */
 565             for (yyx = yyn < 0 ? -yyn : 0;
 566                       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
 567                 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
 568                     yysize += yystrlen (yytname[yyx]) + 15, yycount++;
 569             yysize += yystrlen ("syntax error, unexpected ") + 1;
 570             yysize += yystrlen (yytname[yytype]);
 571             Newx(yymsg, yysize, char *);
 572             if (yymsg != 0) {
 573                 const char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
 574                 yyp = yystpcpy (yyp, yytname[yytype]);
 575
 576                 if (yycount < 5) {
 577                     yycount = 0;
 578                     for (yyx = yyn < 0 ? -yyn : 0;
 579                               yyx < (int) (sizeof (yytname) / sizeof (char *));
 580                               yyx++)
 581                     {
 582                         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) {
 583                             const char *yyq = ! yycount ?
 584                                                     ", expecting " : " or ";
 585                             yyp = yystpcpy (yyp, yyq);
 586                             yyp = yystpcpy (yyp, yytname[yyx]);
 587                             yycount++;
 588                         }
 589                     }
 590                 }
 591                 yyerror (yymsg);
 592                 YYSTACK_FREE (yymsg);
 593             }
 594             else
 595                 yyerror ("syntax error; also virtual memory exhausted");
 596         }
 597         else
 598 #endif /* YYERROR_VERBOSE */
 599             yyerror ("syntax error");
 600     }
 601
 602
 603     if (yyerrstatus == 3) {
 604         /* If just tried and failed to reuse lookahead token after an
 605               error, discard it.  */
 606
 607         /* Return failure if at end of input.  */
 608         if (yychar == YYEOF) {
 609             /* Pop the error token.  */
 610             YYPOPSTACK;
 611             /* Pop the rest of the stack.  */
 612             while (yyss < yyssp) {
 613                 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
 614                 if (yy_is_opval[yystos[*yyssp]]) {
 615                     YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
 616                     op_free(yyvsp->opval);
 617                 }
 618                 YYPOPSTACK;
 619             }
 620             YYABORT;
 621         }
 622
 623         YYDSYMPRINTF ("Error: discarding", yytoken, &yylval);
 624         yychar = YYEMPTY;
 625
 626     }
 627
 628     /* Else will try to reuse lookahead token after shifting the error
 629           token.  */
 630     goto yyerrlab1;
 631
 632
 633   /*----------------------------------------------------.
 634   | yyerrlab1 -- error raised explicitly by an action.  |
 635   `----------------------------------------------------*/
 636   yyerrlab1:
 637     yyerrstatus = 3;    /* Each real token shifted decrements this.  */
 638
 639     for (;;) {
 640         yyn = yypact[yystate];
 641         if (yyn != YYPACT_NINF) {
 642             yyn += YYTERROR;
 643             if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) {
 644                 yyn = yytable[yyn];
 645                 if (0 < yyn)
 646                     break;
 647             }
 648         }
 649
 650         /* Pop the current state because it cannot handle the error token.  */
 651         if (yyssp == yyss)
 652             YYABORT;
 653
 654         YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp);
 655         if (yy_is_opval[yystos[*yyssp]]) {
 656             YYDPRINTF ((Perl_debug_log, "(freeing op)\n"));
 657             op_free(yyvsp->opval);
 658         }
 659         yyvsp--;
 660 #ifdef DEBUGGING
 661         yynsp--;
 662 #endif
 663         yystate = *--yyssp;
 664
 665         YY_STACK_PRINT (yyss, yyssp, yyvs, yyns);
 666     }
 667
 668     if (yyn == YYFINAL)
 669         YYACCEPT;
 670
 671     YYDPRINTF ((Perl_debug_log, "Shifting error token, "));
 672
 673     *++yyvsp = yylval;
 674 #ifdef DEBUGGING
 675     *++yynsp ="<err>";
 676 #endif
 677
 678     yystate = yyn;
 679     YYDPRINTF ((Perl_debug_log, "Entering state %d\n", yystate));
 680
 681     goto yynewstate;
 682
 683
 684   /*-------------------------------------.
 685   | yyacceptlab -- YYACCEPT comes here.  |
 686   `-------------------------------------*/
 687   yyacceptlab:
 688     yyresult = 0;
 689     goto yyreturn;
 690
 691   /*-----------------------------------.
 692   | yyabortlab -- YYABORT comes here.  |
 693   `-----------------------------------*/
 694   yyabortlab:
 695     yyresult = 1;
 696     goto yyreturn;
 697
 698   /*----------------------------------------------.
 699   | yyoverflowlab -- parser overflow comes here.  |
 700   `----------------------------------------------*/
 701   yyoverflowlab:
 702     yyerror ("parser stack overflow");
 703     yyresult = 2;
 704     /* Fall through.  */
 705
 706   yyreturn:
 707
 708     LEAVE;                      /* force stack free before we return */
 709
 710     return yyresult;
 711 }
 712
 713 /*
 714  * Local variables:
 715  * c-indentation-style: bsd
 716  * c-basic-offset: 4
 717  * indent-tabs-mode: t
 718  * End:
 719  *
 720  * ex: set ts=8 sts=4 sw=4 noet:
 721  */