Perl Packages

Perl provides a mechanism for alternate namespaces to protect packages from stomping on each others variables. By default, a perl script starts compiling into the package known as `main'. By use of the package declaration, you can switch namespaces. The scope of the package declaration is from the declaration itself to the end of the enclosing block (the same scope as the local() operator). Typically it would be the first declaration in a file to be included by the require operator. You can switch into a package in more than one place; it merely influences which symbol table is used by the compiler for the rest of that block. You can refer to variables and filehandles in other packages by prefixing the identifier with the package name and a single quote. If the package name is null, the `main' package as assumed.

Only identifiers starting with letters are stored in the packages symbol table. All other symbols are kept in package `main'. In addition, the identifiers `STDIN', `STDOUT', `STDERR', `ARGV', `ARGVOUT', `ENV', `INC' and `SIG' are forced to be in package `main', even when used for other purposes than their built-in one. Note also that, if you have a package called `m', `s' or `y', the you can't use the qualified form of an identifier since it will be interpreted instead as a pattern match, a substitution or a translation.

eval'ed strings are compiled in the package in which the eval was compiled in. (Assignments to `$SIG{}', however, assume the signal handler specified is in the `main' package. Qualify the signal handler name if you wish to have a signal handler in a package.) For an example, examine `perldb.pl' in the perl library. It initially switches to the `DB' package so that the debugger doesn't interfere with variables in the script you are trying to debug. At various points, however, it temporarily switches back to the `main' package to evaluate various expressions in the context of the `main' package.

The symbol table for a package happens to be stored in the associative array of that name prepended with an underscore. The value in each entry of the associative array is what you are referring to when you use the `*name' notation. In fact, the following have the same effect (in package `main', anyway), though the first is more efficient because it does the symbol table lookups at compile time:

local(*foo) = *bar;
local($_main{'foo'}) = $_main{'bar'};

You can use this to print out all the variables in a package, for instance. Here is `dumpvar.pl' from the perl library:

package dumpvar;

sub main'dumpvar {
($package) = @_;
local(*stab) = eval("*_$package");
while (($key,$val) = each(%stab)) {
{
local(*entry) = $val;
if (defined $entry) {
print "\$$key = '$entry'\n";
}
if (defined @entry) {
print "\@$key = (\n";
foreach $num ($[ .. $#entry) {
print " $num\t'",$entry[$num],"'\n";
}
print ")\n";
}
if ($key ne "_$package" && defined %entry) {
print "\%$key = (\n";
foreach $key (sort keys(%entry)) {
print " $key\t'",$entry{$key},"'\n";
}
print ")\n";
}
}
}
}

Note that, even though the subroutine is compiled in package `dumpvar', the name of the subroutine is qualified so that its name is inserted into package `main'.