This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Bring Term::Cap to date
[perl5.git] / lib / Exporter.pm
CommitLineData
8990e307
LW
1package Exporter;
2
732bb7c2 3require 5.006;
8990e307 4
0e57b4e8
IZ
5# Be lean.
6#use strict;
7#no strict 'refs';
b75c8c73
MS
8
9our $Debug = 0;
10our $ExportLevel = 0;
11our $Verbose ||= 0;
a2e772d6 12our $VERSION = '5.60';
a6faae8d 13our (%Cache);
09e96b99
JC
14# Carp does this now for us, so we can finally live w/o Carp
15#$Carp::Internal{Exporter} = 1;
2b5b2650 16
0e57b4e8 17sub as_heavy {
4af1b167 18 require Exporter::Heavy;
0e57b4e8
IZ
19 # Unfortunately, this does not work if the caller is aliased as *name = \&foo
20 # Thus the need to create a lot of identical subroutines
21 my $c = (caller(1))[3];
22 $c =~ s/.*:://;
23 \&{"Exporter::Heavy::heavy_$c"};
84902520
TB
24}
25
4af1b167 26sub export {
0e57b4e8 27 goto &{as_heavy()};
a0d0e21e
LW
28}
29
4af1b167
IZ
30sub import {
31 my $pkg = shift;
32 my $callpkg = caller($ExportLevel);
b75c8c73 33
fe43f860
FD
34 if ($pkg eq "Exporter" and @_ and $_[0] eq "import") {
35 *{$callpkg."::import"} = \&import;
36 return;
37 }
38
4af1b167 39 # We *need* to treat @{"$pkg\::EXPORT_FAIL"} since Carp uses it :-(
a6faae8d 40 my($exports, $fail) = (\@{"$pkg\::EXPORT"}, \@{"$pkg\::EXPORT_FAIL"});
4af1b167 41 return export $pkg, $callpkg, @_
b75c8c73 42 if $Verbose or $Debug or @$fail > 1;
a6faae8d 43 my $export_cache = ($Cache{$pkg} ||= {});
b75c8c73 44 my $args = @_ or @_ = @$exports;
732bb7c2
NC
45
46 local $_;
b75c8c73 47 if ($args and not %$export_cache) {
732bb7c2
NC
48 s/^&//, $export_cache->{$_} = 1
49 foreach (@$exports, @{"$pkg\::EXPORT_OK"});
4af1b167 50 }
fa1bb02f
NC
51 my $heavy;
52 # Try very hard not to use {} and hence have to enter scope on the foreach
53 # We bomb out of the loop with last as soon as heavy is set.
54 if ($args or $fail) {
732bb7c2 55 ($heavy = (/\W/ or $args and not exists $export_cache->{$_}
fa1bb02f
NC
56 or @$fail and $_ eq $fail->[0])) and last
57 foreach (@_);
58 } else {
59 ($heavy = /\W/) and last
732bb7c2 60 foreach (@_);
4af1b167 61 }
732bb7c2 62 return export $pkg, $callpkg, ($args ? @_ : ()) if $heavy;
4af1b167 63 local $SIG{__WARN__} =
bb2cbcd1 64 sub {require Carp; &Carp::carp};
732bb7c2
NC
65 # shortcut for the common case of no type character
66 *{"$callpkg\::$_"} = \&{"$pkg\::$_"} foreach @_;
e50aee73
AD
67}
68
b75c8c73
MS
69# Default methods
70
2b5b2650 71sub export_fail {
b75c8c73
MS
72 my $self = shift;
73 @_;
2b5b2650
PP
74}
75
0e57b4e8
IZ
76# Unfortunately, caller(1)[3] "does not work" if the caller is aliased as
77# *name = \&foo. Thus the need to create a lot of identical subroutines
78# Otherwise we could have aliased them to export().
b75c8c73 79
0e57b4e8
IZ
80sub export_to_level {
81 goto &{as_heavy()};
82}
83
84sub export_tags {
85 goto &{as_heavy()};
b75c8c73
MS
86}
87
0e57b4e8
IZ
88sub export_ok_tags {
89 goto &{as_heavy()};
90}
91
92sub require_version {
93 goto &{as_heavy()};
94}
b75c8c73 95
2b5b2650 961;
732bb7c2 97__END__
b75c8c73 98
2b5b2650
PP
99=head1 NAME
100
101Exporter - Implements default import method for modules
102
103=head1 SYNOPSIS
104
65503211 105In module YourModule.pm:
2b5b2650 106
65503211 107 package YourModule;
2b5b2650
PP
108 require Exporter;
109 @ISA = qw(Exporter);
65503211 110 @EXPORT_OK = qw(munge frobnicate); # symbols to export on request
2b5b2650 111
fe43f860
FD
112or
113
114 package YourModule;
115 use Exporter 'import'; # gives you Exporter's import() method directly
116 @EXPORT_OK = qw(munge frobnicate); # symbols to export on request
117
65503211 118In other files which wish to use YourModule:
2b5b2650 119
65503211
NC
120 use ModuleName qw(frobnicate); # import listed symbols
121 frobnicate ($left, $right) # calls YourModule::frobnicate
2b5b2650
PP
122
123=head1 DESCRIPTION
124
65503211
NC
125The Exporter module implements an C<import> method which allows a module
126to export functions and variables to its users' namespaces. Many modules
127use Exporter rather than implementing their own C<import> method because
128Exporter provides a highly flexible interface, with an implementation optimised
129for the common case.
2b5b2650
PP
130
131Perl automatically calls the C<import> method when processing a
132C<use> statement for a module. Modules and C<use> are documented
133in L<perlfunc> and L<perlmod>. Understanding the concept of
134modules and how the C<use> statement operates is important to
135understanding the Exporter.
136
4fddf32b
GS
137=head2 How to Export
138
139The arrays C<@EXPORT> and C<@EXPORT_OK> in a module hold lists of
140symbols that are going to be exported into the users name space by
141default, or which they can request to be exported, respectively. The
142symbols can represent functions, scalars, arrays, hashes, or typeglobs.
143The symbols must be given by full name with the exception that the
144ampersand in front of a function is optional, e.g.
145
146 @EXPORT = qw(afunc $scalar @array); # afunc is a function
147 @EXPORT_OK = qw(&bfunc %hash *typeglob); # explicit prefix on &bfunc
148
65503211
NC
149If you are only exporting function names it is recommended to omit the
150ampersand, as the implementation is faster this way.
151
2b5b2650
PP
152=head2 Selecting What To Export
153
154Do B<not> export method names!
155
156Do B<not> export anything else by default without a good reason!
157
158Exports pollute the namespace of the module user. If you must export
159try to use @EXPORT_OK in preference to @EXPORT and avoid short or
160common symbol names to reduce the risk of name clashes.
161
162Generally anything not exported is still accessible from outside the
1fef88e7 163module using the ModuleName::item_name (or $blessed_ref-E<gt>method)
2b5b2650
PP
164syntax. By convention you can use a leading underscore on names to
165informally indicate that they are 'internal' and not for public use.
166
167(It is actually possible to get private functions by saying:
168
169 my $subref = sub { ... };
e60ce172
BT
170 $subref->(@args); # Call it as a function
171 $obj->$subref(@args); # Use it as a method
2b5b2650 172
e60ce172
BT
173However if you use them for methods it is up to you to figure out
174how to make inheritance work.)
2b5b2650
PP
175
176As a general rule, if the module is trying to be object oriented
177then export nothing. If it's just a collection of functions then
65503211
NC
178@EXPORT_OK anything but use @EXPORT with caution. For function and
179method names use barewords in preference to names prefixed with
180ampersands for the export lists.
2b5b2650
PP
181
182Other module design guidelines can be found in L<perlmod>.
183
65503211
NC
184=head2 How to Import
185
186In other files which wish to use your module there are three basic ways for
187them to load your module and import its symbols:
188
189=over 4
190
191=item C<use ModuleName;>
192
193This imports all the symbols from ModuleName's @EXPORT into the namespace
194of the C<use> statement.
195
196=item C<use ModuleName ();>
197
198This causes perl to load your module but does not import any symbols.
199
200=item C<use ModuleName qw(...);>
201
202This imports only the symbols listed by the caller into their namespace.
203All listed symbols must be in your @EXPORT or @EXPORT_OK, else an error
204occurs. The advanced export features of Exporter are accessed like this,
205but with list entries that are syntactically distinct from symbol names.
206
207=back
208
209Unless you want to use its advanced features, this is probably all you
210need to know to use Exporter.
211
212=head1 Advanced features
213
2b5b2650
PP
214=head2 Specialised Import Lists
215
a29b0897
MB
216If any of the entries in an import list begins with !, : or / then
217the list is treated as a series of specifications which either add to
218or delete from the list of names to import. They are processed left to
2b5b2650
PP
219right. Specifications are in the form:
220
221 [!]name This name only
222 [!]:DEFAULT All names in @EXPORT
223 [!]:tag All names in $EXPORT_TAGS{tag} anonymous list
224 [!]/pattern/ All names in @EXPORT and @EXPORT_OK which match
225
226A leading ! indicates that matching names should be deleted from the
227list of names to import. If the first specification is a deletion it
228is treated as though preceded by :DEFAULT. If you just want to import
229extra names in addition to the default set you will still need to
230include :DEFAULT explicitly.
231
232e.g., Module.pm defines:
233
234 @EXPORT = qw(A1 A2 A3 A4 A5);
235 @EXPORT_OK = qw(B1 B2 B3 B4 B5);
236 %EXPORT_TAGS = (T1 => [qw(A1 A2 B1 B2)], T2 => [qw(A1 A2 B3 B4)]);
237
238 Note that you cannot use tags in @EXPORT or @EXPORT_OK.
239 Names in EXPORT_TAGS must also appear in @EXPORT or @EXPORT_OK.
240
241An application using Module can say something like:
242
243 use Module qw(:DEFAULT :T2 !B3 A3);
244
245Other examples include:
246
247 use Socket qw(!/^[AP]F_/ !SOMAXCONN !SOL_SOCKET);
248 use POSIX qw(:errno_h :termios_h !TCSADRAIN !/^EXIT/);
249
250Remember that most patterns (using //) will need to be anchored
251with a leading ^, e.g., C</^EXIT/> rather than C</EXIT/>.
252
253You can say C<BEGIN { $Exporter::Verbose=1 }> to see how the
254specifications are being processed and what is actually being imported
255into modules.
256
65503211 257=head2 Exporting without using Exporter's import method
84902520
TB
258
259Exporter has a special method, 'export_to_level' which is used in situations
65503211 260where you can't directly call Exporter's import method. The export_to_level
84902520
TB
261method looks like:
262
cec46e5a 263 MyPackage->export_to_level($where_to_export, $package, @what_to_export);
84902520
TB
264
265where $where_to_export is an integer telling how far up the calling stack
266to export your symbols, and @what_to_export is an array telling what
ba5725f8
GS
267symbols *to* export (usually this is @_). The $package argument is
268currently unused.
84902520
TB
269
270For example, suppose that you have a module, A, which already has an
271import function:
272
cec46e5a 273 package A;
84902520 274
cec46e5a
RGS
275 @ISA = qw(Exporter);
276 @EXPORT_OK = qw ($b);
84902520 277
cec46e5a
RGS
278 sub import
279 {
280 $A::b = 1; # not a very useful import method
281 }
84902520
TB
282
283and you want to Export symbol $A::b back to the module that called
284package A. Since Exporter relies on the import method to work, via
285inheritance, as it stands Exporter::import() will never get called.
286Instead, say the following:
287
cec46e5a
RGS
288 package A;
289 @ISA = qw(Exporter);
290 @EXPORT_OK = qw ($b);
84902520 291
cec46e5a
RGS
292 sub import
293 {
294 $A::b = 1;
295 A->export_to_level(1, @_);
296 }
84902520
TB
297
298This will export the symbols one level 'above' the current package - ie: to
299the program or module that used package A.
300
fe43f860 301Note: Be careful not to modify C<@_> at all before you call export_to_level
84902520
TB
302- or people using your package will get very unexplained results!
303
fe43f860
FD
304=head2 Exporting without inheriting from Exporter
305
306By including Exporter in your @ISA you inherit an Exporter's import() method
307but you also inherit several other helper methods which you probably don't
308want. To avoid this you can do
309
310 package YourModule;
311 use Exporter qw( import );
312
313which will export Exporter's own import() method into YourModule.
314Everything will work as before but you won't need to include Exporter in
315@YourModule::ISA.
84902520 316
2b5b2650
PP
317=head2 Module Version Checking
318
319The Exporter module will convert an attempt to import a number from a
1fef88e7 320module into a call to $module_name-E<gt>require_version($value). This can
2b5b2650
PP
321be used to validate that the version of the module being used is
322greater than or equal to the required version.
323
324The Exporter module supplies a default require_version method which
325checks the value of $VERSION in the exporting module.
326
327Since the default require_version method treats the $VERSION number as
d5e40bcc
PP
328a simple numeric value it will regard version 1.10 as lower than
3291.9. For this reason it is strongly recommended that you use numbers
330with at least two decimal places, e.g., 1.09.
2b5b2650
PP
331
332=head2 Managing Unknown Symbols
333
334In some situations you may want to prevent certain symbols from being
335exported. Typically this applies to extensions which have functions
336or constants that may not exist on some systems.
337
338The names of any symbols that cannot be exported should be listed
339in the C<@EXPORT_FAIL> array.
340
7a2e2cd6 341If a module attempts to import any of these symbols the Exporter
2b5b2650
PP
342will give the module an opportunity to handle the situation before
343generating an error. The Exporter will call an export_fail method
344with a list of the failed symbols:
345
346 @failed_symbols = $module_name->export_fail(@failed_symbols);
347
348If the export_fail method returns an empty list then no error is
349recorded and all the requested symbols are exported. If the returned
350list is not empty then an error is generated for each symbol and the
351export fails. The Exporter provides a default export_fail method which
352simply returns the list unchanged.
353
354Uses for the export_fail method include giving better error messages
355for some symbols and performing lazy architectural checks (put more
356symbols into @EXPORT_FAIL by default and then take them out if someone
357actually tries to use them and an expensive check shows that they are
358usable on that platform).
359
360=head2 Tag Handling Utility Functions
361
362Since the symbols listed within %EXPORT_TAGS must also appear in either
363@EXPORT or @EXPORT_OK, two utility functions are provided which allow
364you to easily add tagged sets of symbols to @EXPORT or @EXPORT_OK:
365
366 %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]);
367
368 Exporter::export_tags('foo'); # add aa, bb and cc to @EXPORT
369 Exporter::export_ok_tags('bar'); # add aa, cc and dd to @EXPORT_OK
370
371Any names which are not tags are added to @EXPORT or @EXPORT_OK
d5e40bcc 372unchanged but will trigger a warning (with C<-w>) to avoid misspelt tags
2b5b2650
PP
373names being silently added to @EXPORT or @EXPORT_OK. Future versions
374may make this a fatal error.
375
d584343b
GME
376=head2 Generating combined tags
377
378If several symbol categories exist in %EXPORT_TAGS, it's usually
379useful to create the utility ":all" to simplify "use" statements.
380
381The simplest way to do this is:
382
383 %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]);
384
385 # add all the other ":class" tags to the ":all" class,
386 # deleting duplicates
387 {
388 my %seen;
389
390 push @{$EXPORT_TAGS{all}},
391 grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} foreach keys %EXPORT_TAGS;
392 }
393
394CGI.pm creates an ":all" tag which contains some (but not really
395all) of its categories. That could be done with one small
396change:
397
398 # add some of the other ":class" tags to the ":all" class,
399 # deleting duplicates
400 {
401 my %seen;
402
403 push @{$EXPORT_TAGS{all}},
404 grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}}
405 foreach qw/html2 html3 netscape form cgi internal/;
406 }
407
408Note that the tag names in %EXPORT_TAGS don't have the leading ':'.
409
5fea0f12
BS
410=head2 C<AUTOLOAD>ed Constants
411
8b4c0206
T
412Many modules make use of C<AUTOLOAD>ing for constant subroutines to
413avoid having to compile and waste memory on rarely used values (see
414L<perlsub> for details on constant subroutines). Calls to such
415constant subroutines are not optimized away at compile time because
416they can't be checked at compile time for constancy.
417
418Even if a prototype is available at compile time, the body of the
419subroutine is not (it hasn't been C<AUTOLOAD>ed yet). perl needs to
420examine both the C<()> prototype and the body of a subroutine at
421compile time to detect that it can safely replace calls to that
422subroutine with the constant value.
5fea0f12
BS
423
424A workaround for this is to call the constants once in a C<BEGIN> block:
425
426 package My ;
427
428 use Socket ;
429
430 foo( SO_LINGER ); ## SO_LINGER NOT optimized away; called at runtime
431 BEGIN { SO_LINGER }
432 foo( SO_LINGER ); ## SO_LINGER optimized away at compile time.
433
8b4c0206
T
434This forces the C<AUTOLOAD> for C<SO_LINGER> to take place before
435SO_LINGER is encountered later in C<My> package.
5fea0f12 436
8b4c0206
T
437If you are writing a package that C<AUTOLOAD>s, consider forcing
438an C<AUTOLOAD> for any constants explicitly imported by other packages
439or which are usually used when your package is C<use>d.
5fea0f12 440
2b5b2650 441=cut