Chapter 8. Symbol Tables and Typeglobs

No matter which part of my program I am in, or which package I am in, I can always get to the package variables as long as I preface the variable name with the full package name. Going back to my lexical(), I can see the package version of the variable even when that name is masked by a lexical variable of the same name. I just have to add the full package name to it, $main::global.

sub lexical {
    my $global = "I'm in the lexical version";
    print "In lexical(), \$global is --> $global\n";
    print "The package version is still --> $main::global\n";
    show_me('From lexical()');
    }

The output shows that I have access to both:

In lexical, $global is  --> I'm the lexical version
The package version is still --> I'm the global version

That’s not the only thing I can do, however. If, for some odd reason, I have a package variable with the same name as a lexical variable that’s currently in scope, I can use our (introduced in Perl 5.6) to tell Perl to use the package variable for the rest of the scope:

sub lexical {
    my $global = "I'm in the lexical version";
    our $global;
    print "In lexical with our, \$global is --> $global\n";
    show_me('In lexical()');
    }

Now the output shows that I don’t ever get to see the lexical version of the variable:

In lexical with our, $global is  --> I'm the global version

It seems pretty silly to use our that way since it masks the lexical version for the rest of the subroutine. If I only need the package version for part of the subroutine, I can create a scope just for it so I can use it for that part and let the lexical version take the rest:

sub lexical {
    my $global = "I'm in the lexical version";

    {
    our $global;
    print "In the naked block, our \$global is --> $global\n";
    }

    print "In lexical, my \$global is --> $global\n";
    print "The package version is still --> $main::global\n";
    show_me('In lexical()');
    }

Now the output shows all of the possible ways I can use $global:

In the naked block, our $global is --> I'm the global version
In lexical, my $global is  --> I'm the lexical version
The package version is still --> I'm the global version

By default, Perl variables are global variables, meaning that I can access them from anywhere in the program as long as I know their names. Perl keeps track of them in the symbol table, which is available to the entire program. Each package has a list of defined identifiers just like I showed in the previous section. Each identifier has a pointer (although not in the C sense) to a slot for each variable type. There are also two bonus slots for the variables NAME and PACKAGE, which I’ll use in a moment. Figure 1 shows the relationship between the package, identifier, and type of variable.

 Package    Identifier           Type    Thingy

                       +------> SCALAR - $bar
                       |
                       +------> ARRAY  - @bar
                       |
                       +------> HASH   - %bar
                       |
Foo:: -----> bar  -----+------> CODE   - &bar
                       |
                       +------> IO     - file and dir handle
                       |
                       +------> GLOB   - *bar
                       |
                       +------> FORMAT - format names
                       |
                       +------> NAME
                       |
                       +------> PACKAGE

There are seven variable types. The three common ones are the SCALAR, ARRAY, and HASH, but Perl also has CODE for subroutines (Chapter 9 covers subroutines as data), IO for file and directory handles, and GLOB for the whole thing. Once I have the glob I can get a reference to a particular variable of that name by accessing the right entry. To access the scalar portion of the *bar typeglob, I access that part almost like a hash access. These return references to data for those slots:

#!/usr/bin/perl
# make_aliases.pl
use v5.10;

$bar = 'Buster';
@bar = qw(Mimi Roscoe);

# these return references or undef
$foo = *bar{SCALAR};
$baz = *bar{ARRAY};

say "\$foo is $$foo";
say "\@baz is @$baz";

If I try to use a slot for a variable I haven’t used yet, I get undef:

#!/usr/bin/perl
# make_aliases_no_hash.pl
use v5.10;

$bar = 'Buster';
@bar = qw(Mimi Roscoe);

$quux = *bar{HASH};  # returns

say '$quux is undefined!' unless defined $quux;

I see that $quux is undefined:

% perl make_aliases_no_hash.pl
$quux is undefined!

Curiously, this doesn’t work if I access the SCALAR slot, which returns an anonymous scalar reference even if the variable has never been used:

#!/usr/bin/perl
# make_aliases_no_scalar.pl
use v5.10;

$foo = *bar{SCALAR};

say '$foo is a reference' if ref $foo;
say '$foo is undefined!' unless defined $foo;
say '$$foo is undefined!' unless defined $$foo;

The $foo value is always defined, but it’s a reference to undef:

% perl make_aliases_no_scalar.pl
$foo is a reference
$$foo is undefined!

For everything but a scalar variable, this gives me a way to check if a package variable has been used somewhere already. I can do it this way, but later I’ll show Package::Stash:

#!/usr/bin/perl
# show_used_var_types.pl
use v5.10;

foreach my $entry ( sort keys %main:: ) {
    say $entry;

    say "\tarray  is defined" if *{$entry}{ARRAY};
    say "\thash   is defined" if *{$entry}{HASH};
    say "\tsub    is defined" if *{$entry}{CODE};
    }

Although I can use the stashes in rvalues, I can’t use them as lvalues:

*bar{SCALAR} = 5;

I’ll get a fatal error:

Can't modify glob elem in scalar assignment ...

I can assign to a typeglob as a whole, though, and Perl will figure out the right place to put the value. I’ll show that later in the “Aliasing” section in this chapter.

I also get two bonus entries in the typeglob, PACKAGE and NAME, so I can always tell from which variable I got the typeglob. These also return strings, but I don’t think this is terribly useful for anything other than deep magic:

#!/usr/bin/perl
# typeglob-name-package.pl
use v5.10;

$foo = "Some value";
$bar = "Another value";

who_am_i( *foo );
who_am_i( *bar );

sub who_am_i {
    local *glob = shift;

    say "I'm from package " . *glob{PACKAGE};
    say "My name is "       . *glob{NAME};
    }

Although this probably has limited usefulness, at least outside of any debugging, the output tells me more about the typeglobs I passed to the function:

I'm from package main
My name is foo
I'm from package main
My name is bar

I can alias variables by assigning one typeglob to another. In this example, all of the variables with the identifier bar become nicknames for all of the variables with the identifier foo once Perl assigns the *foo typeglob to the *bar typeglob:

#!/usr/bin/perl
# alias.pl
use v5.10;

$foo = "Foo scalar";
@foo = 1 .. 5;
sub foo { q(I'm a subroutine!) }
say "\$foo is <$foo>, \@foo is <@foo>";

*bar = *foo;  # typeglob assignment

say "\$bar is <$bar>, \@bar is <@bar>";
say 'Sub returns <', bar(), '>';

$bar = 'Bar scalar';
@bar = 6 .. 10;
say "\$foo is <$foo>, \@foo is <@foo>";

When I change either the variables named bar or foo, the other is changed too because they are actually the same thing with different names. Notice the values for *foo change although I had changed values through *bar:

% perl alias.pl
$foo is <Foo scalar>, @foo is <1 2 3 4 5>
$bar is <Foo scalar>, @bar is <1 2 3 4 5>
Sub returns <I'm a subroutine!>
$foo is <Bar scalar>, @foo is <6 7 8 9 10>

I don’t have to assign an entire typeglob. If I assign a reference to a typeglob, I only affect that part of the typeglob that the reference represents. Assigning the scalar reference \$scalar to the typeglob *foo only affects the SCALAR part of the typeglob. In the next line, when I assign a \@array to the typeglob, the array reference only affects the ARRAY part of the typeglob. Having done that, I’ve made *foo a Frankenstein’s monster of values I’ve taken from other variables:

#!/usr/bin/perl
# frankenstein.pl
use strict;
use v5.10;

my $scalar = 'foo';
my @array  = 1 .. 5;

*foo = \$scalar;
*foo = \@array;

{
no strict 'vars';  # or declare them
say "\$foo is $foo";
say "\@foo is @foo";
}

% perl frankenstein.pl
$foo is foo
@foo is 1 2 3 4 5

Notice that strict doesn’t complain about *foo. It will complain about $foo and @foo though. If you have to do this sort of thing, you might want to pre-declare variables instead:

#!/usr/bin/perl
use v5.10;
use strict;
use vars qw($foo @foo);

my $scalar = 'foo';
my @array  = 1 .. 5;

*foo = \$scalar;
*foo = \@array;

say "\$foo is $foo";
say "\@foo is @foo";

This feature can be quite useful when I have a long variable name but I want to use a different name for it. This is essentially what the Exporter module does when it imports symbols into my namespace (and this doesn’t have the strict problem either). Instead of using the full package specification, I have it in my current package. Exporter takes the variables from the exporting package and assigns to the typeglob of the importing package:

package Exporter;

sub import {
    my $pkg = shift;
    my $callpkg = caller($ExportLevel);

    # ...
    *{"$callpkg\::$_"} = \&{"$pkg\::$_"} foreach @_;
    }

Before Perl 5.6 introduced filehandle references, if I had to pass a subroutine a filehandle I’d have to use a typeglob. This is the most likely use of typeglobs that you’ll see in older code. For instance, the CGI module can read its input from a filehandle I specify, rather than using STDIN:

use CGI;

open FH, $cgi_data_file
    or die "Could not open $cgi_data_file: $!";

CGI->new( *FH ); # can't new( FH ), need a typeglob

This also works with references to typeglobs:

CGI->new( \*FH ); # can't new( FH ), need a typeglob

Again, this is the older way of doing things. The newer way involves a scalar that holds the filehandle reference:

use CGI;
open my $fh, '<', $cgi_data_file
    or die "Could not open $cgi_data_file: $!";
CGI->new( $fh );

In the old method, the filehandles were package variables so they couldn’t be lexical variables. And, they have no sigil. Passing them to a subroutine, however, was a problem. What name do I use for them in the subroutine? I don’t want to use another name already in use because I’ll overwrite its value. I can’t use local with a filehandle either.

local( FH ) = shift; # won't work.

That line of code gives a compilation error:

Can't modify constant item in local ...

I have to use a typeglob instead. Perl figures out to assign the GLOB and IO portions of the FH typeglob:

local( *FH ) = shift; # will work.

Once I’ve done that, I use the filehandle FH just like I would in any other situation. It doesn’t matter to me that I got it through a typeglob assignment. Since I’ve localized it, any filehandle of that name anywhere in the program uses my new value, just as in my earlier local example. Nowadays, just use filehandle references, $fh, and leave this stuff to the older code (unless I’m dealing with the special filehandles STDOUT, STDERR, and STDIN).

Using typeglob assignment I can give anonymous subroutines a name. Instead of dealing with a subroutine dereference I can deal with a named subroutine.

The File::Find module takes a callback function to select files from a list of directories:

use File::Find;

find( \&wanted, @dirs );

sub wanted { ... }

In File::Find::Closures, I have several functions that return two closures I can use with File::Find. That way, I can run common find tasks without recreating the &wanted function I need:

package File::Find::Closures;

sub find_by_name {
    my %hash  = map { $_, 1 } @_;
    my @files = ();

    (
    sub { push @files, canonpath( $File::Find::name )
        if exists $hash{$_} },
    sub { wantarray ? @files : [ @files ] }
    )
    }

I use File::Find::Closures by importing the generator function I want to use, in this case find_by_name, and then use that function to create two anonymous subroutines: one for find and one to use afterward to get the results:

use File::Find;
use File::Find::Closures qw( find_by_name );

my( $wanted, $get_file_list ) = find_by_name( 'index.html' );

find( $wanted, @directories );

foreach my file ( $get_file_list->() ) {
    ...
    }

Perhaps I don’t want to use subroutine references, for whatever reasons. I can assign the anonymous subroutines to typeglobs. Since I’m assigning references, I only affect subroutine entry in the typeglob. After the assignment I can then do the same thing I did with filehandles in the last section, but this time with named subroutines. After I assign the return values from find_by_name to the typeglobs *wanted and *get_file_list, I have subroutines with those names:

( *wanted, *get_file_list ) = find_by_name( 'index.html' );

find( \&wanted, @directories );

foreach my file ( get_file_list() ) {
    ...
    }

This is a contrived example since I could be much more clear by using subroutine references that I assign to scalar variables. If I absolutely need to use a subroutine named &wanted because there’s another bit of code I’m not allowed to change, this sort of thing could work. In Chapter 9 I’ll use this trick with AUTOLOAD to define subroutines on the fly or to replace existing subroutine definitions.