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