(The old package delimiter was a single quote, but double colon is now the preferred delimiter, in part because it's more readable to humans, and in part because it's more readable to emacs macros. It also makes C++ programmers feel like they know what's going on.)
Packages may be nested inside other packages: $OUTER::INNER::var. This implies nothing about the order of name lookups, however. All symbols are either local to the current package, or must be fully qualified from the outer package name down. For instance, there is nowhere within package OUTER that $INNER::var refers to $OUTER::INNER::var. It would treat package INNER as a totally separate global package.
Only identifiers starting with letters (or underscore) are stored in a package's 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, then 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.
(Variables beginning with underscore used to be forced into package main, but we decided it was more useful for package writers to be able to use leading underscore to indicate private variables and method names.)
Eval'ed strings are compiled in the package in which the eval was compiled. (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 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, though the first is more efficient because it does the symbol table lookups at compile time:
local(*main::foo) = *main::bar; local($main::{'foo'}) =
$main::{'bar'};
You can use this to print out all the variables in a package, for
instance. Here is F
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.
Assignment to a symbol table entry performs an aliasing operation, i.e.,
*dick = *richard;
causes variables, subroutines and filehandles accessible via the
identifier richard to also be accessible via the symbol dick. If
you only want to alias a particular variable or subroutine, you can
assign a reference instead:
*dick = \$richard;
makes $richard and $dick the same variable, but leaves
@richard and @dick as separate arrays. Tricky, eh?
A BEGIN subroutine is executed as soon as possible, that is, the moment it is completely defined, even before the rest of the containing file is parsed. You may have multiple BEGIN blocks within a file--they will be executed in order of definition. Because a BEGIN block executes immediately, it can pull in definitions of subroutines and such from other files in time to be visible to the rest of the file.
An END subroutine is executed as late as possible, that is, when the interpreter is being exited, even if it is exiting as a result of a die() function. (But not if it's is being blown out of the water by a signal--you have to trap that yourself (if you can).) You may have multiple END blocks within a file--they will be executed in reverse order of definition, that is, last in, first out.
Note that when you use the -n and -p switches to perl, BEGIN and END work just as they do in awk, as a degenerate case.
Perl modules are included by saying
use Module;
or
use Module LIST;
This is exactly equivalent to
BEGIN { require "Module.pm"; import Module; }
or
BEGIN { require "Module.pm"; import Module LIST; }
All Perl module files have the extension F<.pm>.
use
assumes this so
that you don't have to spell out "FPerl packages may be nested inside other package names, so we can have
package names containing ::. But if we used that package name
directly as a filename it would makes for unwieldy or impossible
filenames on some systems. Therefore, if a module's name is, say,
Text::Soundex, then its definition is actually found in the library
file F For more information on writing extension modules, see
the perlapi manpage
and
the perlguts manpage
.
The module and its user have a contract, part of which is common law,
and part of which is "written". Part of the common law contract is
that a module doesn't pollute any namespace it wasn't asked to. The
written contract for the module (AKA documentation) may make other
provisions. But then you know when you use RedefineTheWorld that
you're redefining the world, and are willing to take the consequences.
SYNOPSIS
SYNOPSIS
Here's a partial table of features the different packages offer:
SYNOPSIS
This function will split up your program into files that the AutoLoader
module can handle. Normally only used to build autoloading Perl library
modules, especially extensions (like POSIX). You should look at how
they're built out for details.
This module contains routines to test for the reachability of remote hosts.
Currently the only routine implemented is pingecho.
pingecho uses a TCP echo (not an ICMP one) to determine if the
remote host is reachable. This is usually adaquate to tell that a remote
host is available to rsh(1), ftp(1), or telnet(1) onto.
Parameters
NOTE
Perl does not enforce private and public parts of its modules as you may
have been used to in other languages like C++, Ada, or Modula-17. Perl's
author doesn't have an infatuation with enforced privacy. He would prefer
that you stay out of my living room because you weren't invited, not
because he has a shotgun.
THE PERL MODULE LIBRARY
Pragmatic Modules
There work somewhat like pragmas in that they tend to affect the compilation of
your program, and thus will usually only work well when used within a
use
, or
no
. These are locally scoped, so if an inner BLOCK
may countermand any of these by saying
no integer;
no strict 'refs';
which lasts until the end of that BLOCK.
use integer;
This tells the compiler that it's okay to use integer operations
from here to the end of the enclosing BLOCK. On many machines,
this doesn't matter a great deal for most computations, but on those
without floating point hardware, it can make a big difference.
use less LIST;
Currently unimplemented, this may someday be a compiler directive
to make certain trade-off, such as perhaps
use less 'memory';
use less 'CPU';
use less 'fat';
use strict
Current there are three possible things to be strict about:
"subs", "vars", or "refs". If no LIST is supplied,
all possible restrictions are assumed. (This the
safest mode to operate in, but is sometimes too strict
for casual programming.)
Standard Modules
use Abbrev;
abbrev *HASH, LIST
Example:
abbrev(*hash,qw("list edit send abort gripe"));
Stores all unambiguous truncations of each element of LIST
as keys key in the associative array indicated by *hash.
The values are the original list elements.
use AnyDBM_File;
This module is a "pure virtual base class"--it has nothing of us its own.
It's just there to inherit from one of the various DBM packages. It
prefers ndbm for compatibility reasons with Perl 4, then Berkeley DB (See
the DB_File manpage
), GDBM, SDBM (which is always there -- it comes with Perl), and
finally ODBM. This way old programs that used to use NDBM via dbmopen() can still
do so, but new ones can reorder @ISA:
@AnyDBM_File::ISA = qw(DB_File GDBM_File NDBM_File);
This makes it trivial to copy database formats:
use POSIX; use NDBM_File; use DB_File;
tie %newhash, DB_File, $new_filename, O_CREAT|O_RDWR;
tie %oldhash, NDBM_File, $old_filename, 1, 0;
%newhash = %oldhash;
DBM Comparison Table:
odbm ndbm sdbm gdbm bsd-db
---- ---- ---- ---- ------
Linkage comes w/ perl yes yes yes yes yes
Src comes w/ perl no no yes no no
Comes w/ many unix os yes yes[0] no no no
Builds ok on !unix ? ? yes yes ?
Code Size ? ? small big big
Database Size ? ? small big? ok[1]
Speed ? ? slow ok fast
FTPable no no yes yes yes
Easy to build N/A N/A yes yes ok[2]
Size limits 1k 4k 1k[3] none none
Byte-order independent no no no no yes
Licensing restrictions ? ? no yes no
package FOOBAR;
use Exporter;
use AutoLoader;
@ISA = (Exporter, AutoLoader);
This tells its users that functions in the FOOBAR package are to be
autoloaded from F
pingecho hostname [, timeout] ;
Example:
use Ping ;
print "'jimmy' is alive and kicking\n" if pingecho('jimmy', 10) ;
DESCRIPTION
Note: pingecho uses alarm to implement the timeout, so don't set another alarm
while you are using it.
Extension Modules