package Exporter;
-require 5.001;
+require 5.006;
-use strict;
-no strict 'refs';
+# Be lean.
+#use strict;
+#no strict 'refs';
our $Debug = 0;
our $ExportLevel = 0;
our $Verbose ||= 0;
-our $VERSION = '5.564';
+our $VERSION = '5.566';
$Carp::Internal{Exporter} = 1;
-sub export_to_level {
+sub as_heavy {
require Exporter::Heavy;
- goto &Exporter::Heavy::heavy_export_to_level;
+ # Unfortunately, this does not work if the caller is aliased as *name = \&foo
+ # Thus the need to create a lot of identical subroutines
+ my $c = (caller(1))[3];
+ $c =~ s/.*:://;
+ \&{"Exporter::Heavy::heavy_$c"};
}
sub export {
- require Exporter::Heavy;
- goto &Exporter::Heavy::heavy_export;
-}
-
-sub export_tags {
- require Exporter::Heavy;
- Exporter::Heavy::_push_tags((caller)[0], "EXPORT", \@_);
-}
-
-sub export_ok_tags {
- require Exporter::Heavy;
- Exporter::Heavy::_push_tags((caller)[0], "EXPORT_OK", \@_);
+ goto &{as_heavy()};
}
sub import {
my $pkg = shift;
my $callpkg = caller($ExportLevel);
- my($exports, $export_cache) = (\@{"$pkg\::EXPORT"},
- \%{"$pkg\::EXPORT"});
# We *need* to treat @{"$pkg\::EXPORT_FAIL"} since Carp uses it :-(
- my($fail) = \@{"$pkg\::EXPORT_FAIL"};
+ my($exports, $export_cache, $fail)
+ = (\@{"$pkg\::EXPORT"}, \%{"$pkg\::EXPORT"}, \@{"$pkg\::EXPORT_FAIL"});
return export $pkg, $callpkg, @_
if $Verbose or $Debug or @$fail > 1;
my $args = @_ or @_ = @$exports;
-
+
+ local $_;
if ($args and not %$export_cache) {
- foreach my $sym (@$exports, @{"$pkg\::EXPORT_OK"}) {
- $sym =~ s/^&//;
- $export_cache->{$sym} = 1;
- }
+ s/^&//, $export_cache->{$_} = 1
+ foreach (@$exports, @{"$pkg\::EXPORT_OK"});
}
- if ($Verbose or $Debug
- or grep {/\W/ or $args and not exists $export_cache->{$_}
- or @$fail and $_ eq $fail->[0]
- or (@{"$pkg\::EXPORT_OK"}
- and $_ eq ${"$pkg\::EXPORT_OK"}[0])} @_) {
- return export $pkg, $callpkg, ($args ? @_ : ());
+ my $heavy;
+ # Try very hard not to use {} and hence have to enter scope on the foreach
+ # We bomb out of the loop with last as soon as heavy is set.
+ if ($args or $fail) {
+ ($heavy = (/\W/ or $args and not exists $export_cache->{$_}
+ or @$fail and $_ eq $fail->[0])) and last
+ foreach (@_);
+ } else {
+ ($heavy = /\W/) and last
+ foreach (@_);
}
+ return export $pkg, $callpkg, ($args ? @_ : ()) if $heavy;
local $SIG{__WARN__} =
sub {require Carp; &Carp::carp};
- foreach my $sym (@_) {
- # shortcut for the common case of no type character
- *{"$callpkg\::$sym"} = \&{"$pkg\::$sym"};
- }
+ # shortcut for the common case of no type character
+ *{"$callpkg\::$_"} = \&{"$pkg\::$_"} foreach @_;
}
-
# Default methods
sub export_fail {
@_;
}
+# Unfortunately, caller(1)[3] "does not work" if the caller is aliased as
+# *name = \&foo. Thus the need to create a lot of identical subroutines
+# Otherwise we could have aliased them to export().
-sub require_version {
- require Exporter::Heavy;
- goto &Exporter::Heavy::require_version;
+sub export_to_level {
+ goto &{as_heavy()};
}
+sub export_tags {
+ goto &{as_heavy()};
+}
-1;
+sub export_ok_tags {
+ goto &{as_heavy()};
+}
+sub require_version {
+ goto &{as_heavy()};
+}
+
+1;
+__END__
=head1 NAME
=head1 SYNOPSIS
-In module ModuleName.pm:
+In module YourModule.pm:
- package ModuleName;
+ package YourModule;
require Exporter;
@ISA = qw(Exporter);
+ @EXPORT_OK = qw(munge frobnicate); # symbols to export on request
- @EXPORT = qw(...); # symbols to export by default
- @EXPORT_OK = qw(...); # symbols to export on request
- %EXPORT_TAGS = tag => [...]; # define names for sets of symbols
-
-In other files which wish to use ModuleName:
-
- use ModuleName; # import default symbols into my package
-
- use ModuleName qw(...); # import listed symbols into my package
+In other files which wish to use YourModule:
- use ModuleName (); # do not import any symbols
+ use ModuleName qw(frobnicate); # import listed symbols
+ frobnicate ($left, $right) # calls YourModule::frobnicate
=head1 DESCRIPTION
-The Exporter module implements a default C<import> method which
-many modules choose to inherit rather than implement their own.
+The Exporter module implements an C<import> method which allows a module
+to export functions and variables to its users' namespaces. Many modules
+use Exporter rather than implementing their own C<import> method because
+Exporter provides a highly flexible interface, with an implementation optimised
+for the common case.
Perl automatically calls the C<import> method when processing a
C<use> statement for a module. Modules and C<use> are documented
@EXPORT = qw(afunc $scalar @array); # afunc is a function
@EXPORT_OK = qw(&bfunc %hash *typeglob); # explicit prefix on &bfunc
+If you are only exporting function names it is recommended to omit the
+ampersand, as the implementation is faster this way.
+
=head2 Selecting What To Export
Do B<not> export method names!
(It is actually possible to get private functions by saying:
my $subref = sub { ... };
- &$subref;
+ $subref->(@args); # Call it as a function
+ $obj->$subref(@args); # Use it as a method
-But there's no way to call that directly as a method, since a method
-must have a name in the symbol table.)
+However if you use them for methods it is up to you to figure out
+how to make inheritance work.)
As a general rule, if the module is trying to be object oriented
then export nothing. If it's just a collection of functions then
-@EXPORT_OK anything but use @EXPORT with caution.
+@EXPORT_OK anything but use @EXPORT with caution. For function and
+method names use barewords in preference to names prefixed with
+ampersands for the export lists.
Other module design guidelines can be found in L<perlmod>.
+=head2 How to Import
+
+In other files which wish to use your module there are three basic ways for
+them to load your module and import its symbols:
+
+=over 4
+
+=item C<use ModuleName;>
+
+This imports all the symbols from ModuleName's @EXPORT into the namespace
+of the C<use> statement.
+
+=item C<use ModuleName ();>
+
+This causes perl to load your module but does not import any symbols.
+
+=item C<use ModuleName qw(...);>
+
+This imports only the symbols listed by the caller into their namespace.
+All listed symbols must be in your @EXPORT or @EXPORT_OK, else an error
+occurs. The advanced export features of Exporter are accessed like this,
+but with list entries that are syntactically distinct from symbol names.
+
+=back
+
+Unless you want to use its advanced features, this is probably all you
+need to know to use Exporter.
+
+=head1 Advanced features
+
=head2 Specialised Import Lists
If the first entry in an import list begins with !, : or / then the
specifications are being processed and what is actually being imported
into modules.
-=head2 Exporting without using Export's import method
+=head2 Exporting without using Exporter's import method
Exporter has a special method, 'export_to_level' which is used in situations
-where you can't directly call Export's import method. The export_to_level
+where you can't directly call Exporter's import method. The export_to_level
method looks like:
MyPackage->export_to_level($where_to_export, $package, @what_to_export);
names being silently added to @EXPORT or @EXPORT_OK. Future versions
may make this a fatal error.
+=head2 Generating combined tags
+
+If several symbol categories exist in %EXPORT_TAGS, it's usually
+useful to create the utility ":all" to simplify "use" statements.
+
+The simplest way to do this is:
+
+ %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]);
+
+ # add all the other ":class" tags to the ":all" class,
+ # deleting duplicates
+ {
+ my %seen;
+
+ push @{$EXPORT_TAGS{all}},
+ grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} foreach keys %EXPORT_TAGS;
+ }
+
+CGI.pm creates an ":all" tag which contains some (but not really
+all) of its categories. That could be done with one small
+change:
+
+ # add some of the other ":class" tags to the ":all" class,
+ # deleting duplicates
+ {
+ my %seen;
+
+ push @{$EXPORT_TAGS{all}},
+ grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}}
+ foreach qw/html2 html3 netscape form cgi internal/;
+ }
+
+Note that the tag names in %EXPORT_TAGS don't have the leading ':'.
+
=head2 C<AUTOLOAD>ed Constants
Many modules make use of C<AUTOLOAD>ing for constant subroutines to
https://perl5.git.perl.org / perl5.git / blobdiff