I sometimes outsmart myself.

[perl5.git] / lib / Exporter.pm

diff --git a/lib/Exporter.pm b/lib/Exporter.pm
index ad6cdef..6459312 100644 (file)
--- a/lib/Exporter.pm
+++ b/lib/Exporter.pm
@@ -8,7 +8,8 @@ no strict 'refs';
 our $Debug = 0;
 our $ExportLevel = 0;
 our $Verbose ||= 0;
-our $VERSION = '5.562';
+our $VERSION = '5.564';
+$Carp::Internal{Exporter} = 1;
 
 sub export_to_level {
   require Exporter::Heavy;
@@ -56,7 +57,7 @@ sub import {
     return export $pkg, $callpkg, ($args ? @_ : ());
   }
   local $SIG{__WARN__} = 
-       sub {require Carp; local $Carp::CarpLevel = 1; &Carp::carp};
+       sub {require Carp; &Carp::carp};
   foreach my $sym (@_) {
     # shortcut for the common case of no type character
     *{"$callpkg\::$sym"} = \&{"$pkg\::$sym"};
@@ -146,10 +147,11 @@ informally indicate that they are 'internal' and not for public use.
 (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
@@ -307,4 +309,35 @@ unchanged but will trigger a warning (with C<-w>) to avoid misspelt tags
 names being silently added to @EXPORT or @EXPORT_OK. Future versions
 may make this a fatal error.
 
+=head2 C<AUTOLOAD>ed Constants
+
+Many modules make use of C<AUTOLOAD>ing for constant subroutines to
+avoid having to compile and waste memory on rarely used values (see
+L<perlsub> for details on constant subroutines).  Calls to such
+constant subroutines are not optimized away at compile time because
+they can't be checked at compile time for constancy.
+
+Even if a prototype is available at compile time, the body of the
+subroutine is not (it hasn't been C<AUTOLOAD>ed yet). perl needs to
+examine both the C<()> prototype and the body of a subroutine at
+compile time to detect that it can safely replace calls to that
+subroutine with the constant value.
+
+A workaround for this is to call the constants once in a C<BEGIN> block:
+
+   package My ;
+
+   use Socket ;
+
+   foo( SO_LINGER );     ## SO_LINGER NOT optimized away; called at runtime
+   BEGIN { SO_LINGER }
+   foo( SO_LINGER );     ## SO_LINGER optimized away at compile time.
+
+This forces the C<AUTOLOAD> for C<SO_LINGER> to take place before
+SO_LINGER is encountered later in C<My> package.
+
+If you are writing a package that C<AUTOLOAD>s, consider forcing
+an C<AUTOLOAD> for any constants explicitly imported by other packages
+or which are usually used when your package is C<use>d.
+
 =cut