Integrate mainline

[perl5.git] / lib / Exporter.pm

diff --git a/lib/Exporter.pm b/lib/Exporter.pm
index 9a361a7..bd55160 100644 (file)
--- a/lib/Exporter.pm
+++ b/lib/Exporter.pm
@@ -1,6 +1,6 @@
 package Exporter;
 
-require 5.001;
+require 5.006;
 
 use strict;
 no strict 'refs';
@@ -8,7 +8,8 @@ no strict 'refs';
 our $Debug = 0;
 our $ExportLevel = 0;
 our $Verbose ||= 0;
-our $VERSION = '5.563';
+our $VERSION = '5.565';
+$Carp::Internal{Exporter} = 1;
 
 sub export_to_level {
   require Exporter::Heavy;
@@ -34,33 +35,34 @@ 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; local $Carp::CarpLevel = 1; &Carp::carp};
-  foreach my $sym (@_) {
-    # shortcut for the common case of no type character
-    *{"$callpkg\::$sym"} = \&{"$pkg\::$sym"};
-  }
+       sub {require Carp; &Carp::carp};
+  # shortcut for the common case of no type character
+  *{"$callpkg\::$_"} = \&{"$pkg\::$_"} foreach @_;
 }
 
 
@@ -79,7 +81,7 @@ sub require_version {
 
 
 1;
-
+__END__
 
 =head1 NAME
 
@@ -146,10 +148,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 +310,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