perly.c

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