In perl.git, the branch blead has been updated
<http://perl5.git.perl.org/perl.git/commitdiff/860aed1a66433b47c656b10cda8f388ea3b26dcd?hp=346c6a2954c23fb46d892160e65f9ea2d7d4a4fd>
- Log -----------------------------------------------------------------
commit 860aed1a66433b47c656b10cda8f388ea3b26dcd
Author: Father Chrysostomos <spr...@cpan.org>
Date: Thu Aug 4 13:06:12 2016 -0700
Increase $Errno::VERSION to 1.26
M ext/Errno/Errno_pm.PL
commit 97375ecb5a6e908690ff85bb2f9995c9470c73a9
Author: Father Chrysostomos <spr...@cpan.org>
Date: Thu Aug 4 13:05:41 2016 -0700
Increase $Tie::Hash::NamedCapture::VERSION to 0.10
M ext/Tie-Hash-NamedCapture/NamedCapture.pm
commit faa895b1b52c1b778b91da4d5b7f53ac72aaa375
Author: Father Chrysostomos <spr...@cpan.org>
Date: Thu Aug 4 13:05:06 2016 -0700
Increase $arybase::VERSION to 0.12
M ext/arybase/arybase.pm
commit e94ea821c9b12318e87433760bdeb91530114733
Author: Father Chrysostomos <spr...@cpan.org>
Date: Thu Aug 4 13:00:18 2016 -0700
Rework mod loading for %- and %!; fix mem leak
There are many built-in variables that perl creates on demand for
efficiencyâs sake. gv_fetchpvn_flags (which is responsible for sym-
bol lookup) will fill in those variables automatically when add-
ing a symbol.
The special GV_ADDMG flag passed to this function by a few code paths
(such as defined *{"..."}) tells gv_fetchpvn_flags to add the symbol,
but only if it is one of the âmagicalâ built-in variables that we pre-
tend already exist.
To accomplish this, when the GV_ADDMG flag is passed,
gv_fetchpvn_flags, if the symbol does not already exist, creates a new
GV that is not attached to the stash. It then runs it through its
magicalization code and checks afterward to see whether the GV
changed. If it did, then it gets added to the stash. Otherwise, it
is discarded.
Three of the variables, %-, %!, and $], are problematic, in that they
are implemented by external modules. gv_fetchpvn_flags loads those
modules, which tie the variable in question, and then control is
returned to gv_fetchpvn_flags. If it has a GV that has not been
installed in the symbol table yet, then the module will vivify that GV
on its own by a recursive call to gv_fetchpvn_flags (with the GV_ADD
flag, which does none of this temporary-dangling-GV stuff), and
gv_fetchpvn_flags will have a separate one which, when installed,
would clobber the one with the tied variable.
We solved that by having the GV installed right before calling the
module, for those three variables (in perl 5.16).
The implementation changed in commit v5.19.3-437-g930867a, which was
supposed to clean up the code and make it easier to follow. Unfortun-
ately there was a bug in the implementation. It tries to install the
GV for those cases *before* the magicalization code, but the logic is
wrong. It checks to see whether we are adding only magical symbols
(addmg) and whether the GV has anything in it, but before anything has
been added to the GV. So the symbol never gets installed. Instead,
it just leaks, and the one that the implementing module vivifies
gets used.
This leak can be observed with XS::APItest::sv_count:
$ ./perl -Ilib -MXS::APItest -e 'for (1..10){ defined *{"!"}; delete
$::{"!"}; warn sv_count }'
3833 at -e line 1.
4496 at -e line 1.
4500 at -e line 1.
4504 at -e line 1.
4508 at -e line 1.
4512 at -e line 1.
4516 at -e line 1.
4520 at -e line 1.
4524 at -e line 1.
4528 at -e line 1.
Perl 5.18 does not exhibit the leak.
So in this commit I am finally implementing something that was dis-
cussed about the time that v5.19.3-437-g930867a was introduced. To
avoid the whole problem of recursive calls to gv_fetchpvn_flags vying
over whose GV counts, I have stopped the implementing modules from
tying the variables themselves. Instead, whichever gv_fetchpvn_flags
call is trying to create the glob is now responsible for seeing that
the variable is tied after the module is loaded. Each module now pro-
vides a _tie_it function that gv_fetchpvn_flags can call.
One remaining infelicity is that Errno mentions $! in its source, so
*! will be vivified when it is loading, only to be clobbered by the
GV subsequently installed by gv_fetch_pvn_flags. But at least it
will not leak.
One test that failed as a result of this (in t/op/magic.t) was try-
ing to undo the loading of Errno.pm in order to test it afresh with
*{"!"}. But it did not remove *! before the test. The new logic in
the code happens to work in such a way that the tiedness of the vari-
able determines whether the module needs to be loaded (which is neces-
sary, now that the module does not tie the variable). Since the test
is by no means normal code, it seems reasonable to change it.
M embed.fnc
M embed.h
M ext/Errno/Errno_pm.PL
M ext/Tie-Hash-NamedCapture/NamedCapture.xs
M ext/arybase/arybase.xs
M gv.c
M proto.h
M t/op/magic.t
M t/op/svleak.t
commit 036bbc13ecf0ff7517db4871ba606c5a3affcb60
Author: Father Chrysostomos <spr...@cpan.org>
Date: Wed Aug 3 13:53:40 2016 -0700
Use parser, not PL_parser, in perly.y
The code snippets in perly.y are #included in a C function that has a
âparserâ local variable. Local variables require less machine code
(especially under threads).
M perly.act
M perly.h
M perly.tab
M perly.y
commit 241bf533f84336b4429cbfe9b261c0857c93c67d
Author: Father Chrysostomos <spr...@cpan.org>
Date: Wed Aug 3 13:46:34 2016 -0700
parser.h: comment typo
M parser.h
commit b1ca4fe2ac73dbf8ca81584e1a4f6acf6f14e34a
Author: Father Chrysostomos <spr...@cpan.org>
Date: Wed Aug 3 13:34:16 2016 -0700
Finish reordering the parser struct (again!)
This is meant to be a more correct version of d64e121b07.
M parser.h
commit 4e46c5e2b0b1df7bde99da38de42feed2bb31f08
Author: Father Chrysostomos <spr...@cpan.org>
Date: Wed Aug 3 13:31:06 2016 -0700
Revert "Um, finish reordering the parser struct"
This reverts commit d64e121b07bda895f7f3a5d0e449fc948986e2f1.
It contained stupid blunders. See
<20160803202545.2999.qm...@lists-nntp.develooper.com>.
M parser.h
-----------------------------------------------------------------------
Summary of changes:
embed.fnc | 4 +-
embed.h | 2 +-
ext/Errno/Errno_pm.PL | 7 +-
ext/Tie-Hash-NamedCapture/NamedCapture.pm | 2 +-
ext/Tie-Hash-NamedCapture/NamedCapture.xs | 30 +-
ext/arybase/arybase.pm | 2 +-
ext/arybase/arybase.xs | 14 +-
gv.c | 85 +-
parser.h | 16 +-
perly.act | 1585 ++++++++++++-----------------
perly.h | 297 ++++--
perly.tab | 1448 ++++++++++++++------------
perly.y | 32 +-
proto.h | 4 +-
t/op/magic.t | 1 +
t/op/svleak.t | 15 +-
16 files changed, 1762 insertions(+), 1782 deletions(-)
diff --git a/embed.fnc b/embed.fnc
index 5f2c580..61c9296 100644
--- a/embed.fnc
+++ b/embed.fnc
@@ -1938,8 +1938,8 @@ s |bool|gv_magicalize|NN GV *gv|NN HV *stash|NN const
char *name \
s |void|maybe_multimagic_gv|NN GV *gv|NN const char *name|const svtype sv_type
s |bool|gv_is_in_main|NN const char *name|STRLEN len \
|const U32 is_utf8
-s |HV* |require_tie_mod|NN GV *gv|NN const char *varpv|NN SV* namesv \
- |NN const char *methpv|const U32 flags
+s |void |require_tie_mod|NN GV *gv|NN const char *varpv|NN SV* namesv \
+ |const U32 flags
#endif
#if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C)
diff --git a/embed.h b/embed.h
index 930ea91..3e43529 100644
--- a/embed.h
+++ b/embed.h
@@ -1544,7 +1544,7 @@
#define gv_stashsvpvn_cached(a,b,c,d) S_gv_stashsvpvn_cached(aTHX_ a,b,c,d)
#define maybe_multimagic_gv(a,b,c) S_maybe_multimagic_gv(aTHX_ a,b,c)
#define parse_gv_stash_name(a,b,c,d,e,f,g,h) S_parse_gv_stash_name(aTHX_
a,b,c,d,e,f,g,h)
-#define require_tie_mod(a,b,c,d,e) S_require_tie_mod(aTHX_ a,b,c,d,e)
+#define require_tie_mod(a,b,c,d) S_require_tie_mod(aTHX_ a,b,c,d)
# endif
# if defined(PERL_IN_HV_C)
#define clear_placeholders(a,b) S_clear_placeholders(aTHX_ a,b)
diff --git a/ext/Errno/Errno_pm.PL b/ext/Errno/Errno_pm.PL
index 6251a3c..3c5c443 100644
--- a/ext/Errno/Errno_pm.PL
+++ b/ext/Errno/Errno_pm.PL
@@ -2,7 +2,7 @@ use ExtUtils::MakeMaker;
use Config;
use strict;
-our $VERSION = "1.25";
+our $VERSION = "1.26";
my %err = ();
@@ -391,6 +391,7 @@ sub STORE {
Carp::confess("ERRNO hash is read only!");
}
+# This is the true return value
*CLEAR = *DELETE = \*STORE; # Typeglob aliasing uses less space
sub NEXTKEY {
@@ -407,7 +408,9 @@ sub EXISTS {
exists $err{$errname};
}
-tie %!, __PACKAGE__; # Returns an object, objects are true.
+sub _tie_it {
+ tie %{$_[0]}, __PACKAGE__;
+}
__END__
diff --git a/ext/Tie-Hash-NamedCapture/NamedCapture.pm
b/ext/Tie-Hash-NamedCapture/NamedCapture.pm
index 9702666..32a0029 100644
--- a/ext/Tie-Hash-NamedCapture/NamedCapture.pm
+++ b/ext/Tie-Hash-NamedCapture/NamedCapture.pm
@@ -1,7 +1,7 @@
use strict;
package Tie::Hash::NamedCapture;
-our $VERSION = "0.09";
+our $VERSION = "0.10";
require XSLoader;
XSLoader::load(); # This returns true, which makes require happy.
diff --git a/ext/Tie-Hash-NamedCapture/NamedCapture.xs
b/ext/Tie-Hash-NamedCapture/NamedCapture.xs
index 04cc463..7eaae56 100644
--- a/ext/Tie-Hash-NamedCapture/NamedCapture.xs
+++ b/ext/Tie-Hash-NamedCapture/NamedCapture.xs
@@ -16,31 +16,23 @@
#define EXISTS_ALIAS (RXapif_EXISTS | (2 << EXPECT_SHIFT))
#define SCALAR_ALIAS (RXapif_SCALAR | (1 << EXPECT_SHIFT))
-static void
-tie_it(pTHX_ const char name, UV flag, HV *const stash)
-{
- GV *const gv = gv_fetchpvn(&name, 1, GV_ADDMULTI|GV_NOTQUAL, SVt_PVHV);
- HV *const hv = GvHV(gv);
- SV *rv = newSV_type(SVt_RV);
+MODULE = Tie::Hash::NamedCapture PACKAGE = Tie::Hash::NamedCapture
+PROTOTYPES: DISABLE
- SvRV_set(rv, newSVuv(flag));
+void
+_tie_it(SV *sv)
+ INIT:
+ GV * const gv = (GV *)sv;
+ HV * const hv = GvHVn(gv);
+ SV *rv = newSV_type(SVt_RV);
+ CODE:
+ SvRV_set(rv, newSVuv(*GvNAME(gv) == '-' ? RXapif_ALL : RXapif_ONE));
SvROK_on(rv);
- sv_bless(rv, stash);
+ sv_bless(rv, GvSTASH(CvGV(cv)));
sv_unmagic((SV *)hv, PERL_MAGIC_tied);
sv_magic((SV *)hv, rv, PERL_MAGIC_tied, NULL, 0);
SvREFCNT_dec(rv); /* As sv_magic increased it by one. */
-}
-
-MODULE = Tie::Hash::NamedCapture PACKAGE = Tie::Hash::NamedCapture
-PROTOTYPES: DISABLE
-
-BOOT:
- {
- HV *const stash = GvSTASH(CvGV(cv));
- tie_it(aTHX_ '-', RXapif_ALL, stash);
- tie_it(aTHX_ '+', RXapif_ONE, stash);
- }
SV *
TIEHASH(package, ...)
diff --git a/ext/arybase/arybase.pm b/ext/arybase/arybase.pm
index a519a4b..64efe3e 100644
--- a/ext/arybase/arybase.pm
+++ b/ext/arybase/arybase.pm
@@ -1,6 +1,6 @@
package arybase;
-our $VERSION = "0.11";
+our $VERSION = "0.12";
require XSLoader;
XSLoader::load(); # This returns true, which makes require happy.
diff --git a/ext/arybase/arybase.xs b/ext/arybase/arybase.xs
index 4ff6cbd..880bbe3 100644
--- a/ext/arybase/arybase.xs
+++ b/ext/arybase/arybase.xs
@@ -410,10 +410,6 @@ PROTOTYPES: DISABLE
BOOT:
{
- GV *const gv = gv_fetchpvn("[", 1, GV_ADDMULTI|GV_NOTQUAL, SVt_PV);
- sv_unmagic(GvSV(gv), PERL_MAGIC_sv); /* This is *our* scalar now! */
- tie(aTHX_ GvSV(gv), NULL, GvSTASH(CvGV(cv)));
-
if (!ab_initialized++) {
ab_op_map = ptable_new();
#ifdef USE_ITHREADS
@@ -438,6 +434,16 @@ BOOT:
}
void
+_tie_it(SV *sv)
+ INIT:
+ GV * const gv = (GV *)sv;
+ CODE:
+ if (GvSV(gv))
+ /* This is *our* scalar now! */
+ sv_unmagic(GvSV(gv), PERL_MAGIC_sv);
+ tie(aTHX_ GvSVn(gv), NULL, GvSTASH(CvGV(cv)));
+
+void
FETCH(...)
PREINIT:
SV *ret = FEATURE_ARYBASE_IS_ENABLED
diff --git a/gv.c b/gv.c
index 4ea0917..cd1c32d 100644
--- a/gv.c
+++ b/gv.c
@@ -1294,34 +1294,46 @@ Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name,
STRLEN len, U32 flags)
/* require_tie_mod() internal routine for requiring a module
* that implements the logic of automatic ties like %! and %-
+ * It loads the module and then calls the _tie_it subroutine
+ * with the passed gv as an argument.
*
* The "gv" parameter should be the glob.
* "varpv" holds the name of the var, used for error messages.
* "namesv" holds the module name. Its refcount will be decremented.
- * "methpv" holds the method name to test for to check that things
- * are working reasonably close to as expected.
* "flags": if flag & 1 then save the scalar before loading.
* For the protection of $! to work (it is set by this routine)
* the sv slot must already be magicalized.
*/
-STATIC HV*
-S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char
*methpv,const U32 flags)
+STATIC void
+S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const U32 flags)
{
- HV* stash = gv_stashsv(namesv, 0);
+ const char varname = *varpv; /* varpv might be clobbered by
+ load_module, so save it. For the
+ moment itâs always a single char. */
+ const SV * const target = varname == '[' ? GvSV(gv) : (SV *)GvHV(gv);
PERL_ARGS_ASSERT_REQUIRE_TIE_MOD;
- if (!stash || !(gv_fetchmethod_autoload(stash, methpv, FALSE))) {
+ /* If it is not tied */
+ if (!target || !SvRMAGICAL(target)
+ || !mg_find(target,
+ varname == '[' ? PERL_MAGIC_tiedscalar : PERL_MAGIC_tied))
+ {
+ HV *stash;
+ GV **gvp;
+ dSP;
+
+ ENTER;
+ SAVEFREESV(namesv);
+
+#define HV_FETCH_TIE_FUNC (GV **)hv_fetch(stash, "_tie_it", 7, 0)
+
+ /* Load the module if it is not loaded. */
+ if (!(stash = gv_stashsv(namesv, 0))
+ || !(gvp = HV_FETCH_TIE_FUNC) || !*gvp || !GvCV(*gvp))
+ {
SV *module = newSVsv(namesv);
- char varname = *varpv; /* varpv might be clobbered by load_module,
- so save it. For the moment it's always
- a single char. */
const char type = varname == '[' ? '$' : '%';
-#ifdef DEBUGGING
- dSP;
-#endif
- ENTER;
- SAVEFREESV(namesv);
if ( flags & 1 )
save_scalar(gv);
Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT, module, NULL);
@@ -1330,13 +1342,19 @@ S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV*
namesv, const char *methp
if (!stash)
Perl_croak(aTHX_ "panic: Can't use %c%c because %"SVf" is not
available",
type, varname, SVfARG(namesv));
- else if (!gv_fetchmethod(stash, methpv))
- Perl_croak(aTHX_ "panic: Can't use %c%c because %"SVf" does not
support method %s",
- type, varname, SVfARG(namesv), methpv);
- LEAVE;
+ else if (!(gvp = HV_FETCH_TIE_FUNC) || !*gvp || !GvCV(*gvp))
+ Perl_croak(aTHX_ "panic: Can't use %c%c because %"SVf" does not
define _tie_it",
+ type, varname, SVfARG(namesv));
+ }
+ /* Now call the tie function. It should be in *gvp. */
+ assert(gvp); assert(*gvp); assert(GvCV(*gvp));
+ PUSHMARK(SP);
+ XPUSHs((SV *)gv);
+ PUTBACK;
+ call_sv((SV *)*gvp, G_VOID|G_DISCARD);
+ LEAVE;
}
else SvREFCNT_dec_NN(namesv);
- return stash;
}
/*
@@ -2064,10 +2082,7 @@ S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char
*name, STRLEN len,
/* magicalization must be done before require_tie_mod is called */
if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
- {
- require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
- addmg = FALSE;
- }
+ require_tie_mod(gv, "!", newSVpvs("Errno"), 1);
break;
case '-': /* $- */
@@ -2084,10 +2099,7 @@ S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char
*name, STRLEN len,
SvREADONLY_on(av);
if (sv_type == SVt_PVHV || sv_type == SVt_PVGV)
- {
- require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"),
"TIEHASH", 0);
- addmg = FALSE;
- }
+ require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"),
0);
break;
}
@@ -2107,8 +2119,7 @@ S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char
*name, STRLEN len,
case '[': /* $[ */
if ((sv_type == SVt_PV || sv_type == SVt_PVGV)
&& FEATURE_ARYBASE_IS_ENABLED) {
- require_tie_mod(gv,name,newSVpvs("arybase"),"FETCH",0);
- addmg = FALSE;
+ require_tie_mod(gv,name,newSVpvs("arybase"),0);
}
else goto magicalize;
break;
@@ -2196,9 +2207,9 @@ S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name,
const svtype sv_type)
if (sv_type == SVt_PVHV || sv_type == SVt_PVGV) {
if (*name == '!')
- require_tie_mod(gv, "!", newSVpvs("Errno"), "TIEHASH", 1);
+ require_tie_mod(gv, "!", newSVpvs("Errno"), 1);
else if (*name == '-' || *name == '+')
- require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"),
"TIEHASH", 0);
+ require_tie_mod(gv, name, newSVpvs("Tie::Hash::NamedCapture"), 0);
} else if (sv_type == SVt_PV) {
if (*name == '*' || *name == '#') {
/* diag_listed_as: $* is no longer supported */
@@ -2210,7 +2221,7 @@ S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name,
const svtype sv_type)
if (sv_type==SVt_PV || sv_type==SVt_PVGV) {
switch (*name) {
case '[':
- require_tie_mod(gv,name,newSVpvs("arybase"),"FETCH",0);
+ require_tie_mod(gv,name,newSVpvs("arybase"),0);
break;
#ifdef PERL_SAWAMPERSAND
case '`':
@@ -2339,16 +2350,9 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN
full_len, I32 flags,
if ( isIDFIRST_lazy_if(name, is_utf8) && !ckWARN(WARN_ONCE) )
GvMULTI_on(gv) ;
- /* First, store the gv in the symtab if we're adding magic,
- * but only for non-empty GVs
- */
#define GvEMPTY(gv) !(GvAV(gv) || GvHV(gv) || GvIO(gv) \
|| GvCV(gv) || (GvSV(gv) && SvOK(GvSV(gv))))
- if ( addmg && !GvEMPTY(gv) ) {
- (void)hv_store(stash,name,len,(SV *)gv,0);
- }
-
/* set up magic where warranted */
if ( gv_magicalize(gv, stash, name, len, addmg, sv_type) ) {
/* See 23496c6 */
@@ -2366,6 +2370,9 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN
full_len, I32 flags,
gv = NULL;
}
}
+ else
+ /* Not empty; this means gv_magicalize magicalised it. */
+ (void)hv_store(stash,name,len,(SV *)gv,0);
}
if (gv) gv_init_svtype(gv, faking_it ? SVt_PVCV : sv_type);
diff --git a/parser.h b/parser.h
index d5f1b88..9c22094 100644
--- a/parser.h
+++ b/parser.h
@@ -95,8 +95,6 @@ typedef struct yy_parser {
U16 in_my; /* we're compiling a "my"/"our"
declaration */
U8 lex_state; /* next token is determined */
U8 error_count; /* how many compile errors so far, max 10 */
- U8 form_lex_state; /* remember lex_state when parsing fmt */
- /* 8-BIT HOLE */
HV *in_my_stash; /* declared class of this "my" declaration */
PerlIO *rsfp; /* current source file pointer */
AV *rsfp_filters; /* holds chain of active source filters */
@@ -104,23 +102,23 @@ typedef struct yy_parser {
YYSTYPE nextval[5]; /* value of next token, if any */
I32 nexttype[5]; /* type of next token */
U8 nexttoke;
-
+ U8 form_lex_state; /* remember lex_state when parsing fmt */
U8 lex_fakeeof; /* precedence at which to fake EOF */
U8 lex_flags;
- PERL_BITFIELD16 in_pod:1; /* lexer is within a =pod section */
- PERL_BITFIELD16 filtered:1; /* source filters in evalbytes */
- PERL_BITFIELD16 saw_infix_sigil:1; /* saw & or * or % operator */
- PERL_BITFIELD16 parsed_sub:1; /* last thing parsed was a sub */
- /* 4 spare bits */
COP *saved_curcop; /* the previous PL_curcop */
char tokenbuf[256];
line_t herelines; /* number of lines in here-doc */
line_t preambling; /* line # when processing $ENV{PERL5DB} */
- /* these are valid whiling parsing a subroutine signature */
+ /* these are valid while parsing a subroutine signature */
IV sig_elems; /* number of signature elements seen so far */
IV sig_optelems; /* number of optional signature elems seen */
char sig_slurpy; /* the sigil of the slurpy var (or null) */
+
+ PERL_BITFIELD16 in_pod:1; /* lexer is within a =pod section */
+ PERL_BITFIELD16 filtered:1; /* source filters in evalbytes */
+ PERL_BITFIELD16 saw_infix_sigil:1; /* saw & or * or % operator */
+ PERL_BITFIELD16 parsed_sub:1; /* last thing parsed was a sub */
} yy_parser;
/* flags for lexer API */
diff --git a/perly.act b/perly.act
index 878b1df..3626904 100644
--- a/perly.act
+++ b/perly.act
@@ -5,246 +5,219 @@
*/
case 2:
-#line 118 "perly.y" /* yacc.c:1646 */
+#line 118 "perly.y"
{
parser->expect = XSTATE;
- }
-
+ ;}
break;
case 3:
-#line 122 "perly.y" /* yacc.c:1646 */
+#line 122 "perly.y"
{
-
newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
+ newPROG(block_end((ps[(3) - (4)].val.ival),(ps[(4) -
(4)].val.opval)));
PL_compiling.cop_seq = 0;
(yyval.ival) = 0;
- }
-
+ ;}
break;
case 4:
-#line 128 "perly.y" /* yacc.c:1646 */
+#line 128 "perly.y"
{
parser->expect = XTERM;
- }
-
+ ;}
break;
case 5:
-#line 132 "perly.y" /* yacc.c:1646 */
+#line 132 "perly.y"
{
- PL_eval_root = (ps[0].val.opval);
+ PL_eval_root = (ps[(3) - (3)].val.opval);
(yyval.ival) = 0;
- }
-
+ ;}
break;
case 6:
-#line 137 "perly.y" /* yacc.c:1646 */
+#line 137 "perly.y"
{
parser->expect = XBLOCK;
- }
-
+ ;}
break;
case 7:
-#line 141 "perly.y" /* yacc.c:1646 */
+#line 141 "perly.y"
{
PL_pad_reset_pending = TRUE;
- PL_eval_root = (ps[0].val.opval);
+ PL_eval_root = (ps[(3) - (3)].val.opval);
(yyval.ival) = 0;
yyunlex();
parser->yychar = YYEOF;
- }
-
+ ;}
break;
case 8:
-#line 149 "perly.y" /* yacc.c:1646 */
+#line 149 "perly.y"
{
parser->expect = XSTATE;
- }
-
+ ;}
break;
case 9:
-#line 153 "perly.y" /* yacc.c:1646 */
+#line 153 "perly.y"
{
PL_pad_reset_pending = TRUE;
- PL_eval_root = (ps[0].val.opval);
+ PL_eval_root = (ps[(3) - (3)].val.opval);
(yyval.ival) = 0;
yyunlex();
parser->yychar = YYEOF;
- }
-
+ ;}
break;
case 10:
-#line 161 "perly.y" /* yacc.c:1646 */
+#line 161 "perly.y"
{
parser->expect = XSTATE;
- }
-
+ ;}
break;
case 11:
-#line 165 "perly.y" /* yacc.c:1646 */
+#line 165 "perly.y"
{
PL_pad_reset_pending = TRUE;
- PL_eval_root = (ps[0].val.opval);
+ PL_eval_root = (ps[(3) - (3)].val.opval);
(yyval.ival) = 0;
yyunlex();
parser->yychar = YYEOF;
- }
-
+ ;}
break;
case 12:
-#line 173 "perly.y" /* yacc.c:1646 */
+#line 173 "perly.y"
{
parser->expect = XSTATE;
- }
-
+ ;}
break;
case 13:
-#line 177 "perly.y" /* yacc.c:1646 */
+#line 177 "perly.y"
{
- PL_eval_root = (ps[0].val.opval);
+ PL_eval_root = (ps[(3) - (3)].val.opval);
(yyval.ival) = 0;
- }
-
+ ;}
break;
case 14:
-#line 185 "perly.y" /* yacc.c:1646 */
- { if (parser->copline > (line_t)(ps[-3].val.ival))
- parser->copline = (line_t)(ps[-3].val.ival);
- (yyval.opval) = block_end((ps[-2].val.ival),
(ps[-1].val.opval));
- }
-
+#line 185 "perly.y"
+ { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
+ parser->copline = (line_t)(ps[(1) -
(4)].val.ival);
+ (yyval.opval) = block_end((ps[(2) - (4)].val.ival),
(ps[(3) - (4)].val.opval));
+ ;}
break;
case 15:
-#line 193 "perly.y" /* yacc.c:1646 */
- { if (parser->copline > (line_t)(ps[-6].val.ival))
- parser->copline = (line_t)(ps[-6].val.ival);
- (yyval.opval) = block_end((ps[-5].val.ival),
(ps[-2].val.opval));
- }
-
+#line 193 "perly.y"
+ { if (parser->copline > (line_t)(ps[(1) - (7)].val.ival))
+ parser->copline = (line_t)(ps[(1) -
(7)].val.ival);
+ (yyval.opval) = block_end((ps[(2) - (7)].val.ival),
(ps[(5) - (7)].val.opval));
+ ;}
break;
case 16:
-#line 200 "perly.y" /* yacc.c:1646 */
+#line 200 "perly.y"
{ (yyval.ival) = block_start(TRUE);
- parser->parsed_sub = 0; }
-
+ parser->parsed_sub = 0; ;}
break;
case 17:
-#line 205 "perly.y" /* yacc.c:1646 */
- { if (parser->copline > (line_t)(ps[-3].val.ival))
- parser->copline = (line_t)(ps[-3].val.ival);
- (yyval.opval) = block_end((ps[-2].val.ival),
(ps[-1].val.opval));
- }
-
+#line 205 "perly.y"
+ { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
+ parser->copline = (line_t)(ps[(1) -
(4)].val.ival);
+ (yyval.opval) = block_end((ps[(2) - (4)].val.ival),
(ps[(3) - (4)].val.opval));
+ ;}
break;
case 18:
-#line 212 "perly.y" /* yacc.c:1646 */
+#line 212 "perly.y"
{ (yyval.ival) = block_start(FALSE);
- parser->parsed_sub = 0; }
-
+ parser->parsed_sub = 0; ;}
break;
case 19:
-#line 218 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 218 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 20:
-#line 220 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval),
(ps[0].val.opval));
+#line 220 "perly.y"
+ { (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval),
(ps[(2) - (2)].val.opval));
PL_pad_reset_pending = TRUE;
- if ((ps[-1].val.opval) && (ps[0].val.opval))
+ if ((ps[(1) - (2)].val.opval) && (ps[(2) -
(2)].val.opval))
PL_hints |= HINT_BLOCK_SCOPE;
- }
-
+ ;}
break;
case 21:
-#line 229 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 229 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 22:
-#line 231 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval),
(ps[0].val.opval));
+#line 231 "perly.y"
+ { (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval),
(ps[(2) - (2)].val.opval));
PL_pad_reset_pending = TRUE;
- if ((ps[-1].val.opval) && (ps[0].val.opval))
+ if ((ps[(1) - (2)].val.opval) && (ps[(2) -
(2)].val.opval))
PL_hints |= HINT_BLOCK_SCOPE;
- }
-
+ ;}
break;
case 23:
-#line 240 "perly.y" /* yacc.c:1646 */
+#line 240 "perly.y"
{
- (yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0,
NULL, (ps[0].val.opval)) : NULL;
- }
-
+ (yyval.opval) = (ps[(1) - (1)].val.opval) ?
newSTATEOP(0, NULL, (ps[(1) - (1)].val.opval)) : NULL;
+ ;}
break;
case 24:
-#line 244 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 244 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 25:
-#line 248 "perly.y" /* yacc.c:1646 */
+#line 248 "perly.y"
{
- (yyval.opval) = newSTATEOP(SVf_UTF8 *
(ps[-1].val.pval)[strlen((ps[-1].val.pval))+1], (ps[-1].val.pval),
(ps[0].val.opval));
- }
-
+ (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) -
(2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval),
(ps[(2) - (2)].val.opval));
+ ;}
break;
case 26:
-#line 252 "perly.y" /* yacc.c:1646 */
+#line 252 "perly.y"
{
- (yyval.opval) = newSTATEOP(SVf_UTF8 *
(ps[-1].val.pval)[strlen((ps[-1].val.pval))+1], (ps[-1].val.pval),
(ps[0].val.opval));
- }
-
+ (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) -
(2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval),
(ps[(2) - (2)].val.opval));
+ ;}
break;
case 27:
-#line 259 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 259 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 28:
-#line 261 "perly.y" /* yacc.c:1646 */
+#line 261 "perly.y"
{
CV *fmtcv = PL_compcv;
- newFORM((ps[-2].val.ival), (ps[-1].val.opval),
(ps[0].val.opval));
+ newFORM((ps[(2) - (4)].val.ival), (ps[(3) -
(4)].val.opval), (ps[(4) - (4)].val.opval));
(yyval.opval) = (OP*)NULL;
if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
pad_add_weakref(fmtcv);
}
parser->parsed_sub = 1;
- }
-
+ ;}
break;
case 29:
-#line 271 "perly.y" /* yacc.c:1646 */
+#line 271 "perly.y"
{
- if ((ps[-1].val.opval)->op_type == OP_CONST) {
+ if ((ps[(2) - (3)].val.opval)->op_type == OP_CONST) {
const char *const name =
-
SvPV_nolen_const(((SVOP*)(ps[-1].val.opval))->op_sv);
+ SvPV_nolen_const(((SVOP*)(ps[(2) -
(3)].val.opval))->op_sv);
if (strEQ(name, "BEGIN") || strEQ(name, "END")
|| strEQ(name, "INIT") || strEQ(name, "CHECK")
|| strEQ(name, "UNITCHECK"))
@@ -257,35 +230,33 @@ case 2:
|| CvCLONE(CvOUTSIDE(PL_compcv))
|| !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
CvOUTSIDE(PL_compcv)
- ))[(ps[-1].val.opval)->op_targ]))
+ ))[(ps[(2) -
(3)].val.opval)->op_targ]))
CvCLONE_on(PL_compcv);
parser->in_my = 0;
parser->in_my_stash = NULL;
- }
-
+ ;}
break;
case 30:
-#line 293 "perly.y" /* yacc.c:1646 */
+#line 293 "perly.y"
{
SvREFCNT_inc_simple_void(PL_compcv);
- (ps[-5].val.opval)->op_type == OP_CONST
- ? newATTRSUB((ps[-4].val.ival),
(ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
- : newMYSUB((ps[-4].val.ival), (ps[-5].val.opval),
(ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
+ (ps[(2) - (7)].val.opval)->op_type == OP_CONST
+ ? newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) -
(7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7)
- (7)].val.opval))
+ : newMYSUB((ps[(3) - (7)].val.ival), (ps[(2) -
(7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7)
- (7)].val.opval))
;
(yyval.opval) = (OP*)NULL;
intro_my();
parser->parsed_sub = 1;
- }
-
+ ;}
break;
case 31:
-#line 304 "perly.y" /* yacc.c:1646 */
+#line 304 "perly.y"
{
- if ((ps[-1].val.opval)->op_type == OP_CONST) {
+ if ((ps[(2) - (3)].val.opval)->op_type == OP_CONST) {
const char *const name =
-
SvPV_nolen_const(((SVOP*)(ps[-1].val.opval))->op_sv);
+ SvPV_nolen_const(((SVOP*)(ps[(2) -
(3)].val.opval))->op_sv);
if (strEQ(name, "BEGIN") || strEQ(name, "END")
|| strEQ(name, "INIT") || strEQ(name, "CHECK")
|| strEQ(name, "UNITCHECK"))
@@ -298,144 +269,130 @@ case 2:
|| CvCLONE(CvOUTSIDE(PL_compcv))
|| !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
CvOUTSIDE(PL_compcv)
- ))[(ps[-1].val.opval)->op_targ]))
+ ))[(ps[(2) -
(3)].val.opval)->op_targ]))
CvCLONE_on(PL_compcv);
parser->in_my = 0;
parser->in_my_stash = NULL;
- }
-
+ ;}
break;
case 32:
-#line 326 "perly.y" /* yacc.c:1646 */
+#line 326 "perly.y"
{
OP *body;
- if (parser->copline > (line_t)(ps[-2].val.ival))
- parser->copline = (line_t)(ps[-2].val.ival);
- body = block_end((ps[-5].val.ival),
- op_append_list(OP_LINESEQ, (ps[-4].val.opval),
(ps[-1].val.opval)));
+ if (parser->copline > (line_t)(ps[(8) -
(10)].val.ival))
+ parser->copline = (line_t)(ps[(8) -
(10)].val.ival);
+ body = block_end((ps[(5) - (10)].val.ival),
+ op_append_list(OP_LINESEQ, (ps[(6) -
(10)].val.opval), (ps[(9) - (10)].val.opval)));
SvREFCNT_inc_simple_void(PL_compcv);
- (ps[-8].val.opval)->op_type == OP_CONST
- ? newATTRSUB((ps[-7].val.ival),
(ps[-8].val.opval), NULL, (ps[-3].val.opval), body)
- : newMYSUB((ps[-7].val.ival), (ps[-8].val.opval),
NULL, (ps[-3].val.opval), body)
+ (ps[(2) - (10)].val.opval)->op_type == OP_CONST
+ ? newATTRSUB((ps[(3) - (10)].val.ival), (ps[(2) -
(10)].val.opval), NULL, (ps[(7) - (10)].val.opval), body)
+ : newMYSUB((ps[(3) - (10)].val.ival), (ps[(2) -
(10)].val.opval), NULL, (ps[(7) - (10)].val.opval), body)
;
(yyval.opval) = (OP*)NULL;
intro_my();
parser->parsed_sub = 1;
- }
-
+ ;}
break;
case 33:
-#line 343 "perly.y" /* yacc.c:1646 */
+#line 343 "perly.y"
{
- package((ps[-1].val.opval));
- if ((ps[-2].val.opval))
- package_version((ps[-2].val.opval));
+ package((ps[(3) - (4)].val.opval));
+ if ((ps[(2) - (4)].val.opval))
+ package_version((ps[(2) - (4)].val.opval));
(yyval.opval) = (OP*)NULL;
- }
-
+ ;}
break;
case 34:
-#line 350 "perly.y" /* yacc.c:1646 */
- { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
-
+#line 350 "perly.y"
+ { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
break;
case 35:
-#line 352 "perly.y" /* yacc.c:1646 */
+#line 352 "perly.y"
{
SvREFCNT_inc_simple_void(PL_compcv);
- utilize((ps[-6].val.ival), (ps[-5].val.ival),
(ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
+ utilize((ps[(1) - (7)].val.ival), (ps[(2) -
(7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) -
(7)].val.opval));
parser->parsed_sub = 1;
(yyval.opval) = (OP*)NULL;
- }
-
+ ;}
break;
case 36:
-#line 359 "perly.y" /* yacc.c:1646 */
+#line 359 "perly.y"
{
- (yyval.opval) = block_end((ps[-4].val.ival),
- newCONDOP(0, (ps[-3].val.opval),
op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
- parser->copline = (line_t)(ps[-6].val.ival);
- }
-
+ (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
+ newCONDOP(0, (ps[(4) - (7)].val.opval),
op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
+ parser->copline = (line_t)(ps[(1) - (7)].val.ival);
+ ;}
break;
case 37:
-#line 365 "perly.y" /* yacc.c:1646 */
+#line 365 "perly.y"
{
- (yyval.opval) = block_end((ps[-4].val.ival),
- newCONDOP(0, (ps[-3].val.opval),
(ps[0].val.opval), op_scope((ps[-1].val.opval))));
- parser->copline = (line_t)(ps[-6].val.ival);
- }
-
+ (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
+ newCONDOP(0, (ps[(4) - (7)].val.opval), (ps[(7)
- (7)].val.opval), op_scope((ps[(6) - (7)].val.opval))));
+ parser->copline = (line_t)(ps[(1) - (7)].val.ival);
+ ;}
break;
case 38:
-#line 371 "perly.y" /* yacc.c:1646 */
+#line 371 "perly.y"
{
- (yyval.opval) = block_end((ps[-3].val.ival),
newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
- parser->copline = (line_t)(ps[-5].val.ival);
- }
-
+ (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
newGIVENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)), 0));
+ parser->copline = (line_t)(ps[(1) - (6)].val.ival);
+ ;}
break;
case 39:
-#line 376 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = block_end((ps[-3].val.ival),
newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
-
+#line 376 "perly.y"
+ { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) -
(6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); ;}
break;
case 40:
-#line 378 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
-
+#line 378 "perly.y"
+ { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); ;}
break;
case 41:
-#line 380 "perly.y" /* yacc.c:1646 */
+#line 380 "perly.y"
{
- (yyval.opval) = block_end((ps[-5].val.ival),
+ (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
- (ps[-4].val.opval), (ps[-1].val.opval),
(ps[0].val.opval), (ps[-2].val.ival)));
- parser->copline = (line_t)(ps[-7].val.ival);
- }
-
+ (ps[(4) - (8)].val.opval), (ps[(7) -
(8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
+ parser->copline = (line_t)(ps[(1) - (8)].val.ival);
+ ;}
break;
case 42:
-#line 387 "perly.y" /* yacc.c:1646 */
+#line 387 "perly.y"
{
- (yyval.opval) = block_end((ps[-5].val.ival),
+ (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
- (ps[-4].val.opval), (ps[-1].val.opval),
(ps[0].val.opval), (ps[-2].val.ival)));
- parser->copline = (line_t)(ps[-7].val.ival);
- }
-
+ (ps[(4) - (8)].val.opval), (ps[(7) -
(8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
+ parser->copline = (line_t)(ps[(1) - (8)].val.ival);
+ ;}
break;
case 43:
-#line 394 "perly.y" /* yacc.c:1646 */
- { parser->expect = XTERM; }
-
+#line 394 "perly.y"
+ { parser->expect = XTERM; ;}
break;
case 44:
-#line 396 "perly.y" /* yacc.c:1646 */
- { parser->expect = XTERM; }
-
+#line 396 "perly.y"
+ { parser->expect = XTERM; ;}
break;
case 45:
-#line 399 "perly.y" /* yacc.c:1646 */
+#line 399 "perly.y"
{
- OP *initop = (ps[-9].val.opval);
+ OP *initop = (ps[(4) - (13)].val.opval);
OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
- scalar((ps[-6].val.opval)),
(ps[0].val.opval), (ps[-2].val.opval), (ps[-3].val.ival));
+ scalar((ps[(7) - (13)].val.opval)),
(ps[(13) - (13)].val.opval), (ps[(11) - (13)].val.opval), (ps[(10) -
(13)].val.ival));
if (initop) {
forop = op_prepend_elem(OP_LINESEQ, initop,
op_append_elem(OP_LINESEQ,
@@ -443,428 +400,375 @@ case 2:
forop));
}
PL_hints |= HINT_BLOCK_SCOPE;
- (yyval.opval) = block_end((ps[-10].val.ival), forop);
- parser->copline = (line_t)(ps[-12].val.ival);
- }
-
+ (yyval.opval) = block_end((ps[(3) - (13)].val.ival),
forop);
+ parser->copline = (line_t)(ps[(1) - (13)].val.ival);
+ ;}
break;
case 46:
-#line 414 "perly.y" /* yacc.c:1646 */
+#line 414 "perly.y"
{
- (yyval.opval) = block_end((ps[-6].val.ival),
newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval),
(ps[0].val.opval)));
- parser->copline = (line_t)(ps[-8].val.ival);
- }
-
+ (yyval.opval) = block_end((ps[(3) - (9)].val.ival),
newFOROP(0, (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) -
(9)].val.opval), (ps[(9) - (9)].val.opval)));
+ parser->copline = (line_t)(ps[(1) - (9)].val.ival);
+ ;}
break;
case 47:
-#line 419 "perly.y" /* yacc.c:1646 */
+#line 419 "perly.y"
{
- (yyval.opval) = block_end((ps[-4].val.ival),
newFOROP(0,
- op_lvalue((ps[-6].val.opval),
OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
- parser->copline = (line_t)(ps[-7].val.ival);
- }
-
+ (yyval.opval) = block_end((ps[(4) - (8)].val.ival),
newFOROP(0,
+ op_lvalue((ps[(2) - (8)].val.opval),
OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) -
(8)].val.opval)));
+ parser->copline = (line_t)(ps[(1) - (8)].val.ival);
+ ;}
break;
case 48:
-#line 425 "perly.y" /* yacc.c:1646 */
- { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
-
+#line 425 "perly.y"
+ { parser->in_my = 0; (yyval.opval) = my((ps[(4) - (4)].val.opval)); ;}
break;
case 49:
-#line 427 "perly.y" /* yacc.c:1646 */
+#line 427 "perly.y"
{
(yyval.opval) = block_end(
- (ps[-7].val.ival),
+ (ps[(3) - (10)].val.ival),
newFOROP(0,
op_lvalue(
newUNOP(OP_REFGEN, 0,
- (ps[-5].val.opval)),
+ (ps[(5) - (10)].val.opval)),
OP_ENTERLOOP),
- (ps[-3].val.opval),
(ps[-1].val.opval), (ps[0].val.opval))
+ (ps[(7) - (10)].val.opval), (ps[(9) -
(10)].val.opval), (ps[(10) - (10)].val.opval))
);
- parser->copline = (line_t)(ps[-9].val.ival);
- }
-
+ parser->copline = (line_t)(ps[(1) - (10)].val.ival);
+ ;}
break;
case 50:
-#line 440 "perly.y" /* yacc.c:1646 */
+#line 440 "perly.y"
{
- (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
+ (yyval.opval) = block_end((ps[(5) - (9)].val.ival),
newFOROP(
0, op_lvalue(newUNOP(OP_REFGEN, 0,
- (ps[-6].val.opval)),
- OP_ENTERLOOP), (ps[-3].val.opval),
(ps[-1].val.opval), (ps[0].val.opval)));
- parser->copline = (line_t)(ps[-8].val.ival);
- }
-
+ (ps[(3) - (9)].val.opval)),
+ OP_ENTERLOOP), (ps[(6) -
(9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
+ parser->copline = (line_t)(ps[(1) - (9)].val.ival);
+ ;}
break;
case 51:
-#line 448 "perly.y" /* yacc.c:1646 */
+#line 448 "perly.y"
{
- (yyval.opval) = block_end((ps[-4].val.ival),
- newFOROP(0, (OP*)NULL, (ps[-3].val.opval),
(ps[-1].val.opval), (ps[0].val.opval)));
- parser->copline = (line_t)(ps[-6].val.ival);
- }
-
+ (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
+ newFOROP(0, (OP*)NULL, (ps[(4) -
(7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
+ parser->copline = (line_t)(ps[(1) - (7)].val.ival);
+ ;}
break;
case 52:
-#line 454 "perly.y" /* yacc.c:1646 */
+#line 454 "perly.y"
{
/* a block is a loop that happens once */
(yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
- (OP*)NULL, (ps[-1].val.opval),
(ps[0].val.opval), 0);
- }
-
+ (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2)
- (2)].val.opval), 0);
+ ;}
break;
case 53:
-#line 460 "perly.y" /* yacc.c:1646 */
+#line 460 "perly.y"
{
- package((ps[-2].val.opval));
- if ((ps[-3].val.opval)) {
- package_version((ps[-3].val.opval));
+ package((ps[(3) - (5)].val.opval));
+ if ((ps[(2) - (5)].val.opval)) {
+ package_version((ps[(2) - (5)].val.opval));
}
- }
-
+ ;}
break;
case 54:
-#line 467 "perly.y" /* yacc.c:1646 */
+#line 467 "perly.y"
{
/* a block is a loop that happens once */
(yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
- (OP*)NULL, block_end((ps[-3].val.ival),
(ps[-1].val.opval)), (OP*)NULL, 0);
- if (parser->copline > (line_t)(ps[-4].val.ival))
- parser->copline = (line_t)(ps[-4].val.ival);
- }
-
+ (OP*)NULL, block_end((ps[(5) -
(8)].val.ival), (ps[(7) - (8)].val.opval)), (OP*)NULL, 0);
+ if (parser->copline > (line_t)(ps[(4) -
(8)].val.ival))
+ parser->copline = (line_t)(ps[(4) -
(8)].val.ival);
+ ;}
break;
case 55:
-#line 475 "perly.y" /* yacc.c:1646 */
+#line 475 "perly.y"
{
- (yyval.opval) = (ps[-1].val.opval);
- }
-
+ (yyval.opval) = (ps[(1) - (2)].val.opval);
+ ;}
break;
case 56:
-#line 479 "perly.y" /* yacc.c:1646 */
+#line 479 "perly.y"
{
(yyval.opval) = (OP*)NULL;
parser->copline = NOLINE;
- }
-
+ ;}
break;
case 57:
-#line 487 "perly.y" /* yacc.c:1646 */
+#line 487 "perly.y"
{ OP *list;
- if ((ps[0].val.opval)) {
- OP *term = (ps[0].val.opval);
- list = op_append_elem(OP_LIST,
(ps[-1].val.opval), term);
+ if ((ps[(2) - (2)].val.opval)) {
+ OP *term = (ps[(2) - (2)].val.opval);
+ list = op_append_elem(OP_LIST, (ps[(1) -
(2)].val.opval), term);
}
else {
- list = (ps[-1].val.opval);
+ list = (ps[(1) - (2)].val.opval);
}
if (parser->copline == NOLINE)
parser->copline = CopLINE(PL_curcop)-1;
else parser->copline--;
(yyval.opval) = newSTATEOP(0, NULL,
op_convert_list(OP_FORMLINE, 0,
list));
- }
-
+ ;}
break;
case 58:
-#line 504 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = NULL; }
-
+#line 504 "perly.y"
+ { (yyval.opval) = NULL; ;}
break;
case 59:
-#line 506 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
-
+#line 506 "perly.y"
+ { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); ;}
break;
case 60:
-#line 511 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 511 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 61:
-#line 513 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 513 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 62:
-#line 515 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval),
(ps[-2].val.opval)); }
-
+#line 515 "perly.y"
+ { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) -
(3)].val.opval)); ;}
break;
case 63:
-#line 517 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval),
(ps[-2].val.opval)); }
-
+#line 517 "perly.y"
+ { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) -
(3)].val.opval)); ;}
break;
case 64:
-#line 519 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)),
(ps[-2].val.opval)); }
-
+#line 519 "perly.y"
+ { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) -
(3)].val.opval)), (ps[(1) - (3)].val.opval)); ;}
break;
case 65:
-#line 521 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval),
(ps[-2].val.opval)); }
-
+#line 521 "perly.y"
+ { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval),
(ps[(1) - (3)].val.opval)); ;}
break;
case 66:
-#line 523 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[0].val.opval),
(ps[-2].val.opval), (OP*)NULL);
- parser->copline = (line_t)(ps[-1].val.ival); }
-
+#line 523 "perly.y"
+ { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval),
(ps[(1) - (3)].val.opval), (OP*)NULL);
+ parser->copline = (line_t)(ps[(2) - (3)].val.ival); ;}
break;
case 67:
-#line 526 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newWHENOP((ps[0].val.opval),
op_scope((ps[-2].val.opval))); }
-
+#line 526 "perly.y"
+ { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) -
(3)].val.opval))); ;}
break;
case 68:
-#line 531 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 531 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 69:
-#line 533 "perly.y" /* yacc.c:1646 */
+#line 533 "perly.y"
{
- ((ps[0].val.opval))->op_flags |= OPf_PARENS;
- (yyval.opval) = op_scope((ps[0].val.opval));
- }
-
+ ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
+ (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
+ ;}
break;
case 70:
-#line 538 "perly.y" /* yacc.c:1646 */
- { parser->copline = (line_t)(ps[-5].val.ival);
+#line 538 "perly.y"
+ { parser->copline = (line_t)(ps[(1) - (6)].val.ival);
(yyval.opval) = newCONDOP(0,
- newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
- op_scope((ps[-1].val.opval)),
(ps[0].val.opval));
+ newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) -
(6)].val.opval)),
+ op_scope((ps[(5) - (6)].val.opval)), (ps[(6) -
(6)].val.opval));
PL_hints |= HINT_BLOCK_SCOPE;
- }
-
+ ;}
break;
case 71:
-#line 548 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 548 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 72:
-#line 550 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_scope((ps[0].val.opval)); }
-
+#line 550 "perly.y"
+ { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); ;}
break;
case 73:
-#line 555 "perly.y" /* yacc.c:1646 */
+#line 555 "perly.y"
{ (yyval.ival) = (PL_min_intro_pending &&
PL_max_intro_pending >= PL_min_intro_pending);
- intro_my(); }
-
+ intro_my(); ;}
break;
case 74:
-#line 561 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 561 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 76:
-#line 567 "perly.y" /* yacc.c:1646 */
+#line 567 "perly.y"
{ YYSTYPE tmplval;
(void)scan_num("1", &tmplval);
- (yyval.opval) = tmplval.opval; }
-
+ (yyval.opval) = tmplval.opval; ;}
break;
case 78:
-#line 575 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
-
+#line 575 "perly.y"
+ { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
break;
case 79:
-#line 580 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); intro_my(); }
-
+#line 580 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
break;
case 80:
-#line 584 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); intro_my(); }
-
+#line 584 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
break;
case 81:
-#line 587 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 587 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 82:
-#line 588 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 588 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 83:
-#line 592 "perly.y" /* yacc.c:1646 */
+#line 592 "perly.y"
{ (yyval.ival) = start_subparse(FALSE, 0);
- SAVEFREESV(PL_compcv); }
-
+ SAVEFREESV(PL_compcv); ;}
break;
case 84:
-#line 598 "perly.y" /* yacc.c:1646 */
+#line 598 "perly.y"
{ (yyval.ival) = start_subparse(FALSE, CVf_ANON);
- SAVEFREESV(PL_compcv); }
-
+ SAVEFREESV(PL_compcv); ;}
break;
case 85:
-#line 603 "perly.y" /* yacc.c:1646 */
+#line 603 "perly.y"
{ (yyval.ival) = start_subparse(TRUE, 0);
- SAVEFREESV(PL_compcv); }
-
+ SAVEFREESV(PL_compcv); ;}
break;
case 88:
-#line 614 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 614 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 90:
-#line 620 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 620 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 91:
-#line 622 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 622 "perly.y"
+ { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
break;
case 92:
-#line 624 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 624 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 93:
-#line 629 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 629 "perly.y"
+ { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
break;
case 94:
-#line 631 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 631 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 95:
-#line 642 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 642 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 96:
-#line 644 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 644 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 97:
-#line 649 "perly.y" /* yacc.c:1646 */
- { (yyval.ival) = '@'; }
-
+#line 649 "perly.y"
+ { (yyval.ival) = '@'; ;}
break;
case 98:
-#line 651 "perly.y" /* yacc.c:1646 */
- { (yyval.ival) = '%'; }
-
+#line 651 "perly.y"
+ { (yyval.ival) = '%'; ;}
break;
case 99:
-#line 655 "perly.y" /* yacc.c:1646 */
+#line 655 "perly.y"
{
- I32 sigil = (ps[-2].val.ival);
- OP *var = (ps[-1].val.opval);
- OP *defexpr = (ps[0].val.opval);
+ I32 sigil = (ps[(1) - (3)].val.ival);
+ OP *var = (ps[(2) - (3)].val.opval);
+ OP *defexpr = (ps[(3) - (3)].val.opval);
- if (PL_parser->sig_slurpy)
+ if (parser->sig_slurpy)
yyerror("Multiple slurpy parameters not
allowed");
- PL_parser->sig_slurpy = (char)sigil;
+ parser->sig_slurpy = (char)sigil;
if (defexpr)
yyerror("A slurpy parameter may not have "
"a default value");
(yyval.opval) = var ? newSTATEOP(0, NULL, var) :
(OP*)NULL;
- }
-
+ ;}
break;
case 100:
-#line 674 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 674 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 101:
-#line 676 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newOP(OP_NULL, 0); }
-
+#line 676 "perly.y"
+ { (yyval.opval) = newOP(OP_NULL, 0); ;}
break;
case 102:
-#line 678 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 678 "perly.y"
+ { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
break;
case 103:
-#line 684 "perly.y" /* yacc.c:1646 */
+#line 684 "perly.y"
{
- OP *var = (ps[-1].val.opval);
- OP *defexpr = (ps[0].val.opval);
+ OP *var = (ps[(2) - (3)].val.opval);
+ OP *defexpr = (ps[(3) - (3)].val.opval);
- if (PL_parser->sig_slurpy)
+ if (parser->sig_slurpy)
yyerror("Slurpy parameter not last");
- PL_parser->sig_elems++;
+ parser->sig_elems++;
if (defexpr) {
- PL_parser->sig_optelems++;
+ parser->sig_optelems++;
if ( defexpr->op_type == OP_NULL
&& !(defexpr->op_flags & OPf_KIDS))
@@ -882,7 +786,7 @@ case 2:
LINKLIST(defexpr));
/* re-purpose op_targ to hold @_ index */
defop->op_targ =
- (PADOFFSET)(PL_parser->sig_elems - 1);
+ (PADOFFSET)(parser->sig_elems - 1);
if (var) {
var->op_flags |= OPf_STACKED;
@@ -907,79 +811,70 @@ case 2:
}
}
else {
- if (PL_parser->sig_optelems)
+ if (parser->sig_optelems)
yyerror("Mandatory parameter "
"follows optional parameter");
}
(yyval.opval) = var ? newSTATEOP(0, NULL, var) :
(OP*)NULL;
- }
-
+ ;}
break;
case 104:
-#line 749 "perly.y" /* yacc.c:1646 */
- { parser->expect = XSIGVAR; (yyval.opval) = (ps[0].val.opval); }
-
+#line 749 "perly.y"
+ { parser->expect = XSIGVAR; (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 105:
-#line 751 "perly.y" /* yacc.c:1646 */
- { parser->expect = XSIGVAR; (yyval.opval) = (ps[0].val.opval); }
-
+#line 751 "perly.y"
+ { parser->expect = XSIGVAR; (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 106:
-#line 757 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[-1].val.opval); }
-
+#line 757 "perly.y"
+ { (yyval.opval) = (ps[(1) - (2)].val.opval); ;}
break;
case 107:
-#line 759 "perly.y" /* yacc.c:1646 */
+#line 759 "perly.y"
{
- (yyval.opval) = op_append_list(OP_LINESEQ,
(ps[-2].val.opval), (ps[0].val.opval));
- }
-
+ (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) -
(3)].val.opval), (ps[(3) - (3)].val.opval));
+ ;}
break;
case 108:
-#line 763 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 763 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 109:
-#line 768 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 768 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 110:
-#line 770 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[0].val.opval); }
-
+#line 770 "perly.y"
+ { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
break;
case 111:
-#line 774 "perly.y" /* yacc.c:1646 */
+#line 774 "perly.y"
{
ENTER;
- SAVEIV(PL_parser->sig_elems);
- SAVEIV(PL_parser->sig_optelems);
- SAVEI8(PL_parser->sig_slurpy);
- PL_parser->sig_elems = 0;
- PL_parser->sig_optelems = 0;
- PL_parser->sig_slurpy = 0;
+ SAVEIV(parser->sig_elems);
+ SAVEIV(parser->sig_optelems);
+ SAVEI8(parser->sig_slurpy);
+ parser->sig_elems = 0;
+ parser->sig_optelems = 0;
+ parser->sig_slurpy = 0;
parser->expect = XSIGVAR;
- }
-
+ ;}
break;
case 112:
-#line 786 "perly.y" /* yacc.c:1646 */
+#line 786 "perly.y"
{
- OP *sigops = (ps[-1].val.opval);
+ OP *sigops = (ps[(3) - (4)].val.opval);
UNOP_AUX_item *aux;
OP *check;
@@ -992,9 +887,9 @@ case 2:
aux = (UNOP_AUX_item*)PerlMemShared_malloc(
sizeof(UNOP_AUX_item) * 3);
- aux[0].iv = PL_parser->sig_elems;
- aux[1].iv = PL_parser->sig_optelems;
- aux[2].iv = PL_parser->sig_slurpy;
+ aux[0].iv = parser->sig_elems;
+ aux[1].iv = parser->sig_optelems;
+ aux[2].iv = parser->sig_slurpy;
check = newUNOP_AUX(OP_ARGCHECK, 0, NULL, aux);
sigops = op_prepend_elem(OP_LINESEQ, check,
sigops);
sigops = op_prepend_elem(OP_LINESEQ,
@@ -1008,361 +903,310 @@ case 2:
parser->expect = XATTRBLOCK;
LEAVE;
- }
-
+ ;}
break;
case 114:
-#line 823 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (OP*)NULL; }
-
+#line 823 "perly.y"
+ { (yyval.opval) = (OP*)NULL; ;}
break;
case 115:
-#line 828 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval),
(ps[0].val.opval)); }
-
+#line 828 "perly.y"
+ { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) -
(3)].val.opval)); ;}
break;
case 116:
-#line 830 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval),
(ps[0].val.opval)); }
-
+#line 830 "perly.y"
+ { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) -
(3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
break;
case 117:
-#line 832 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval),
(ps[0].val.opval)); }
-
+#line 832 "perly.y"
+ { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) -
(3)].val.opval)); ;}
break;
case 119:
-#line 838 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = (ps[-1].val.opval); }
-
+#line 838 "perly.y"
+ { (yyval.opval) = (ps[(1) - (2)].val.opval); ;}
break;
case 120:
-#line 840 "perly.y" /* yacc.c:1646 */
+#line 840 "perly.y"
{
- OP* term = (ps[0].val.opval);
- (yyval.opval) = op_append_elem(OP_LIST,
(ps[-2].val.opval), term);
- }
-
+ OP* term = (ps[(3) - (3)].val.opval);
+ (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) -
(3)].val.opval), term);
+ ;}
break;
case 122:
-#line 849 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
- op_prepend_elem(OP_LIST,
newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
- }
-
+#line 849 "perly.y"
+ { (yyval.opval) = op_convert_list((ps[(1) - (3)].val.ival), OPf_STACKED,
+ op_prepend_elem(OP_LIST, newGVREF((ps[(1) -
(3)].val.ival),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
+ ;}
break;
case 123:
-#line 853 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
- op_prepend_elem(OP_LIST,
newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
- }
-
+#line 853 "perly.y"
+ { (yyval.opval) = op_convert_list((ps[(1) - (5)].val.ival), OPf_STACKED,
+ op_prepend_elem(OP_LIST, newGVREF((ps[(1) -
(5)].val.ival),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
+ ;}
break;
case 124:
-#line 857 "perly.y" /* yacc.c:1646 */
+#line 857 "perly.y"
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
- op_prepend_elem(OP_LIST,
scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
- newMETHOP(OP_METHOD, 0,
(ps[-3].val.opval))));
- }
-
+ op_prepend_elem(OP_LIST, scalar((ps[(1) -
(6)].val.opval)), (ps[(5) - (6)].val.opval)),
+ newMETHOP(OP_METHOD, 0, (ps[(3) -
(6)].val.opval))));
+ ;}
break;
case 125:
-#line 863 "perly.y" /* yacc.c:1646 */
+#line 863 "perly.y"
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
- op_append_elem(OP_LIST,
scalar((ps[-2].val.opval)),
- newMETHOP(OP_METHOD, 0,
(ps[0].val.opval))));
- }
-
+ op_append_elem(OP_LIST, scalar((ps[(1) -
(3)].val.opval)),
+ newMETHOP(OP_METHOD, 0, (ps[(3) -
(3)].val.opval))));
+ ;}
break;
case 126:
-#line 868 "perly.y" /* yacc.c:1646 */
+#line 868 "perly.y"
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
- op_prepend_elem(OP_LIST,
(ps[-1].val.opval), (ps[0].val.opval)),
- newMETHOP(OP_METHOD, 0,
(ps[-2].val.opval))));
- }
-
+ op_prepend_elem(OP_LIST, (ps[(2) -
(3)].val.opval), (ps[(3) - (3)].val.opval)),
+ newMETHOP(OP_METHOD, 0, (ps[(1) -
(3)].val.opval))));
+ ;}
break;
case 127:
-#line 874 "perly.y" /* yacc.c:1646 */
+#line 874 "perly.y"
{ (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
- op_prepend_elem(OP_LIST,
(ps[-3].val.opval), (ps[-1].val.opval)),
- newMETHOP(OP_METHOD, 0,
(ps[-4].val.opval))));
- }
-
+ op_prepend_elem(OP_LIST, (ps[(2) -
(5)].val.opval), (ps[(4) - (5)].val.opval)),
+ newMETHOP(OP_METHOD, 0, (ps[(1) -
(5)].val.opval))));
+ ;}
break;
case 128:
-#line 880 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0,
(ps[0].val.opval)); }
-
+#line 880 "perly.y"
+ { (yyval.opval) = op_convert_list((ps[(1) - (2)].val.ival), 0, (ps[(2) -
(2)].val.opval)); ;}
break;
case 129:
-#line 882 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0,
(ps[-1].val.opval)); }
-
+#line 882 "perly.y"
+ { (yyval.opval) = op_convert_list((ps[(1) - (4)].val.ival), 0, (ps[(3) -
(4)].val.opval)); ;}
break;
case 130:
-#line 884 "perly.y" /* yacc.c:1646 */
+#line 884 "perly.y"
{ SvREFCNT_inc_simple_void(PL_compcv);
- (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0,
(OP*)NULL, (ps[0].val.opval)); }
-
+ (yyval.opval) = newANONATTRSUB((ps[(2) -
(3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
break;
case 131:
-#line 887 "perly.y" /* yacc.c:1646 */
+#line 887 "perly.y"
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
op_append_elem(OP_LIST,
- op_prepend_elem(OP_LIST, (ps[-1].val.opval),
(ps[0].val.opval)), (ps[-4].val.opval)));
- }
-
+ op_prepend_elem(OP_LIST, (ps[(4) -
(5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
+ ;}
break;
case 134:
-#line 902 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval),
scalar((ps[-2].val.opval))); }
-
+#line 902 "perly.y"
+ { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval),
scalar((ps[(3) - (5)].val.opval))); ;}
break;
case 135:
-#line 904 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)),
scalar((ps[-1].val.opval)));
- }
-
+#line 904 "perly.y"
+ { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)),
scalar((ps[(3) - (4)].val.opval)));
+ ;}
break;
case 136:
-#line 907 "perly.y" /* yacc.c:1646 */
+#line 907 "perly.y"
{ (yyval.opval) = newBINOP(OP_AELEM, 0,
-
ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
- scalar((ps[-1].val.opval)));
- }
-
+ ref(newAVREF((ps[(1) -
(5)].val.opval)),OP_RV2AV),
+ scalar((ps[(4) - (5)].val.opval)));
+ ;}
break;
case 137:
-#line 912 "perly.y" /* yacc.c:1646 */
+#line 912 "perly.y"
{ (yyval.opval) = newBINOP(OP_AELEM, 0,
-
ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
- scalar((ps[-1].val.opval)));
- }
-
+ ref(newAVREF((ps[(1) -
(4)].val.opval)),OP_RV2AV),
+ scalar((ps[(3) - (4)].val.opval)));
+ ;}
break;
case 138:
-#line 917 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)),
jmaybe((ps[-2].val.opval)));
- }
-
+#line 917 "perly.y"
+ { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)),
jmaybe((ps[(3) - (5)].val.opval)));
+ ;}
break;
case 139:
-#line 920 "perly.y" /* yacc.c:1646 */
+#line 920 "perly.y"
{ (yyval.opval) = newBINOP(OP_HELEM, 0,
-
ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
- jmaybe((ps[-2].val.opval))); }
-
+ ref(newHVREF((ps[(1) -
(6)].val.opval)),OP_RV2HV),
+ jmaybe((ps[(4) - (6)].val.opval))); ;}
break;
case 140:
-#line 924 "perly.y" /* yacc.c:1646 */
+#line 924 "perly.y"
{ (yyval.opval) = newBINOP(OP_HELEM, 0,
-
ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
- jmaybe((ps[-2].val.opval))); }
-
+ ref(newHVREF((ps[(1) -
(5)].val.opval)),OP_RV2HV),
+ jmaybe((ps[(3) - (5)].val.opval))); ;}
break;
case 141:
-#line 928 "perly.y" /* yacc.c:1646 */
+#line 928 "perly.y"
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
- newCVREF(0, scalar((ps[-3].val.opval)))); }
-
+ newCVREF(0, scalar((ps[(1) -
(4)].val.opval)))); ;}
break;
case 142:
-#line 931 "perly.y" /* yacc.c:1646 */
+#line 931 "perly.y"
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
- op_append_elem(OP_LIST, (ps[-1].val.opval),
- newCVREF(0,
scalar((ps[-4].val.opval))))); }
-
+ op_append_elem(OP_LIST, (ps[(4) -
(5)].val.opval),
+ newCVREF(0, scalar((ps[(1) -
(5)].val.opval))))); ;}
break;
case 143:
-#line 936 "perly.y" /* yacc.c:1646 */
+#line 936 "perly.y"
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
- op_append_elem(OP_LIST, (ps[-1].val.opval),
- newCVREF(0,
scalar((ps[-3].val.opval))))); }
-
+ op_append_elem(OP_LIST, (ps[(3) -
(4)].val.opval),
+ newCVREF(0, scalar((ps[(1) -
(4)].val.opval))))); ;}
break;
case 144:
-#line 940 "perly.y" /* yacc.c:1646 */
+#line 940 "perly.y"
{ (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
- newCVREF(0, scalar((ps[-2].val.opval)))); }
-
+ newCVREF(0, scalar((ps[(1) -
(3)].val.opval)))); ;}
break;
case 145:
-#line 943 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
-
+#line 943 "perly.y"
+ { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) -
(6)].val.opval)); ;}
break;
case 146:
-#line 945 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
-
+#line 945 "perly.y"
+ { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) -
(4)].val.opval)); ;}
break;
case 147:
-#line 947 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (OP*)NULL); }
-
+#line 947 "perly.y"
+ { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); ;}
break;
case 148:
-#line 952 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval),
(ps[-1].val.ival), (ps[0].val.opval)); }
-
+#line 952 "perly.y"
+ { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval),
(ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); ;}
break;
case 149:
-#line 954 "perly.y" /* yacc.c:1646 */
- { (yyval.opval) = newBINOP((ps[-1].val.ival), 0,
scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
-
+#line 954 "perly.y"
+ { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) -
(3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
**** PATCH TRUNCATED AT 2000 LINES -- 3227 NOT SHOWN ****
--
Perl5 Master Repository
