perl
view release on metacpan or search on metacpan
#define CvLVALUE(cv) (CvFLAGS(cv) & CVf_LVALUE)
#define CvLVALUE_on(cv) (CvFLAGS(cv) |= CVf_LVALUE)
#define CvLVALUE_off(cv) (CvFLAGS(cv) &= ~CVf_LVALUE)
/* eval or PL_main_cv */
#define CvEVAL(cv) (CvUNIQUE(cv) && !SvFAKE(cv))
#define CvEVAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_off(cv))
#define CvEVAL_off(cv) CvUNIQUE_off(cv)
/* BEGIN|CHECK|INIT|UNITCHECK|END */
#define CvSPECIAL(cv) (CvUNIQUE(cv) && SvFAKE(cv))
#define CvSPECIAL_on(cv) (CvUNIQUE_on(cv),SvFAKE_on(cv))
#define CvSPECIAL_off(cv) (CvUNIQUE_off(cv),SvFAKE_off(cv))
#define CvCONST(cv) (CvFLAGS(cv) & CVf_CONST)
#define CvCONST_on(cv) (CvFLAGS(cv) |= CVf_CONST)
#define CvCONST_off(cv) (CvFLAGS(cv) &= ~CVf_CONST)
#define CvWEAKOUTSIDE(cv) (CvFLAGS(cv) & CVf_WEAKOUTSIDE)
#define CvWEAKOUTSIDE_on(cv) (CvFLAGS(cv) |= CVf_WEAKOUTSIDE)
dist/Attribute-Handlers/lib/Attribute/Handlers.pm view on Meta::CPAN
=head1 DESCRIPTION
This module, when inherited by a package, allows that package's class to
define attribute handler subroutines for specific attributes. Variables
and subroutines subsequently defined in that package, or in packages
derived from that package may be given attributes with the same names as
the attribute handler subroutines, which will then be called in one of
the compilation phases (i.e. in a C<BEGIN>, C<CHECK>, C<INIT>, or C<END>
block). (C<UNITCHECK> blocks don't correspond to a global compilation
phase, so they can't be specified here.)
To create a handler, define it as a subroutine with the same name as
the desired attribute, and declare the subroutine itself with the
attribute C<:ATTR>. For example:
package LoudDecl;
use Attribute::Handlers;
sub Loud :ATTR {
dist/Devel-PPPort/parts/base/5009005 view on Meta::CPAN
isGV_with_GP_on # Z added by devel/scanprov
is_LNBREAK_latin1_safe # Z added by devel/scanprov
is_LNBREAK_safe # Z added by devel/scanprov
is_LNBREAK_utf8_safe # Z added by devel/scanprov
IS_TRIE_AC # Z added by devel/scanprov
KEEPCOPY_PAT_MOD # Z added by devel/scanprov
KEEPCOPY_PAT_MODS # Z added by devel/scanprov
KEEPS # Z added by devel/scanprov
KEEPS_next # Z added by devel/scanprov
KEEPS_next_fail # Z added by devel/scanprov
KEY_UNITCHECK # Z added by devel/scanprov
LNBREAK # Z added by devel/scanprov
LOOP_PAT_MODS # Z added by devel/scanprov
L_R_TZSET # K added by devel/scanprov
MARKPOINT # Z added by devel/scanprov
MARKPOINT_next # Z added by devel/scanprov
MARKPOINT_next_fail # Z added by devel/scanprov
MAX_RECURSE_EVAL_NOCHANGE_DEPTH # Z added by devel/scanprov
memEQs # U
memNEs # U
MEM_SIZE_MAX # Z added by devel/scanprov
dist/ExtUtils-ParseXS/Changes view on Meta::CPAN
Other:
- Removed PERL_CORE specific @INC manipulation (no longer needed)
[Nicholas Clark]
- Changed hard-coded $^H manipulation in favor of "use re 'eval'"
[Nicholas Clark]
2.200402 - Fri Oct 2 01:26:40 EDT 2009
Bug fixes:
- UNITCHECK subroutines were not being called (detected in ext/XS-APItest
in Perl blead) [reported by Jesse Vincent, patched by David Golden]
2.200401 - Mon Sep 14 22:26:03 EDT 2009
- No changes from 2.20_04.
2.20_04 - Mon Aug 10 11:18:47 EDT 2009
Bug fixes:
dist/ExtUtils-ParseXS/Changes view on Meta::CPAN
- Allow (pedantically correct) C pre-processor comments in the code
snippets of typemap files. [Nicholas Clark]
2.19 - Sun Feb 17 14:27:40 2008
- Fixed the treatment of the OVERLOAD: keyword, which was causing a C
compile error. [Toshiyuki Yamato]
2.18 - Mon Jan 29 20:56:36 2007
- Added some UNITCHECK stuff, which (I think) makes XS code able to
do UNITCHECK blocks. [Nicholas Clark]
- Changed 'use re "eval";' to 'BEGIN { $^H |= 0x00200000 };' so we
can compile re.xs in bleadperl. [Yves Orton]
- Fix an undefined-variable warning related to 'inout' parameter
processing.
2.17 - Mon Nov 20 17:07:27 2006
- Stacked $filepathname to make #line directives in #INCLUDEs work.
dist/constant/Changes view on Meta::CPAN
1.15 2007.12.31 SAPER (Sébastien Aperghis-Tramoni)
[TEST] Adjusted t/constant.t to how empty prototypes are reported
among different versions of Perl (thus fixing the FAIL reports for
Perl 5.8.0 to 5.8.3).
1.14 2007.12.27 SAPER (Sébastien Aperghis-Tramoni)
[DIST] CPAN-RT#31627: Specify core install dir in Build.PL.
Thanks to Michael G Schwern.
1.13 2007.12.27 SAPER (Sébastien Aperghis-Tramoni)
[CODE] Merged changed blead@32338: UNITCHECK is only a keyword
post 5.009 (Nicholas Clark).
[DIST] Copied the sysnopsis into eg/
1.12 2007.11.06 SAPER (Sébastien Aperghis-Tramoni)
[DIST] CPAN-RT#30460: The module must be installed in core, not in
site (because it get shadowed). Thanks to Imacat.
1.11 2007.09.25 SAPER (Sébastien Aperghis-Tramoni)
[CODE] Fixed code and tests so everything work under Perl 5.005.
[DOC] Some Pod nits. Added information about current maintainers.
1.10 2007.04.19
blead@30980: C3 MRO support (Brandon L Black).
blead@30824: Small fix for Symbian (Jarkko Hietaniemi).
1.09 2007.03.13
blead@30561: Inform constant.pm about UNITCHECK (Joshua ben Jore).
1.08 2007.02.13
blead@30255: Remove some debugging code (Nicholas Clark).
blead@26502: Use Internals::inc_sub_generation() to invalidate
cached methods (Nicholas Clark).
1.07 2005.12.26
blead@26487: Rework constant.pm to take advantage of the space
savings of proxy constant subroutines whenever it can (Nicholas Clark).
blead@26485: Factore caller() call out of the loop (Nicholas Clark).
dist/constant/lib/constant.pm view on Meta::CPAN
use strict;
use warnings::register;
our $VERSION = '1.33';
our %declared;
#=======================================================================
# Some names are evil choices.
my %keywords = map +($_, 1), qw{ BEGIN INIT CHECK END DESTROY AUTOLOAD };
$keywords{UNITCHECK}++ if $] > 5.009;
my %forced_into_main = map +($_, 1),
qw{ STDIN STDOUT STDERR ARGV ARGVOUT ENV INC SIG };
my %forbidden = (%keywords, %forced_into_main);
my $normal_constant_name = qr/^_?[^\W_0-9]\w*\z/;
my $tolerable = qr/^[A-Za-z_]\w*\z/;
my $boolean = qr/^[01]?\z/;
dist/constant/t/constant.t view on Meta::CPAN
use constant 'DESTROY' => 1 ;
use constant 'AUTOLOAD' => 1 ;
use constant 'STDIN' => 1 ;
use constant 'STDOUT' => 1 ;
use constant 'STDERR' => 1 ;
use constant 'ARGV' => 1 ;
use constant 'ARGVOUT' => 1 ;
use constant 'ENV' => 1 ;
use constant 'INC' => 1 ;
use constant 'SIG' => 1 ;
use constant 'UNITCHECK' => 1;
};
my @Expected_Warnings =
(
qr/^Constant name 'BEGIN' is a Perl keyword at/,
qr/^Constant subroutine BEGIN redefined at/,
qr/^Constant name 'INIT' is a Perl keyword at/,
qr/^Constant name 'CHECK' is a Perl keyword at/,
qr/^Constant name 'END' is a Perl keyword at/,
qr/^Constant name 'DESTROY' is a Perl keyword at/,
qr/^Constant name 'AUTOLOAD' is a Perl keyword at/,
qr/^Constant name 'STDIN' is forced into package main:: a/,
qr/^Constant name 'STDOUT' is forced into package main:: at/,
qr/^Constant name 'STDERR' is forced into package main:: at/,
qr/^Constant name 'ARGV' is forced into package main:: at/,
qr/^Constant name 'ARGVOUT' is forced into package main:: at/,
qr/^Constant name 'ENV' is forced into package main:: at/,
qr/^Constant name 'INC' is forced into package main:: at/,
qr/^Constant name 'SIG' is forced into package main:: at/,
qr/^Constant name 'UNITCHECK' is a Perl keyword at/,
);
unless ($] > 5.009) {
# Remove the UNITCHECK warning
pop @Expected_Warnings;
# But keep the count the same
push @Expected_Warnings, qr/^$/;
push @warnings, "";
}
# when run under "make test"
if (@warnings == 16) {
push @warnings, "";
push @Expected_Warnings, qr/^$/;
dist/threads/lib/threads.pm view on Meta::CPAN
Returning blessed objects from threads does not work. Depending on the classes
involved, you may be able to work around this by returning a serialized
version of the object (e.g., using L<Data::Dumper> or L<Storable>), and then
reconstituting it in the joining thread. If you're using Perl 5.10.0 or
later, and if the class supports L<shared objects|threads::shared/"OBJECTS">,
you can pass them via L<shared queues|Thread::Queue>.
=item END blocks in threads
It is possible to add L<END blocks|perlmod/"BEGIN, UNITCHECK, CHECK, INIT and
END"> to threads by using L<require|perlfunc/"require VERSION"> or
L<eval|perlfunc/"eval EXPR"> with the appropriate code. These C<END> blocks
will then be executed when the thread's interpreter is destroyed (i.e., either
during a C<-E<gt>join()> call, or at program termination).
However, calling any L<threads> methods in such an C<END> block will most
likely I<fail> (e.g., the application may hang, or generate an error) due to
mutexes that are needed to control functionality within the L<threads> module.
For this reason, the use of C<END> blocks in threads is B<strongly>
=item init_av
Returns the AV object (i.e. in class B::AV) representing INIT blocks.
=item check_av
Returns the AV object (i.e. in class B::AV) representing CHECK blocks.
=item unitcheck_av
Returns the AV object (i.e. in class B::AV) representing UNITCHECK blocks.
=item begin_av
Returns the AV object (i.e. in class B::AV) representing BEGIN blocks.
=item end_av
Returns the AV object (i.e. in class B::AV) representing END blocks.
=item comppadlist
ext/B/B/Concise.pm view on Meta::CPAN
B::begin_av->isa("B::AV") ?
B::begin_av->ARRAY : ());
} elsif ($objname eq "INIT") {
concise_specials("INIT", $order,
B::init_av->isa("B::AV") ?
B::init_av->ARRAY : ());
} elsif ($objname eq "CHECK") {
concise_specials("CHECK", $order,
B::check_av->isa("B::AV") ?
B::check_av->ARRAY : ());
} elsif ($objname eq "UNITCHECK") {
concise_specials("UNITCHECK", $order,
B::unitcheck_av->isa("B::AV") ?
B::unitcheck_av->ARRAY : ());
} elsif ($objname eq "END") {
concise_specials("END", $order,
B::end_av->isa("B::AV") ?
B::end_av->ARRAY : ());
}
else {
# convert function names to subrefs
if (ref $objname) {
ext/B/B/Concise.pm view on Meta::CPAN
subtle feature to provide some visual distinction between renderings
on threaded and un-threaded perls.
=head1 OPTIONS
Arguments that don't start with a hyphen are taken to be the names of
subroutines or formats to render; if no
such functions are specified, the main
body of the program (outside any subroutines, and not including use'd
or require'd files) is rendered. Passing C<BEGIN>, C<UNITCHECK>,
C<CHECK>, C<INIT>, or C<END> will cause all of the corresponding
special blocks to be printed. Arguments must follow options.
Options affect how things are rendered (ie printed). They're presented
here by their visual effect, 1st being strongest. They're grouped
according to how they interrelate; within each group the options are
mutually exclusive (unless otherwise stated).
=head2 Options for Opcode Ordering
ext/B/t/optree_specials.t view on Meta::CPAN
require_ok("B::Concise");
my $out = runperl(
switches => ["-MO=Concise,BEGIN,CHECK,INIT,END,-exec"],
prog => q{$a=$b && print q/foo/},
stderr => 1 );
#print "out:$out\n";
my $src = q[our ($beg, $chk, $init, $end, $uc) = qq{'foo'}; BEGIN { $beg++ } CHECK { $chk++ } INIT { $init++ } END { $end++ } UNITCHECK {$uc++}];
checkOptree ( name => 'BEGIN',
bcopts => 'BEGIN',
prog => $src,
strip_open_hints => 1,
expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# BEGIN 1:
# a <1> leavesub[1 ref] K/REFC,1 ->(end)
# - <@> lineseq KP ->a
ext/B/t/optree_specials.t view on Meta::CPAN
EOT_EOT
# CHECK 1:
# 4 <1> leavesub[1 ref] K/REFC,1 ->(end)
# - <@> lineseq KP ->4
# 1 <;> nextstate(main 3 -e:4) v:>,<,%,{ ->2
# 3 <1> postinc[t2] sK/1 ->4
# - <1> ex-rv2sv sKRM/1 ->3
# 2 <$> gvsv(*chk) s ->3
EONT_EONT
checkOptree ( name => 'UNITCHECK',
bcopts=> 'UNITCHECK',
prog => $src,
strip_open_hints => 1,
expect=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# UNITCHECK 1:
# 4 <1> leavesub[1 ref] K/REFC,1 ->(end)
# - <@> lineseq KP ->4
# 1 <;> nextstate(main 3 -e:4) v:>,<,%,{ ->2
# 3 <1> postinc[t3] sK/1 ->4
# - <1> ex-rv2sv sKRM/1 ->3
# 2 <#> gvsv[*uc] s ->3
EOT_EOT
# UNITCHECK 1:
# 4 <1> leavesub[1 ref] K/REFC,1 ->(end)
# - <@> lineseq KP ->4
# 1 <;> nextstate(main 3 -e:4) v:>,<,%,{ ->2
# 3 <1> postinc[t2] sK/1 ->4
# - <1> ex-rv2sv sKRM/1 ->3
# 2 <$> gvsv(*uc) s ->3
EONT_EONT
checkOptree ( name => 'INIT',
bcopts => 'INIT',
ext/B/t/optree_specials.t view on Meta::CPAN
EOT_EOT
# INIT 1:
# 4 <1> leavesub[1 ref] K/REFC,1 ->(end)
# - <@> lineseq KP ->4
# 1 <;> nextstate(main 4 -e:5) v:>,<,%,{ ->2
# 3 <1> postinc[t2] sK/1 ->4
# - <1> ex-rv2sv sKRM/1 ->3
# 2 <$> gvsv(*init) s ->3
EONT_EONT
checkOptree ( name => 'all of BEGIN END INIT CHECK UNITCHECK -exec',
bcopts => [qw/ BEGIN END INIT CHECK UNITCHECK -exec /],
prog => $src,
strip_open_hints => 1,
expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# BEGIN 1:
# 1 <;> nextstate(Exporter::Heavy -1410 Heavy.pm:4) v:*,&,{,x*,x&,x$,$
# 2 <$> const[PV "strict.pm"] s/BARE
# 3 <1> require sK/1
# 4 <;> nextstate(Exporter::Heavy -1410 Heavy.pm:4) :*,&,{,x*,x&,x$,$
# 5 <0> pushmark s
# 6 <$> const[PV "strict"] sM
ext/B/t/optree_specials.t view on Meta::CPAN
# INIT 1:
# 2e <;> nextstate(main 7 -e:1) v:{
# 2f <#> gvsv[*init] s
# 2g <1> postinc[t3] sK/1
# 2h <1> leavesub[1 ref] K/REFC,1
# CHECK 1:
# 2i <;> nextstate(main 5 -e:1) v:{
# 2j <#> gvsv[*chk] s
# 2k <1> postinc[t3] sK/1
# 2l <1> leavesub[1 ref] K/REFC,1
# UNITCHECK 1:
# 2m <;> nextstate(main 11 -e:1) v:{
# 2n <#> gvsv[*uc] s
# 2o <1> postinc[t3] sK/1
# 2p <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# BEGIN 1:
# 1 <;> nextstate(Exporter::Heavy -1410 Heavy.pm:4) v:*,&,{,x*,x&,x$,$
# 2 <$> const(PV "strict.pm") s/BARE
# 3 <1> require sK/1
# 4 <;> nextstate(Exporter::Heavy -1410 Heavy.pm:4) :*,&,{,x*,x&,x$,$
ext/B/t/optree_specials.t view on Meta::CPAN
# INIT 1:
# 2e <;> nextstate(main 7 -e:1) v:{
# 2f <$> gvsv(*init) s
# 2g <1> postinc[t2] sK/1
# 2h <1> leavesub[1 ref] K/REFC,1
# CHECK 1:
# 2i <;> nextstate(main 5 -e:1) v:{
# 2j <$> gvsv(*chk) s
# 2k <1> postinc[t2] sK/1
# 2l <1> leavesub[1 ref] K/REFC,1
# UNITCHECK 1:
# 2m <;> nextstate(main 11 -e:1) v:{
# 2n <$> gvsv(*uc) s
# 2o <1> postinc[t2] sK/1
# 2p <1> leavesub[1 ref] K/REFC,1
EONT_EONT
# perl "-I../lib" -MO=Concise,BEGIN,CHECK,INIT,END,-exec -e '$a=$b && print q/foo/'
checkOptree ( name => 'regression test for patch 25352',
bcopts => [qw/ BEGIN END INIT CHECK -exec /],
ext/XS-APItest/APItest.pm view on Meta::CPAN
my @carp = keys %$exports;
if (@carp) {
croak(join '',
(map "\"$_\" is not exported by the $package module\n", sort @carp),
"Can't continue after import errors");
}
}
}
use vars '$WARNINGS_ON_BOOTSTRAP';
use vars map "\$${_}_called_PP", qw(BEGIN UNITCHECK CHECK INIT END);
# Do these here to verify that XS code and Perl code get called at the same
# times
BEGIN {
$BEGIN_called_PP++;
}
UNITCHECK {
$UNITCHECK_called_PP++;
};
{
# Need $W false by default, as some tests run under -w, and under -w we
# can get warnings about "Too late to run CHECK" block (and INIT block)
no warnings 'void';
CHECK {
$CHECK_called_PP++;
}
INIT {
$INIT_called_PP++;
ext/XS-APItest/APItest.xs view on Meta::CPAN
BEGIN()
CODE:
sv_inc(get_sv("XS::APItest::BEGIN_called", GV_ADD|GV_ADDMULTI));
void
CHECK()
CODE:
sv_inc(get_sv("XS::APItest::CHECK_called", GV_ADD|GV_ADDMULTI));
void
UNITCHECK()
CODE:
sv_inc(get_sv("XS::APItest::UNITCHECK_called", GV_ADD|GV_ADDMULTI));
void
INIT()
CODE:
sv_inc(get_sv("XS::APItest::INIT_called", GV_ADD|GV_ADDMULTI));
void
END()
CODE:
sv_inc(get_sv("XS::APItest::END_called", GV_ADD|GV_ADDMULTI));
ext/XS-APItest/t/xs_special_subs.t view on Meta::CPAN
use strict;
use warnings;
use Test::More tests => 100;
# Doing this longhand cut&paste makes it clear
# BEGIN and INIT are FIFO, CHECK and END are LIFO
BEGIN {
print "# First BEGIN\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not yet called");
is($XS::APItest::CHECK_called, undef, "CHECK not yet called");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not yet called");
is($XS::APItest::INIT_called, undef, "INIT not yet called");
is($XS::APItest::INIT_called_PP, undef, "INIT not yet called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
CHECK {
print "# First CHECK\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, 1, "CHECK called");
is($XS::APItest::CHECK_called_PP, 1, "CHECK called");
is($XS::APItest::INIT_called, undef, "INIT not yet called");
is($XS::APItest::INIT_called_PP, undef, "INIT not yet called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
INIT {
print "# First INIT\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, 1, "CHECK called");
is($XS::APItest::CHECK_called_PP, 1, "CHECK called");
is($XS::APItest::INIT_called, undef, "INIT not yet called");
is($XS::APItest::INIT_called_PP, undef, "INIT not yet called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
END {
print "# First END\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, 1, "CHECK called");
is($XS::APItest::CHECK_called_PP, 1, "CHECK called");
is($XS::APItest::INIT_called, 1, "INIT called");
is($XS::APItest::INIT_called_PP, 1, "INIT called");
is($XS::APItest::END_called, 1, "END called");
is($XS::APItest::END_called_PP, 1, "END called");
}
print "# First body\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, 1, "CHECK called");
is($XS::APItest::CHECK_called_PP, 1, "CHECK called");
is($XS::APItest::INIT_called, 1, "INIT called");
is($XS::APItest::INIT_called_PP, 1, "INIT called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
use XS::APItest;
print "# Second body\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, 1, "CHECK called");
is($XS::APItest::CHECK_called_PP, 1, "CHECK called");
is($XS::APItest::INIT_called, 1, "INIT called");
is($XS::APItest::INIT_called_PP, 1, "INIT called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
BEGIN {
print "# Second BEGIN\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, undef, "CHECK not yet called");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not yet called");
is($XS::APItest::INIT_called, undef, "INIT not yet called");
is($XS::APItest::INIT_called_PP, undef, "INIT not yet called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
CHECK {
print "# Second CHECK\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK yet called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK yet called");
is($XS::APItest::CHECK_called, undef, "CHECK not yet called");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not yet called");
is($XS::APItest::INIT_called, undef, "INIT not yet called");
is($XS::APItest::INIT_called_PP, undef, "INIT not yet called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
INIT {
print "# Second INIT\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, 1, "CHECK called");
is($XS::APItest::CHECK_called_PP, 1, "CHECK called");
is($XS::APItest::INIT_called, 1, "INIT called");
is($XS::APItest::INIT_called_PP, 1, "INIT called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
END {
print "# Second END\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, 1, "CHECK called");
is($XS::APItest::CHECK_called_PP, 1, "CHECK called");
is($XS::APItest::INIT_called, 1, "INIT called");
is($XS::APItest::INIT_called_PP, 1, "INIT called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
ext/XS-APItest/t/xs_special_subs_require.t view on Meta::CPAN
use strict;
use warnings;
use Test::More tests => 103;
# Doing this longhand cut&paste makes it clear
# BEGIN and INIT are FIFO, CHECK and END are LIFO
BEGIN {
print "# First BEGIN\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not called");
is($XS::APItest::CHECK_called, undef, "CHECK not called");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called");
is($XS::APItest::INIT_called, undef, "INIT not called");
is($XS::APItest::INIT_called_PP, undef, "INIT not called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
CHECK {
print "# First CHECK\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not called");
is($XS::APItest::CHECK_called, undef, "CHECK not called (too late)");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called (too late)");
is($XS::APItest::INIT_called, undef, "INIT not called");
is($XS::APItest::INIT_called_PP, undef, "INIT not called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
INIT {
print "# First INIT\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not called");
is($XS::APItest::CHECK_called, undef, "CHECK not called (too late)");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called (too late)");
is($XS::APItest::INIT_called, undef, "INIT not called");
is($XS::APItest::INIT_called_PP, undef, "INIT not called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
END {
print "# First END\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, undef, "CHECK not called (too late)");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called (too late)");
is($XS::APItest::INIT_called, undef, "INIT not called (too late)");
is($XS::APItest::INIT_called_PP, undef, "INIT not called (too late)");
is($XS::APItest::END_called, 1, "END called");
is($XS::APItest::END_called_PP, 1, "END called");
}
print "# First body\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not called");
is($XS::APItest::CHECK_called, undef, "CHECK not called (too late)");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called (too late)");
is($XS::APItest::INIT_called, undef, "INIT not called (too late)");
is($XS::APItest::INIT_called_PP, undef, "INIT not called (too late)");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
{
my @trap;
local $SIG{__WARN__} = sub { push @trap, join "!", @_ };
ext/XS-APItest/t/xs_special_subs_require.t view on Meta::CPAN
@trap = sort @trap;
is(scalar @trap, 2, "There were 2 warnings");
like($trap[0], qr "^Too late to run CHECK block");
like($trap[1], qr "^Too late to run INIT block");
}
print "# Second body\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");;
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, undef, "CHECK not called (too late)");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called (too late)");
is($XS::APItest::INIT_called, undef, "INIT not called (too late)");
is($XS::APItest::INIT_called_PP, undef, "INIT not called (too late)");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
BEGIN {
print "# Second BEGIN\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not called");
is($XS::APItest::CHECK_called, undef, "CHECK not called");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called");
is($XS::APItest::INIT_called, undef, "INIT not called");
is($XS::APItest::INIT_called_PP, undef, "INIT not called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
CHECK {
print "# Second CHECK\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not yet called");
is($XS::APItest::CHECK_called, undef, "CHECK not called");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called");
is($XS::APItest::INIT_called, undef, "INIT not called");
is($XS::APItest::INIT_called_PP, undef, "INIT not called");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
INIT {
print "# Second INIT\n";
is($XS::APItest::BEGIN_called, undef, "BEGIN not yet called");
is($XS::APItest::BEGIN_called_PP, undef, "BEGIN not yet called");
is($XS::APItest::UNITCHECK_called, undef, "UNITCHECK not yet called");
is($XS::APItest::UNITCHECK_called_PP, undef, "UNITCHECK not yet called");
is($XS::APItest::CHECK_called, undef, "CHECK not called (too late)");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called (too late)");
is($XS::APItest::INIT_called, undef, "INIT not called (too late)");
is($XS::APItest::INIT_called_PP, undef, "INIT not called (too late)");
is($XS::APItest::END_called, undef, "END not yet called");
is($XS::APItest::END_called_PP, undef, "END not yet called");
}
END {
print "# Second END\n";
is($XS::APItest::BEGIN_called, 1, "BEGIN called");
is($XS::APItest::BEGIN_called_PP, 1, "BEGIN called");
is($XS::APItest::UNITCHECK_called, 1, "UNITCHECK called");
is($XS::APItest::UNITCHECK_called_PP, 1, "UNITCHECK called");
is($XS::APItest::CHECK_called, undef, "CHECK not called (too late)");
is($XS::APItest::CHECK_called_PP, undef, "CHECK not called (too late)");
is($XS::APItest::INIT_called, undef, "INIT not called (too late)");
is($XS::APItest::INIT_called_PP, undef, "INIT not called (too late)");
is($XS::APItest::END_called, 1, "END called");
is($XS::APItest::END_called_PP, 1, "END called");
}
assert(gv || stash);
assert(name);
if (!code) return NULL; /* Not a keyword */
switch (code < 0 ? -code : code) {
/* no support for \&CORE::infix;
no support for funcs that do not parse like funcs */
case KEY___DATA__: case KEY___END__ :
case KEY_ADJUST : case KEY_AUTOLOAD: case KEY_BEGIN : case KEY_CHECK :
case KEY_DESTROY : case KEY_END : case KEY_INIT : case KEY_UNITCHECK:
case KEY_and : case KEY_catch : case KEY_class :
case KEY_cmp : case KEY_default: case KEY_defer :
case KEY_do : case KEY_dump : case KEY_else : case KEY_elsif :
case KEY_eq : case KEY_eval : case KEY_field :
case KEY_finally:
case KEY_for : case KEY_foreach: case KEY_format: case KEY_ge :
case KEY_given : case KEY_goto : case KEY_grep : case KEY_gt :
case KEY_if : case KEY_isa :
case KEY_last :
case KEY_le : case KEY_local : case KEY_lt : case KEY_m :
PERLVAR(I, dbargs, AV *) /* args to call listed by caller function */
PERLVARA(I, DBcontrol, DBVARMG_COUNT, IV) /* IV versions of $DB::single, trace, signal */
/* symbol tables */
PERLVAR(I, debstash, HV *) /* symbol table for perldb package */
PERLVAR(I, globalstash, HV *) /* global keyword overrides imported here */
PERLVAR(I, curstname, SV *) /* name of current package */
PERLVAR(I, beginav, AV *) /* names of BEGIN subroutines */
PERLVAR(I, endav, AV *) /* names of END subroutines */
PERLVAR(I, unitcheckav, AV *) /* names of UNITCHECK subroutines */
PERLVAR(I, checkav, AV *) /* names of CHECK subroutines */
PERLVAR(I, initav, AV *) /* names of INIT subroutines */
/* subprocess state */
PERLVAR(I, fdpid, AV *) /* keep fd-to-pid mappings for my_popen */
/* internal state */
PERLVARI(I, op_mask, char *, NULL) /* masked operations for safe evals */
/* current interpreter roots */
PERLVAR(I, custom_op_descs, HV *) /* Descriptions of user defined ops */
#ifdef PERLIO_LAYERS
PERLVARI(I, perlio, PerlIOl *, NULL)
PERLVARI(I, known_layers, PerlIO_list_t *, NULL)
PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL)
#endif
PERLVARI(I, checkav_save, AV *, NULL) /* save CHECK{}s when compiling */
PERLVARI(I, unitcheckav_save, AV *, NULL)
/* save UNITCHECK{}s when compiling */
PERLVARI(I, clocktick, long, 0) /* this many times() ticks in a second */
/* Hooks to shared SVs and locks. */
PERLVARI(I, sharehook, share_proc_t, Perl_sv_nosharing)
PERLVARI(I, lockhook, share_proc_t, Perl_sv_nosharing)
#if defined(__HP_cc) || defined(__HP_aCC)
#pragma diag_suppress 3215
#endif
{
case 'U':
if (name[1] == 'N' &&
name[2] == 'I' &&
name[3] == 'T' &&
name[4] == 'C' &&
name[5] == 'H' &&
name[6] == 'E' &&
name[7] == 'C' &&
name[8] == 'K')
{ /* UNITCHECK */
return KEY_UNITCHECK;
}
goto unknown;
case '_':
if (name[1] == '_' &&
name[2] == 'C' &&
name[3] == 'L' &&
name[4] == 'A' &&
name[5] == 'S' &&
#define KEY___FILE__ 1
#define KEY___LINE__ 2
#define KEY___PACKAGE__ 3
#define KEY___CLASS__ 4
#define KEY___DATA__ 5
#define KEY___END__ 6
#define KEY___SUB__ 7
#define KEY_ADJUST 8
#define KEY_AUTOLOAD 9
#define KEY_BEGIN 10
#define KEY_UNITCHECK 11
#define KEY_DESTROY 12
#define KEY_END 13
#define KEY_INIT 14
#define KEY_CHECK 15
#define KEY_abs 16
#define KEY_accept 17
#define KEY_alarm 18
#define KEY_and 19
#define KEY_atan2 20
#define KEY_bind 21
lib/B/Deparse-core.t view on Meta::CPAN
__PACKAGE__
__CLASS__
ADJUST
AUTOLOAD
BEGIN
CHECK
CORE
DESTROY
END
INIT
UNITCHECK
catch
class
default
defer
else
elsif
field
finally
for
foreach
lib/B/Deparse.pm view on Meta::CPAN
}
if ($^W) { # deparse -w
print qq(BEGIN { \$^W = $^W; }\n);
}
if ($/ ne "\n" or defined $O::savebackslash) { # deparse -l and -0
my $fs = perlstring($/) || 'undef';
my $bs = perlstring($O::savebackslash) || 'undef';
print qq(BEGIN { \$/ = $fs; \$\\ = $bs; }\n);
}
my @BEGINs = B::begin_av->isa("B::AV") ? B::begin_av->ARRAY : ();
my @UNITCHECKs = B::unitcheck_av->isa("B::AV")
? B::unitcheck_av->ARRAY
: ();
my @CHECKs = B::check_av->isa("B::AV") ? B::check_av->ARRAY : ();
my @INITs = B::init_av->isa("B::AV") ? B::init_av->ARRAY : ();
my @ENDs = B::end_av->isa("B::AV") ? B::end_av->ARRAY : ();
my @names = qw(BEGIN UNITCHECK CHECK INIT END);
my @blocks = \(@BEGINs, @UNITCHECKs, @CHECKs, @INITs, @ENDs);
while (@names) {
my ($name, $blocks) = (shift @names, shift @blocks);
for my $block (@$blocks) {
$self->todo($block, 0, $name);
}
}
$self->stash_subs();
local($SIG{"__DIE__"}) =
sub {
if ($self->{'curcop'}) {
const char *colon;
const char *name;
PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS;
colon = strrchr(fullname,':');
name = colon ? colon + 1 : fullname;
if ((*name == 'B' && strEQ(name, "BEGIN"))
|| (*name == 'E' && strEQ(name, "END"))
|| (*name == 'U' && strEQ(name, "UNITCHECK"))
|| (*name == 'C' && strEQ(name, "CHECK"))
|| (*name == 'I' && strEQ(name, "INIT"))) {
if (!isGV(gv)) {
(void)CvGV(cv);
assert(isGV(gv));
}
GvCV_set(gv, NULL);
SvREFCNT_dec_NN(MUTABLE_SV(cv));
}
}
else
return FALSE;
} else {
if (*name == 'E') {
if (strEQ(name, "END")) {
DEBUG_x( dump_sub(gv) );
Perl_av_create_and_unshift_one(aTHX_ &PL_endav, MUTABLE_SV(cv));
} else
return FALSE;
} else if (*name == 'U') {
if (strEQ(name, "UNITCHECK")) {
/* It's never too late to run a unitcheck block */
Perl_av_create_and_unshift_one(aTHX_ &PL_unitcheckav, MUTABLE_SV(cv));
}
else
return FALSE;
} else if (*name == 'C') {
if (strEQ(name, "CHECK")) {
if (PL_main_start)
/* diag_listed_as: Too late to run %s block */
Perl_ck_warner(aTHX_ packWARN(WARN_VOID),
the argument strings must be in writable memory, and so mustn't just be
string constants.
C<env> specifies a set of environment variables that will be used by
this Perl interpreter. If non-null, it must point to a null-terminated
array of environment strings. If null, the Perl interpreter will use
the environment supplied by the C<environ> global variable.
This function initialises the interpreter, and parses and compiles the
script specified by the command-line arguments. This includes executing
code in C<BEGIN>, C<UNITCHECK>, and C<CHECK> blocks. It does not execute
C<INIT> blocks or the main program.
Returns an integer of slightly tricky interpretation. The correct
use of the return value is as a truth value indicating whether there
was a failure in initialisation. If zero is returned, this indicates
that initialisation was successful, and it is safe to proceed to call
L</perl_run> and make other use of it. If a non-zero value is returned,
this indicates some problem that means the interpreter wants to terminate.
The interpreter should not be just abandoned upon such failure; the caller
should proceed to shut the interpreter down cleanly with L</perl_destruct>
if (len) {
PL_curcop = &PL_compiling;
CopLINE_set(PL_curcop, oldline);
if (paramList == PL_beginav)
sv_catpvs(atsv, "BEGIN failed--compilation aborted");
else
Perl_sv_catpvf(aTHX_ atsv,
"%s failed--call queue aborted",
paramList == PL_checkav ? "CHECK"
: paramList == PL_initav ? "INIT"
: paramList == PL_unitcheckav ? "UNITCHECK"
: "END");
while (PL_scopestack_ix > oldscope)
LEAVE;
JMPENV_POP;
Perl_croak(aTHX_ "%" SVf, SVfARG(atsv));
}
break;
case 1:
STATUS_ALL_FAILURE;
/* FALLTHROUGH */
pod/perl5100delta.pod view on Meta::CPAN
A new prototype character has been added. C<_> is equivalent to C<$> but
defaults to C<$_> if the corresponding argument isn't supplied (both C<$>
and C<_> denote a scalar). Due to the optional nature of the argument,
you can only use it at the end of a prototype, or before a semicolon.
This has a small incompatible consequence: the prototype() function has
been adjusted to return C<_> for some built-ins in appropriate cases (for
example, C<prototype('CORE::rmdir')>). (Rafael Garcia-Suarez)
=head2 UNITCHECK blocks
C<UNITCHECK>, a new special code block has been introduced, in addition to
C<BEGIN>, C<CHECK>, C<INIT> and C<END>.
C<CHECK> and C<INIT> blocks, while useful for some specialized purposes,
are always executed at the transition between the compilation and the
execution of the main program, and thus are useless whenever code is
loaded at runtime. On the other hand, C<UNITCHECK> blocks are executed
just after the unit which defined them has been compiled. See L<perlmod>
for more information. (Alex Gough)
=head2 New Pragma, C<mro>
A new pragma, C<mro> (for Method Resolution Order) has been added. It
permits to switch, on a per-class basis, the algorithm that perl uses to
find inherited methods in case of a multiple inheritance hierarchy. The
default MRO hasn't changed (DFS, for Depth First Search). Another MRO is
available: the C3 algorithm. See L<mro> for more information.
pod/perl5140delta.pod view on Meta::CPAN
compiler, Perl now understands the size modifier "j" (C<intmax_t>)
(but this is not portable).
So, for example, on any modern machine, C<sprintf("%hhd", 257)> returns "1".
=head3 New global variable C<${^GLOBAL_PHASE}>
A new global variable, C<${^GLOBAL_PHASE}>, has been added to allow
introspection of the current phase of the Perl interpreter. It's explained in
detail in L<perlvar/"${^GLOBAL_PHASE}"> and in
L<perlmod/"BEGIN, UNITCHECK, CHECK, INIT and END">.
=head3 C<-d:-foo> calls C<Devel::foo::unimport>
The syntax B<-d:foo> was extended in 5.6.1 to make B<-d:foo=bar>
equivalent to B<-MDevel::foo=bar>, which expands
internally to C<use Devel::foo 'bar'>.
Perl now allows prefixing the module name with B<->, with the same
semantics as B<-M>; that is:
=over 4
pod/perl5140delta.pod view on Meta::CPAN
to turn into
$text =~ /phoo/
at compile time. Now it correctly matches against C<$_> [perl #20444].
=item *
Parsing Perl code (either with string C<eval> or by loading modules) from
within a C<UNITCHECK> block no longer causes the interpreter to crash
[perl #70614].
=item *
String C<eval>s no longer fail after 2 billion scopes have been
compiled [perl #83364].
=item *
The parser no longer hangs when encountering certain Unicode characters,
pod/perl5160delta.pod view on Meta::CPAN
of C<\Q> and escapes like C<\x>, C<\L>, etc., within a C<\Q...\E> pair.
These need to be fixed, and doing so will necessarily change current
behavior. The changes have not yet been settled.
=back
=head1 Incompatible Changes
=head2 Special blocks called in void context
Special blocks (C<BEGIN>, C<CHECK>, C<INIT>, C<UNITCHECK>, C<END>) are now
called in void context. This avoids wasteful copying of the result of the
last statement [perl #108794].
=head2 The C<overloading> pragma and regexp objects
With C<no overloading>, regular expression objects returned by C<qr//> are
now stringified as "Regexp=REGEXP(0xbe600d)" instead of the regular
expression itself [perl #108780].
=head2 Two XS typemap Entries removed
pod/perl5320delta.pod view on Meta::CPAN
The API eval_sv() now accepts a C<G_RETHROW> flag. If this flag is set and an
exception is thrown while compiling or executing the supplied code, it will be
rethrown, and eval_sv() will not return.
L<[GH #17036]|https://github.com/Perl/perl5/issues/17036>
=item *
As part of the fix for
L<[GH #1537]|https://github.com/Perl/perl5/issues/1537> perl_parse()
now returns non-zero if exit(0) is called in a C<BEGIN>, C<UNITCHECK> or
C<CHECK> block.
=item *
Most functions which recursively walked an op tree during compilation have been
made non-recursive. This avoids SEGVs from stack overflow when the op tree is
deeply nested, such as C<$n == 1 ? "one" : $n == 2 ? "two" : ....> (especially
in code which is auto-generated).
This is particularly noticeable where the code is compiled within a separate
pod/perl5320delta.pod view on Meta::CPAN
=item *
eval_pv()'s I<croak_on_error> flag will now throw even if the exception is a
false overloaded value.
L<[GH #17036]|https://github.com/Perl/perl5/issues/17036>
=item *
C<INIT> blocks and the program itself are no longer run if exit(0) is called
within a C<BEGIN>, C<UNITCHECK> or C<CHECK> block.
L<[GH #1537]|https://github.com/Perl/perl5/issues/1537>
=item *
C<< open my $fh, ">>+", undef >> now opens the temporary file in append mode:
writes will seek to the end of file before writing.
L<[GH #17058]|https://github.com/Perl/perl5/issues/17058>
=item *
pod/perl5360delta.pod view on Meta::CPAN
=back
=head2 C<defer> blocks (experimental)
This release adds support for C<defer> blocks, which are blocks of code
prefixed by the C<defer> modifier. They provide a section of code which runs
at a later time, during scope exit.
In brief, when a C<defer> block is reached at runtime, its body is set aside to
be run when the enclosing scope is exited. It is unlike a UNITCHECK (among
other reasons) in that if the block I<containing> the C<defer> block is exited
before the block is reached, it will not be run.
C<defer> blocks can be used to take the place of "scope guard" objects where an
object is passed a code block to be run by its destructor.
For more information, see L<perlsyn/"defer blocks">.
=head2 try/catch can now have a C<finally> block (experimental)
pod/perlclass.pod view on Meta::CPAN
say "x = $x";
}
}
my $object = WellAdjusted->new(x => 42);
# Output:
# Hello!
# x = 42
C<ADJUST> blocks are syntactically similar to L<C<BEGIN> or C<INIT>
blocks|perlmod/BEGIN, UNITCHECK, CHECK, INIT and END>, which only run once.
However, C<ADJUST> blocks, like methods, have access to C<$self> (a lexical
variable holding the object being constructed) as well as all object fields
created up to that point.
=head2 Lifetime
After the construction phase, the object is ready to be used.
Using C<blessed> (C<Scalar::Util::blessed> or C<builtin::blessed>) on the
object will return the name of the class, while C<reftype>
pod/perldebug.pod view on Meta::CPAN
When the C<frame> option is set, the debugger would print entered (and
optionally exited) subroutines in different styles. See L<perldebguts>
for incredibly long examples of these.
=back
=head2 Debugging Compile-Time Statements
If you have compile-time executable statements (such as code within
BEGIN, UNITCHECK and CHECK blocks or C<use> statements), these will
I<not> be stopped by debugger, although C<require>s and INIT blocks
will, and compile-time statements can be traced with the C<AutoTrace>
option set in C<PERLDB_OPTS>). From your own Perl code, however, you
can transfer control back to the debugger using the following
statement, which is harmless if the debugger is not running:
$DB::single = 1;
If you set C<$DB::single> to 2, it's equivalent to having
just typed the C<n> command, whereas a value of 1 means the C<s>
( run in 2.929 seconds using v1.01-cache-2.11-cpan-748bfb374f4 )