X-Git-Url: http://git.vpit.fr/?a=blobdiff_plain;ds=sidebyside;f=lib%2FScope%2FUpper.pm;h=ddbdc81a9bc7376e6e3ab6eea920c7fe61fbce57;hb=84662f0d82519cb851bb79144bc4b45aa78646f5;hp=6e02d2cc7d83004c609b9ff98f89a3d683aea727;hpb=1e8a530156ab09a816d8afc37692d1b46032eb32;p=perl%2Fmodules%2FScope-Upper.git
diff --git a/lib/Scope/Upper.pm b/lib/Scope/Upper.pm
index 6e02d2c..ddbdc81 100644
--- a/lib/Scope/Upper.pm
+++ b/lib/Scope/Upper.pm
@@ -9,61 +9,89 @@ Scope::Upper - Act on upper scopes.
=head1 VERSION
-Version 0.10
+Version 0.11
=cut
our $VERSION;
BEGIN {
- $VERSION = '0.10';
+ $VERSION = '0.11';
}
=head1 SYNOPSIS
- package X;
+L, L, L, L and L :
+
+ package Scope;
use Scope::Upper qw/reap localize localize_elem localize_delete :words/;
- sub desc { shift->{desc} }
+ sub new {
+ my ($class, $name) = @_;
+
+ localize '$tag' => bless({ name => $name }, $class) => UP;
+
+ reap { print Scope->tag->name, ": end\n" } UP;
+ }
- sub set_tag {
- my ($desc) = @_;
+ # Get the tag stored in the caller namespace
+ sub tag {
+ my $l = 0;
+ my $pkg = __PACKAGE__;
+ $pkg = caller $l++ while $pkg eq __PACKAGE__;
- # First localize $x so that it gets destroyed last
- localize '$x' => bless({ desc => $desc }, __PACKAGE__) => UP; # one scope up
+ no strict 'refs';
+ ${$pkg . '::tag'};
+ }
- reap sub {
- my $pkg = caller;
- my $x = do { no strict 'refs'; ${$pkg.'::x'} }; # Get the $x in the scope
- print $x->desc . ": done\n";
- } => SCOPE 1; # same as UP here
+ sub name { shift->{name} }
+ # Locally capture warnings and reprint them with the name prefixed
+ sub catch {
localize_elem '%SIG', '__WARN__' => sub {
- my $pkg = caller;
- my $x = do { no strict 'refs'; ${$pkg.'::x'} }; # Get the $x in the scope
- CORE::warn($x->desc . ': ' . join('', @_));
- } => UP CALLER 0; # same as UP here
+ print Scope->tag->name, ': ', @_;
+ } => UP;
+ }
- # delete last @ARGV element
- localize_delete '@ARGV', -1 => UP SUB HERE; # same as UP here
+ # Locally clear @INC
+ sub private {
+ for (reverse 0 .. $#INC) {
+ # First UP is the for loop, second is the sub boundary
+ localize_delete '@INC', $_ => UP UP;
+ }
}
- package Y;
+ ...
+
+ package UserLand;
{
- X::set_tag('pie');
- # $x is now a X object, and @ARGV has one element less
- warn 'what'; # warns "pie: what at ..."
- ...
- } # "pie: done" is printed
+ Scope->new("top"); # initializes $UserLand::tag
- package Z;
+ {
+ Scope->catch;
+ my $one = 1 + undef; # prints "top: Use of uninitialized value..."
+
+ {
+ Scope->private;
+ eval { require Cwd };
+ print $@; # prints "Can't locate Cwd.pm in @INC (@INC contains:) at..."
+ }
+
+ require Cwd; # loads Cwd.pm
+ }
+
+ } # prints "top: done"
+
+L and L :
+
+ package Try;
use Scope::Upper qw/unwind want_at :words/;
sub try (&) {
my @result = shift->();
- my $cx = SUB UP SUB;
+ my $cx = SUB UP; # Point to the sub above this one
unwind +(want_at($cx) ? @result : scalar @result) => $cx;
}
@@ -71,13 +99,15 @@ BEGIN {
sub zap {
try {
+ my @things = qw/a b c/;
return @things; # returns to try() and then outside zap()
# not reached
- }
+ };
# not reached
}
- my @what = zap(); # @what contains @things
+ my @stuff = zap(); # @stuff contains qw/a b c/
+ my $stuff = zap(); # $stuff contains 3
=head1 DESCRIPTION
@@ -143,8 +173,8 @@ For example,
will set C<$x> to a reference to the string C<'foo'>.
Other sigils (C<'@'>, C<'%'>, C<'&'> and C<'*'>) require C<$value> to be a reference of the corresponding type.
-When the symbol is given by a string, it is resolved when the actual localization takes place and not when C is called.
-Thus, if the symbol name is not qualified, it will refer to the variable in the package where the localization actually takes place and not in the one where the C call was compiled.
+When the symbol is given by a string, it is resolved when the actual localization takes place and not when L is called.
+Thus, if the symbol name is not qualified, it will refer to the variable in the package where the localization actually takes place and not in the one where the L call was compiled.
For example,
{
@@ -172,7 +202,8 @@ Although I believe it shouldn't be a problem as glob slots definedness is pretty
=head2 C
Introduces a C or C delayed to the time of first return into the upper scope denoted by C<$context>.
-Just like for L, the type of localization is determined from which kind of reference C<$value> is when C<$what> is a glob, and from the sigil when it's a string.
+Unlike L, C<$what> must be a string and the type of localization is inferred from its sigil.
+The two only valid types are array and hash ; for anything besides those, L will throw an exception.
C<$key> is either an array index or a hash key, depending of which kind of variable you localize.
If C<$what> is a string pointing to an undeclared variable, the variable will be vivified as soon as the localization occurs and emptied when it ends, although it will still exist in its glob.
@@ -395,11 +426,15 @@ L (standard since perl 5.006).
=head1 SEE ALSO
+L, L.
+
L, L, L, L.
L is a thin wrapper around L that gives you a continuation passing style interface to L.
It's easier to use, but it requires you to have control over the scope where you want to return.
+L.
+
=head1 AUTHOR
Vincent Pit, C<< >>, L.