MAN page from Old RedHat 5.X perl-5.004-4.i386.rpm

PERLMOD

Section: Perl Programmers Reference Guide (1)
Updated: perl 5.004, patch 04
Index

NAME

perlmod - Perl modules (packages and symbol tables)

DESCRIPTION

Packages

Perl provides a mechanism for alternative namespaces to protect packagesfrom stomping on each other's variables. In fact, apart from certainmagical variables, there's really no such thing as a global variablein Perl. The package statement declares the compilation unit asbeing in the given namespace. The scope of the package declarationis from the declaration itself through the end of the enclosing block,eval, sub, or end of file, whichever comes first (the same scopeas the my() and local() operators). All further unqualified dynamicidentifiers will be in this namespace. A package statement affectsonly dynamic variables---including those you've used local() on---butnot lexical variables created with my(). Typically it would bethe first declaration in a file to be included by the require oruse operator. You can switch into a package in more than one place;it influences merely which symbol table is used by the compiler for therest of that block. You can refer to variables and filehandles in otherpackages by prefixing the identifier with the package name and a doublecolon: $Package::Variable. If the package name is null, the mainpackage is assumed. That is, $::sail is equivalent to $main::sail.

(The old package delimiter was a single quote, but double colonis now the preferred delimiter, in part because it's more readableto 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. Thisimplies nothing about the order of name lookups, however. All symbolsare either local to the current package, or must be fully qualifiedfrom the outer package name down. For instance, there is nowherewithin 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 apackage's symbol table. All other symbols are kept in package main,including all of the punctuation variables like $_. In addition, theidentifiers STDIN, STDOUT, STDERR, ARGV, ARGVOUT, ENV, INC, and SIG areforced to be in package main, even when used for other purposes thantheir builtin one. Note also that, if you have a package called m,s, or y, then you can't use the qualified form of an identifierbecause it will be interpreted instead as a pattern match, a substitution,or a translation.

(Variables beginning with underscore used to be forced into packagemain, but we decided it was more useful for package writers to be ableto use leading underscore to indicate private variables and method names.$_ is still global though.)

Eval()ed strings are compiled in the package in which the eval() wascompiled. (Assignments to $SIG{}, however, assume the signalhandler specified is in the main package. Qualify the signal handlername if you wish to have a signal handler in a package.) For anexample, examine perldb.pl in the Perl library. It initially switchesto the DB package so that the debugger doesn't interfere with variablesin the script you are trying to debug. At various points, however, ittemporarily switches back to the main package to evaluate variousexpressions in the context of the main package (or wherever you camefrom). See the perldebug manpage.

The special symbol __PACKAGE__ contains the current package, but cannot(easily) be used to construct variables.

See the perlsub manpage for other scoping issues related to my() and local(),and the perlref manpage regarding closures.

Symbol Tables

The symbol table for a package happens to be stored in the hash of thatname with two colons appended. The main symbol table's name is thus%main::, or %:: for short. Likewise symbol table for the nestedpackage mentioned earlier is named %OUTER::INNER::.

The value in each entry of the hash is what you are referring to when youuse the *name typeglob notation. In fact, the following have the sameeffect, though the first is more efficient because it does the symboltable 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, forinstance. 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 intopackage main. While popular many years ago, this is now consideredvery poor style; in general, you should be writing modules and using thenormal export mechanism instead of hammering someone else's namespace,even main's.

Assignment to a typeglob performs an aliasing operation, i.e.,

    *dick = *richard;

causes variables, subroutines, and file handles accessible via theidentifier richard to also be accessible via the identifier dick. Ifyou want to alias only a particular variable or subroutine, you canassign a reference instead:

    *dick = \$richard;

makes $richard and $dick the same variable, but leaves@richard and @dick as separate arrays. Tricky, eh?

This mechanism may be used to pass and return cheap referencesinto or from subroutines if you won't want to copy the wholething.

    %some_hash = ();    *some_hash = fn( \%another_hash );    sub fn {        local *hashsym = shift;        # now use %hashsym normally, and you        # will affect the caller's %another_hash        my %nhash = (); # do what you want        return \%nhash;    }

On return, the reference will overwrite the hash slot in thesymbol table specified by the *some_hash typeglob. Thisis a somewhat tricky way of passing around references cheaplywhen you won't want to have to remember to dereference variablesexplicitly.

Another use of symbol tables is for making ``constant'' scalars.

    *PI = \3.14159265358979;

Now you cannot alter $PI, which is probably a good thing all in all.This isn't the same as a constant subroutine (one prototyped to take no arguments and to return a constant expression), which issubject to optimization at compile-time. This isn't. See the perlsub manpagefor details on these.

You can say *foo{PACKAGE} and *foo{NAME} to find out what name andpackage the *foo symbol table entry comes from. This may be usefulin a subroutine which is passed typeglobs as arguments

    sub identify_typeglob {        my $glob = shift;        print 'You gave me ', *{$glob}{PACKAGE}, '::', *{$glob}{NAME}, "\n";    }    identify_typeglob *foo;    identify_typeglob *bar::baz;

This prints

    You gave me main::foo    You gave me bar::baz

The *foo{THING} notation can also be used to obtain references to theindividual elements of *foo, see the perlref manpage.

Package Constructors and Destructors

There are two special subroutine definitions that function as packageconstructors and destructors. These are the BEGIN and ENDroutines. The sub is optional for these routines.

A BEGIN subroutine is executed as soon as possible, that is, the momentit is completely defined, even before the rest of the containing fileis parsed. You may have multiple BEGIN blocks within a file---theywill execute in order of definition. Because a BEGIN block executesimmediately, it can pull in definitions of subroutines and such from otherfiles in time to be visible to the rest of the file. Once a BEGINhas run, it is immediately undefined and any code it used is returned toPerl's memory pool. This means you can't ever explicitly call a BEGIN.

An END subroutine is executed as late as possible, that is, when theinterpreter is being exited, even if it is exiting as a result of adie() function. (But not if it's is being blown out of the water by asignal---you have to trap that yourself (if you can).) You may havemultiple END blocks within a file---they will execute in reverseorder of definition; that is: last in, first out (LIFO).

Inside an END subroutine $? contains the value that the script isgoing to pass to exit(). You can modify $? to change the exitvalue of the script. Beware of changing $? by accident (e.g. byrunning something via system).

Note that when you use the -n and -p switches to Perl, BEGINand END work just as they do in awk, as a degenerate case.

Perl Classes

There is no special class syntax in Perl, but a package may functionas a class if it provides subroutines that function as methods. Such apackage may also derive some of its methods from another class packageby listing the other package name in its @ISA array.

For more on this, see the perltoot manpage and the perlobj manpage.

Perl Modules

A module is just a package that is defined in a library file ofthe same name, and is designed to be reusable. It may do this byproviding a mechanism for exporting some of its symbols into the symboltable of any package using it. Or it may function as a classdefinition and make its semantics available implicitly through methodcalls on the class and its objects, without explicit exportation of anysymbols. Or it can do a little of both.

For example, to start a normal module called Some::Module, createa file called Some/Module.pm and start with this template:

    package Some::Module;  # assumes Some/Module.pm

    use strict;

    BEGIN {        use Exporter   ();        use vars       qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);

        # set the version for version checking        $VERSION     = 1.00;        # if using RCS/CVS, this may be preferred        $VERSION = do { my @r = (q$Revision: 2.21 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker

        @ISA         = qw(Exporter);        @EXPORT      = qw(&func1 &func2 &func4);        %EXPORT_TAGS = ( );     # eg: TAG => [ qw!name1 name2! ],

        # your exported package globals go here,        # as well as any optionally exported functions        @EXPORT_OK   = qw($Var1 %Hashit &func3);    }    use vars      @EXPORT_OK;

    # non-exported package globals go here    use vars      qw(@more $stuff);

    # initalize package globals, first exported ones    $Var1   = '';    %Hashit = ();

    # then the others (which are still accessible as $Some::Module::stuff)    $stuff  = '';    @more   = ();

    # all file-scoped lexicals must be created before    # the functions below that use them.

    # file-private lexicals go here    my $priv_var    = '';    my %secret_hash = ();

    # here's a file-private function as a closure,    # callable as &$priv_func;  it cannot be prototyped.    my $priv_func = sub {        # stuff goes here.    };

    # make all your functions, whether exported or not;    # remember to put something interesting in the {} stubs    sub func1      {}    # no prototype    sub func2()    {}    # proto'd void    sub func3($$)  {}    # proto'd to 2 scalars

    # this one isn't exported, but could be called!    sub func4(\%)  {}    # proto'd to 1 hash ref

    END { }       # module clean-up code here (global destructor)

Then go on to declare and use your variables in functionswithout any qualifications.See the Exporter manpage and the the perlmodlib manpage for details onmechanics and style issues in module creation.

Perl modules are included into your program by saying

    use Module;

    use Module LIST;

This is exactly equivalent to

    BEGIN { require "Module.pm"; import Module; }

    BEGIN { require "Module.pm"; import Module LIST; }

As a special case

    use Module ();

is exactly equivalent to

    BEGIN { require "Module.pm"; }

All Perl module files have the extension .pm. use assumes this sothat you don't have to spell out ``Module.pm'' in quotes. This alsohelps to differentiate new modules from old .pl and .ph files.Module names are also capitalized unless they're functioning as pragmas,``Pragmas'' are in effect compiler directives, and are sometimes called``pragmatic modules'' (or even ``pragmata'' if you're a classicist).

Because the use statement implies a BEGIN block, the importationof semantics happens at the moment the use statement is compiled,before the rest of the file is compiled. This is how it is ableto function as a pragma mechanism, and also how modules are able todeclare subroutines that are then visible as list operators forthe rest of the current file. This will not work if you use requireinstead of use. With require you can get into this problem:

    require Cwd;                # make Cwd:: accessible    $here = Cwd::getcwd();

    use Cwd;                    # import names from Cwd::    $here = getcwd();

    require Cwd;                # make Cwd:: accessible    $here = getcwd();           # oops! no main::getcwd()

In general use Module (); is recommended over require Module;.

Perl packages may be nested inside other package names, so we can havepackage names containing ::. But if we used that package namedirectly as a filename it would makes for unwieldy or impossiblefilenames on some systems. Therefore, if a module's name is, say,Text::Soundex, then its definition is actually found in the libraryfile Text/Soundex.pm.

Perl modules always have a .pm file, but there may also be dynamicallylinked executables or autoloaded subroutine definitions associated withthe module. If so, these will be entirely transparent to the user ofthe module. It is the responsibility of the .pm file to load (orarrange to autoload) any additional functionality. The POSIX modulehappens to do both dynamic loading and autoloading, but the user cansay just use POSIX to get it all.

For more information on writing extension modules, see the perlxstut manpageand the perlguts manpage.

This document was created byman2html,using the manual pages.