How can I localize Perl variables in a different stack frame?

Question

I have some auto-generated code which effectively writes out the following in a bunch of different places in some code:

no warnings 'uninitialized';
local %ENV = %ENV;
local $/   = $/;
local @INC = @INC;
local %INC = %INC;
local $_   = $_;
local $|   = $|;
local %SIG = %SIG;
use warnings 'uninitialized';

When auto-generating code, some argue that it's not strictly necessary that the code be "beautiful", but I'd like to pull that out into a subroutine. However, that would localize those variables in that subroutine. Is there a way to localize those variables in the calling stack frame?

Update: In a similar vein, it would be nice to be able to run eval in a higher stack frame. I think Python already has this. It would be nice if Perl did, too.

Answer 1

I'm not terribly familiar with Perl, so forgive me if it is actually possible. But normally, variables local to a stack frame are only available within that stack frame. You can't access them from either a higher or lower one (unless you do some hacky pointer arithmetic but that's never guaranteed to succeed). Large blocks of variable declarations are unfortunately something you will have to live with.

QuantumPete

Answer 2

In TCL you can use uplevel. As for Perl, I don't know.

Answer 3

Not sure why QuantumPete is being downvoted, he seems to be right on this one. You can't tell local to initialize variables in the calling block. Its functionality is special, and the initialization/teardown that it does only works on the block where it was run.

There are some experimental modules such as Sub::Uplevel and Devel::RunBlock which allow you to attempt to "fool" caller() for subroutines or do a 'long jump return' of values to higher stack frames (respectively), but neither of these do anything to affect how local treats variables (I tried. :)

So for now, it does indeed look like you will have to live with the local declarations in the scope where you need them.

Answer 4

Perhaps you can arrange for the code that uses those locals to be generated as a closure? Then you could

sub run_with_env {
    my ($sub, @args) = @_;
    no warnings 'uninitialized';
    local %ENV = %ENV;
    local $/   = $/;
    local @INC = @INC;
    local %INC = %INC;
    local $_   = $_;
    local $|   = $|;
    local %SIG = %SIG;
    use warnings 'uninitialized';  
    $sub->(@args);
}

run_with_env(sub {
    # do stuff here
});

run_with_env(sub {
    # do different stuff here
});

Answer 5

perldoc perlguts says:

   The "Alias" module implements localization of the basic types within
   the caller's scope.  People who are interested in how to localize
   things in the containing scope should take a look there too.

FWIW. I haven't looked at Alias.pm closely enough to see how easy this might be.

Answer 6

Perl has Sub::Uplevel