- 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
+ reap { print Scope->tag->name, ": end\n" } UP;
+ }
+
+ # Get the tag stored in the caller namespace
+ sub tag {
+ my $l = 0;
+ my $pkg = __PACKAGE__;
+ $pkg = caller $l++ while $pkg eq __PACKAGE__;
+
+ no strict 'refs';
+ ${$pkg . '::tag'};
+ }
+
+ sub name { shift->{name} }
- 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;
+ }
- 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
- use Scope::Upper qw/unwind want_at :words/;
+ {
+ 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</unwind> and L</want_at> :
+
+ package Try;
+
+ use Scope::Upper qw<unwind want_at :words>;
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.
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<localize> 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<localize> call was compiled.
+When the symbol is given by a string, it is resolved when the actual localization takes place and not when L</localize> 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</localize> call was compiled.
Note that if C<$what> is a string denoting a variable that wasn't declared beforehand, the relevant slot will be vivified as needed and won't be deleted from the glob when the localization ends.
This situation never arises with C<local> because it only compiles when the localized variable is already declared.
Note that if C<$what> is a string denoting a variable that wasn't declared beforehand, the relevant slot will be vivified as needed and won't be deleted from the glob when the localization ends.
This situation never arises with C<local> because it only compiles when the localized variable is already declared.
=head2 C<localize_elem $what, $key, $value, $context>
=head2 C<localize_elem $what, $key, $value, $context>
-Similar to L</localize> but for array and hash elements.
-If C<$what> is a glob, the slot to fill is determined from which type of reference C<$value> is ; otherwise it's inferred from the sigil.
+Introduces a C<local $what[$key] = $value> or C<local $what{$key} = $value> delayed to the time of first return into the upper scope denoted by C<$context>.
+Unlike L</localize>, 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</localize_elem> will throw an exception.
-Just like for L</localize>, when C<$what> is a string pointing to an undeclared variable, it will be vivified but the variable itself will be empty when the localization ends (although it will still exist in its parent glob).
+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.
-Returns C<@values> I<from> the context pointed by C<$context>, i.e. from the subroutine, eval or format just above C<$context>, and immediately restart the program flow at this point - thus effectively returning to (or from, depending on how you see it) an upper context.
+Returns C<@values> I<from> the context pointed by C<$context>, i.e. from the subroutine, eval or format at or just above C<$context>, and immediately restart the program flow at this point - thus effectively returning to an upper scope.
- funcs => [ qw/reap localize localize_elem localize_delete unwind want_at/ ],
- words => [ qw/TOP HERE UP SUB EVAL SCOPE CALLER/ ],
- consts => [ qw/SU_THREADSAFE/ ],
+ funcs => [ qw<reap localize localize_elem localize_delete unwind want_at> ],
+ words => [ qw<TOP HERE UP SUB EVAL SCOPE CALLER> ],
+ consts => [ qw<SU_THREADSAFE> ],
L<Alias>, L<Hook::Scope>, L<Scope::Guard>, L<Guard>.
L<Continuation::Escape> is a thin wrapper around L<Scope::Upper> that gives you a continuation passing style interface to L</unwind>.
It's easier to use, but it requires you to have control over the scope where you want to return.
L<Alias>, L<Hook::Scope>, L<Scope::Guard>, L<Guard>.
L<Continuation::Escape> is a thin wrapper around L<Scope::Upper> that gives you a continuation passing style interface to L</unwind>.
It's easier to use, but it requires you to have control over the scope where you want to return.
-Copyright 2008,2009,2010 Vincent Pit, all rights reserved.
+Copyright 2008,2009,2010,2011 Vincent Pit, all rights reserved.