Stories
Slash Boxes
Comments
NOTE: use Perl; is on undef hiatus. You can read content, but you can't post it. More info will be forthcoming forthcomingly.

All the Perl that's Practical to Extract and Report

use Perl Log In

Log In

[ Create a new account ]

Ovid (2709)

Ovid
  (email not shown publicly)
http://publius-ovidius.livejournal.com/
AOL IM: ovidperl (Add Buddy, Send Message)

Stuff with the Perl Foundation. A couple of patches in the Perl core. A few CPAN modules. That about sums it up.

Journal of Ovid (2709)

Tuesday April 14, 2009
04:38 AM

Programmatic Discovery of Package Variables in Perl?

[ #38807 ]

With Test::Most, you can do something like this:

ok $response = some_func($foo), 'some_func() should return something'
    or show $response;

And if the test fails, the show() function should display something like:

# $response = 0;

However, if $response is actually a package variable, you would get:

# $VAR1 = 0;

This is because show relies on Data::Dumper::Names and that, in turn, relies on PadWalker. So basically, I'm wondering how I know something is a package variable and how to (easily) find its name. The only thing which occurs to me offhand is to either programmatically fetch the names of Perl's special variables[1] and see if $VAR1 is really one of those. That might catch many package variables (and other "strange" variables like @_?), but is that enough? When people declare their own package variables, is there any easy way for me to find and identify them short of walking symbol tables looking for them?

1. I've seen this done, but I can't recall how to do it.

The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
 Full
 Abbreviated
 Hidden
More | Login | Reply
Loading... please wait.
  • PadWalker can see both lexical and package variables, just fill %pad_vars with peek_our first and let peek_my override it (since lexical variables hide package variables).
    • #!/usr/bin/perl

      use strict;
      use warnings;

      use PadWalker qw/peek_our peek_my/;
      use Scalar::Util 'refaddr';
      use Data::Dumper;

      our $foo = 1;
      our $bar = 2;
      {
              my $foo = 3;
              print "my masks our\n", dumper(\$foo, \$bar);
      }
      print "now both are our\n", dumper(\$foo, \$bar);

      sub dumper {
              my $package = peek_our(1);
              my $lexical = peek_my(1);
              my %pad_vars;
              while ( my

      • This seems to handle $" and the like:

        #!/usr/bin/perl

        use strict;
        use warnings;

        use PadWalker qw/peek_our peek_my/;
        use Scalar::Util 'refaddr';
        use Data::Dumper;

        our $foo = 1;
        our $bar = 2;
        {
                my $foo = 3;
                print "my masks our\n", dumper(\$foo, \$bar, \$");
        }
        print "now both are our\n", dumper(\$foo, \$bar, \$");

        sub dumper {
                my $package = peek_our(1);
                my $lexical = peek_my(1);
                my %p

    • This works for vars.pm and $Fully::Qualified::Variables too?

      • Yes, but only if they have had a value assigned to them. Otherwise they aren't really variables yet (just compiler directives to not throw errors if it sees them).

        • Well, it handles $main::foo, but not $other::package::foo. You would need to look in %other::package for it. Hmm, there should be some way of finding out what namespaces exist.

          • Alright, it is ugly, but it gets the job done. This handles everything but var pragma variables that have never been assigned to (they don't really exist yet). This version also has the benefit of displaying package and lexical variables differently, so you can easily spot the masking effect. Hmm, but I think there might be a bug in the case where you have

            {
                    our $foo;
                    {
                            my $foo;
               

            • I take it back, since he is using the address of the variable as the key it works fine, and there is the order doesn't matter when you build the hash.