Dave.

In the past, I've noticed that entries in the symbol table (%::) always have a SCALAR component. I guess every package symbol always has a scalar component due to how Perl's guts are written.

package main;

our %test = ( a => 1 );

print('SCALAR: ', (  *{ $::{'main::'}{'test'} }{SCALAR}  )?1:0, "\n");
print('ARRAY:  ', (  *{ $::{'main::'}{'test'} }{ARRAY }  )?1:0, "\n");
print('HASH:   ', (  *{ $::{'main::'}{'test'} }{HASH  }  )?1:0, "\n");

${  *{ $::{'main::'}{'test'} }{SCALAR}  } = 'scalar';
print("$test\n");

__END__
SCALAR: 1
ARRAY:  0
HASH:   1
scalar
[download]

Is this documented anywhere that you know of? Do you think this is worthy of being labeled a "bug" in Devel::Symdump (if so, I'll report it in RT)?

Thanks for confirming I'm not going crazy anyway! :-)

--Brian

Just a couple of notes as a I retrace my understanding of this behavior. Here's some relevant text from perlref, section "Making References":

*foo{THING} returns undef if that particular THING hasn’t been used yet, except in the case of scalars. *foo{SCALAR} returns a reference to an anonymous scalar if $foo hasn’t been used yet. This might change in a future release.

One consequence of this is that at the symbol-table level, the following two packages are indistinguishable:

{
    package Foo;
    our $x = undef;
    our @x = qw( alpha beta gamma );
}

{
    package Bar;
    our @x = qw( alpha beta gamma );
}
[download]

... which I may demonstrate with some code of my own, once I come up with something convincing that navigates the sea of casting and dereferencing that is the Perl symbol table. So while I think I appreciate what broquaint is trying to get across, I don't think the above post addresses the "spirit" of the OP. I would agree with the as-yet unmade statement that Devel::Symdump is doing its best, but the underlying data is ambiguous, and so are the values returned from the module.

Indeed, such is the nature of globs. Thanks, bpphillips, for starting this conversation.

Update: Here's a more concrete example, following the package definitions above:

Read more... (1496 Bytes)

Depending, of course, on what you ultimately want to do with this, you might want to look at Dumpvalue, which can dump the symbol tables of whole packages, or at another of the modules listed here.

For example,

package private;
our $my_scalar = 'my scalar';
our @my_array  = qw(my array);
our %my_hash   = ( my => 'hash' );

package main;
use strict;
use Devel::Symdump;
use Dumpvalue;

print "ARRAYS => "
    . join(q{, }, Devel::Symdump->arrays("private")),"\n";
print "SCALARS => "
    . join(q{, }, Devel::Symdump->scalars("private")),"\n";
print "HASHES => "
    . join(q{, }, Devel::Symdump->hashes("private")),"\n";

print "\nDumpvalue:\n";
Dumpvalue->new->dumpvars('private');
[download]

yields this output:

ARRAYS => private::my_array
SCALARS => private::my_scalar, private::my_array, private::my_hash
HASHES => private::my_hash

Dumpvalue:
@my_array = (
   0  'my'
   1  'array'
)
$my_scalar = 'my scalar'
%my_hash = (
   'my' => 'hash'
)
[download]

which lends itself to visual inspection.

Update: Added example.

HTH,