Examing local's stack

[Ovid]

I have some code which relies heavily on the fact that I can localize variables in recursive functions. However, sometimes I need to examine the top of the local stack:

#!/usr/bin/perl -l

use strict;
use warnings;

our $x = 3;

foo(7);

sub foo {
    local $x = shift;
    print $x;
    # is there any way to get the "3" value?
}

The obvious solution is for me to cache the top-level values of the variables in question and that's probably what I will do, but I was wondering if there is any way to examine the stack created by local? I'd prefer to do this without C, but if I must ...

[chromatic]

If you only care about arguments passed to your recursive subroutine, you can use the uplevel_args() trick alluded to in caller:

package DB;

sub uplevel_args
{
    my $level = shift;
    my @foo   = caller( $level );
    return @DB::args;
}

Then just call this from your code to get the argument list passed to your code... most of the time.

[codeacrobat]

Don't know if this counts ;-)

$ perl -l
use strict;
use warnings;

our $x = 3;

foo(7);

sub foo {
  my $oldx=$x;
  local $x = shift;
  print $x;
  print $oldx;
}

[polettix]

This won't work with recursive functions:

#!/usr/bin/perl
use strict;
use warnings;

our $x = 3;

foo(7);

sub foo {
  my $oldx=$x;
  local $x = shift;
  print "localised x = $x\n";
  print "      old x = $oldx\n";
  foo(0) if $x; # recursive call, only 1 time
}

__END__
localised x = 7
      old x = 3
localised x = 0
      old x = 7

[Anonymous Monk]

The obvious solution is for me to cache the top-level values of the variables in question and that's probably what I will do, but I was wondering if there is any way to examine the stack created by local?

Create your own stack without bothering with local()? It doesn't sound like it's doing what you want it to do, so, performance issues aside, why bother with it?

{ # start of block of variables private to function foo()
my @stack;

sub foo {
    my ($var) = shift;
    push(@stack, $x);
    $x=$var;

    # code involving foo() and $x goes here...
    
    $x=pop(@stack);
} # end foo

} # end block of variables private to function foo()

Just a thought...

--
Ytrew

[adrianh]

Create your own stack without bothering with local()?

Or localise your stack.

our @x = 3;

foo(7);

sub foo {
    local @x = ( shift, @x );
    print $x[0], "\n";
}

Not the most efficient thing in the world though... I miss languages where I can apply expressions to dynamic scope entry/exit :-)

[Elian]

Do you not want C involved, or just don't want to write it? It seems a useful feature to have, albeit one that'll require some internals grovelling, and I've been hankering to grovel the internals again recently...

[Ovid]

I don't mind C being involved, but my C is weak and my knowledge of Perl's internals is even weaker. I wouldn't know where to start.

[Elian]

Gotcha. Okay, I think I may go fiddle then, and see what happens. That's always fun, if not a bit dangerous. :)