Update to MakeMaker 5.34

7 files changed, 2657 insertions, 2821 deletions

diff --git a/lib/ExtUtils/Install.pm b/lib/ExtUtils/Install.pm
index 46b09d5025..45bd2d7b0e 100644
--- a/lib/ExtUtils/Install.pm
+++ b/lib/ExtUtils/Install.pm
@@ -1,27 +1,30 @@
 package ExtUtils::Install;
 
+$VERSION = substr q$Revision: 1.12 $, 10;
+# $Id: Install.pm,v 1.12 1996/06/23 20:46:07 k Exp $
+
 use Exporter;
-use SelfLoader;
 use Carp ();
-
+use Config ();
+use vars qw(@ISA @EXPORT $VERSION);
 @ISA = ('Exporter');
 @EXPORT = ('install','uninstall','pm_to_blib');
 $Is_VMS = $^O eq 'VMS';
 
+my $splitchar = $^O eq 'VMS' ? '|' : $^O eq 'os2' ? ';' : ':';
+my @PERL_ENV_LIB = split $splitchar, defined $ENV{'PERL5LIB'} ? $ENV{'PERL5LIB'} : $ENV{'PERLLIB'};
+my $Inc_uninstall_warn_handler;
+
 #use vars qw( @EXPORT @ISA $Is_VMS );
 #use strict;
 
-1;
-
-sub ExtUtils::Install::install;
-sub ExtUtils::Install::uninstall;
-sub ExtUtils::Install::pm_to_blib;
-sub ExtUtils::Install::my_cmp;
-
-__DATA__
+sub forceunlink {
+    chmod 0666, $_[0];
+    unlink $_[0] or Carp::croak("Cannot forceunlink $_[0]: $!")
+}
 
 sub install {
-    my($hash,$verbose,$nonono) = @_;
+    my($hash,$verbose,$nonono,$inc_uninstall) = @_;
     $verbose ||= 0;
     $nonono  ||= 0;
 
@@ -31,7 +34,11 @@ sub install {
     use File::Copy qw(copy);
     use File::Find qw(find);
     use File::Path qw(mkpath);
-    # require "auto/ExtUtils/Install/my_cmp.al"; # Hairy, but for the first
+    # The following lines were needed with AutoLoader (left for the record)
+    # my $my_req = $self->catfile(qw(auto ExtUtils Install my_cmp.al));
+    # require $my_req;
+    # $my_req = $self->catfile(qw(auto ExtUtils Install forceunlink.al));
+    # require $my_req; # Hairy, but for the first
     # time use we are in a different directory when autoload happens, so
     # the relativ path to ./blib is ill.
 
@@ -47,7 +54,7 @@ sub install {
 	#Check if there are files, and if yes, look if the corresponding
 	#target directory is writable for us
 	opendir DIR, $source_dir_or_file or next;
-	while ($_ = readdir DIR) {
+	for (readdir DIR) {
 	    next if $_ eq "." || $_ eq ".." || $_ eq ".exists";
 	    if (-w $hash{$source_dir_or_file} || mkpath($hash{$source_dir_or_file})) {
 		last;
@@ -89,8 +96,8 @@ sub install {
 	    return if $_ eq ".exists";
 	    my $targetdir = $MY->catdir($hash{$source},$File::Find::dir);
 	    my $targetfile = $MY->catfile($targetdir,$_);
-	    my $diff = 0;
 
+	    my $diff = 0;
 	    if ( -f $targetfile && -s _ == $size) {
 		# We have a good chance, we can skip this one
 		$diff = my_cmp($_,$targetfile);
@@ -101,21 +108,28 @@ sub install {
 
 	    if ($diff){
 		if (-f $targetfile){
-		    unlink $targetfile or Carp::croak("Couldn't unlink $targetfile");
+		    forceunlink($targetfile) unless $nonono;
 		} else {
 		    mkpath($targetdir,0,0755) unless $nonono;
 		    print "mkpath($targetdir,0,0755)\n" if $verbose>1;
 		}
 		copy($_,$targetfile) unless $nonono;
-		print "Installing $targetfile\n" if $verbose;
+		print "Installing $targetfile\n";
 		utime($atime,$mtime + $Is_VMS,$targetfile) unless $nonono>1;
 		print "utime($atime,$mtime,$targetfile)\n" if $verbose>1;
+		$mode = 0444 | ( $mode & 0111 ? 0111 : 0 );
 		chmod $mode, $targetfile;
 		print "chmod($mode, $targetfile)\n" if $verbose>1;
 	    } else {
-		print "Skipping $targetfile (unchanged)\n";
+		print "Skipping $targetfile (unchanged)\n" if $verbose;
+	    }
+	    
+	    if (! defined $inc_uninstall) { # it's called 
+	    } elsif ($inc_uninstall == 0){
+		inc_uninstall($_,$File::Find::dir,$verbose,1); # nonono set to 1
+	    } else {
+		inc_uninstall($_,$File::Find::dir,$verbose,0); # nonono set to 0
 	    }
-
 	    $write{$targetfile}++;
 
 	}, ".");
@@ -163,15 +177,56 @@ sub my_cmp {
 sub uninstall {
     my($fil,$verbose,$nonono) = @_;
     die "no packlist file found: $fil" unless -f $fil;
+    # my $my_req = $self->catfile(qw(auto ExtUtils Install forceunlink.al));
+    # require $my_req; # Hairy, but for the first
     local *P;
     open P, $fil or Carp::croak("uninstall: Could not read packlist file $fil: $!");
     while (<P>) {
 	chomp;
 	print "unlink $_\n" if $verbose;
-	unlink($_) || Carp::carp("Couldn't unlink $_") unless $nonono;
+	forceunlink($_) unless $nonono;
     }
     print "unlink $fil\n" if $verbose;
-    unlink($fil) || Carp::carp("Couldn't unlink $fil") unless $nonono;
+    forceunlink($fil) unless $nonono;
+}
+
+sub inc_uninstall {
+    my($file,$libdir,$verbose,$nonono) = @_;
+    my($dir);
+    my $MY = {};
+    bless $MY, 'MY';
+    my %seen_dir = ();
+    foreach $dir (@INC, @PERL_ENV_LIB, @Config::Config{qw/archlibexp privlibexp sitearchexp sitelibexp/}) {
+	next if $dir eq ".";
+	next if $seen_dir{$dir}++;
+	my($targetfile) = $MY->catfile($dir,$libdir,$file);
+	next unless -f $targetfile;
+
+	# The reason why we compare file's contents is, that we cannot
+	# know, which is the file we just installed (AFS). So we leave
+	# an identical file in place
+	my $diff = 0;
+	if ( -f $targetfile && -s _ == -s $file) {
+	    # We have a good chance, we can skip this one
+	    $diff = my_cmp($file,$targetfile);
+	} else {
+	    print "#$file and $targetfile differ\n" if $verbose>1;
+	    $diff++;
+	}
+
+	next unless $diff;
+	if ($nonono) {
+	    if ($verbose) {
+		$Inc_uninstall_warn_handler ||= new ExtUtils::Install::Warn;
+		$libdir =~ s|^\./|| ; # That's just cosmetics, no need to port. It looks prettier.
+		$Inc_uninstall_warn_handler->add("$libdir/$file",$targetfile);
+	    }
+	    # if not verbose, we just say nothing
+	} else {
+	    print "Unlinking $targetfile (shadowing?)\n";
+	    forceunlink($targetfile);
+	}
+    }
 }
 
 sub pm_to_blib {
@@ -181,6 +236,8 @@ sub pm_to_blib {
     use File::Copy qw(copy);
     use File::Path qw(mkpath);
     use AutoSplit;
+    # my $my_req = $self->catfile(qw(auto ExtUtils Install forceunlink.al));
+    # require $my_req; # Hairy, but for the first
 
     my $umask = umask 0022 unless $Is_VMS;
     mkpath($autodir,0,0755);
@@ -191,12 +248,12 @@ sub pm_to_blib {
 	    next;
 	}
 	if (-f $fromto->{$_}){
-	    unlink $fromto->{$_} or Carp::carp("Couldn't unlink $fromto->{$_}");
+	    forceunlink($fromto->{$_});
 	} else {
 	    mkpath(dirname($fromto->{$_}),0,0755);
 	}
 	copy($_,$fromto->{$_});
-	chmod((stat)[2],$fromto->{$_});
+	chmod(0444 | ( (stat)[2] & 0111 ? 0111 : 0 ),$fromto->{$_});
 	print "cp $_ $fromto->{$_}\n";
 	next unless /\.pm$/;
 	autosplit($fromto->{$_},$autodir);
@@ -204,6 +261,30 @@ sub pm_to_blib {
     umask $umask unless $Is_VMS;
 }
 
+package ExtUtils::Install::Warn;
+
+sub new { bless {}, shift }
+
+sub add {
+    my($self,$file,$targetfile) = @_;
+    push @{$self->{$file}}, $targetfile;
+}
+
+sub DESTROY {
+    my $self = shift;
+    my($file,$i,$plural);
+    foreach $file (sort keys %$self) {
+	$plural = @{$self->{$file}} > 1 ? "s" : "";
+	print "## Differing version$plural of $file found. You might like to\n";
+	for (0..$#{$self->{$file}}) {
+	    print "rm ", $self->{$file}[$_], "\n";
+	    $i++;
+	}
+    }
+    $plural = $i>1 ? "all those files" : "this file";
+    print "## Running 'make install UNINST=1' will unlink $plural for you.\n";
+}
+
 1;
 
 __END__
diff --git a/lib/ExtUtils/Liblist.pm b/lib/ExtUtils/Liblist.pm
index 1064cb17b7..77aa831bc7 100644
--- a/lib/ExtUtils/Liblist.pm
+++ b/lib/ExtUtils/Liblist.pm
@@ -2,6 +2,8 @@ package ExtUtils::Liblist;
 
 # Broken out of MakeMaker from version 4.11
 
+$ExtUtils::Liblist::VERSION = substr q$Revision: 1.19 $, 10;
+
 use Config;
 use Cwd 'cwd';
 use File::Basename;
@@ -10,7 +12,7 @@ my $Config_libext = $Config{lib_ext} || ".a";
 
 sub ext {
     my($self,$potential_libs, $Verbose) = @_;
-    if ($^O eq 'os2' and $Config{libs}) { 
+    if ($^O =~ 'os2' and $Config{libs}) { 
 	# Dynamic libraries are not transitive, so we may need including
 	# the libraries linked against perl.dll again.
 
@@ -45,9 +47,9 @@ sub ext {
 			if $Verbose;
 		next;
 	    }
-	    if ($thislib !~ m|^/|) {
+	    unless ($self->file_name_is_absolute($thislib)) {
 	      print STDOUT "Warning: $ptype$thislib changed to $ptype$pwd/$thislib\n";
-	      $thislib = "$pwd/$thislib";
+	      $thislib = $self->catdir($pwd,$thislib);
 	    }
 	    push(@searchpath, $thislib);
 	    push(@extralibs,  "$ptype$thislib");
diff --git a/lib/ExtUtils/MM_Unix.pm b/lib/ExtUtils/MM_Unix.pm
index 7b5b17325c..34cf76ed53 100644
--- a/lib/ExtUtils/MM_Unix.pm
+++ b/lib/ExtUtils/MM_Unix.pm
@@ -1,32 +1,23 @@
 package ExtUtils::MM_Unix;
 
-# $Id: MM_Unix.pm,v 1.14 1996/02/29 07:59:10 k Exp $
-
-						    # Loading Time cumulated
-require Exporter;      	       	       	       	    # 0.28          0.28
-use Config;					    # 0.37          0.38
-use File::Basename qw(basename dirname fileparse);  # 0.47          0.48
-use DirHandle;					    # 0.37          0.58
-# use FileHandle ();				    # 1.28   !!!!   1.46
-
-# And another benchmark. I have deleted MakeMaker completely from the perl installation
-# and deleted blib and pm_to_blib, the timestamp file.
-
-# MM_Unix with Selfloader:
-# perl Makefile.PL  4.34s user 0.57s system 84% cpu 5.844 total
-# make  14.77s user 3.16s system 78% cpu 22.698 total
-
-# MM_Unix with my own autoloader
-# perl Makefile.PL  3.82s user 0.55s system 73% cpu 5.920 total
-# make  14.70s user 3.27s system 82% cpu 21.714 total
-
+$VERSION = substr q$Revision: 1.101 $, 10;
+# $Id: MM_Unix.pm,v 1.101 1996/06/23 20:51:18 k Exp k $
 
+require Exporter;
+use Config;
+use File::Basename qw(basename dirname fileparse);
+use DirHandle;
 
 Exporter::import('ExtUtils::MakeMaker',
 	qw( $Verbose &neatvalue));
 
-$Is_OS2 = $^O eq 'os2';
-$Is_VMS = $^O eq 'VMS';
+$Is_OS2 = $^O =~ m|^os/?2$|i;
+$Is_Mac = $^O eq "MacOS";
+
+if ($Is_VMS = $^O eq 'VMS') {
+    require VMS::Filespec;
+    import VMS::Filespec qw( &vmsify );
+}
 
 =head1 NAME
 
@@ -64,7 +55,7 @@ The following description of methods is still under
 development. Please refer to the code for not suitably documented
 sections and complain loudly to the makemaker mailing list.
 
-Not all of the methos below are overridable in a
+Not all of the methods below are overridable in a
 Makefile.PL. Overridable methods are marked as (o). All methods are
 overridable by a platform specific MM_*.pm file (See
 L<ExtUtils::MM_VMS>) and L<ExtUtils::MM_OS2>).
@@ -73,325 +64,1035 @@ L<ExtUtils::MM_VMS>) and L<ExtUtils::MM_OS2>).
 
 =over 2
 
+=item canonpath
+
+No physical check on the filesystem, but a logical cleanup of a
+path. On UNIX eliminated successive slashes and successive "/.".
+
+=cut
+
+sub canonpath {
+    my($self,$path) = @_;
+    $path =~ s|/+|/|g ;                            # xx////xx  -> xx/xx
+    $path =~ s|(/\.)+/|/|g ;                       # xx/././xx -> xx/xx
+    $path =~ s|^(\./)+|| unless $path eq "./";     # ./xx      -> xx
+    $path =~ s|/$|| unless $path eq "/";           # xx/       -> xx
+    $path;
+}
+
 =item catdir
 
 Concatenate two or more directory names to form a complete path ending
-with a directory
+with a directory. But remove the trailing slash from the resulting
+string, because it doesn't look good, isn't necessary and confuses
+OS2. Of course, if this is the root directory, don't cut off the
+trailing slash :-)
 
 =cut
 
 # ';
 
-sub catdir  {
+sub catdir {
     shift;
-    my $result = join('/',@_);
-    $result =~ s:/(\./)+:/:g;
-    $result =~ s:/+:/:g;
-    $result =~ s:/$::;
+    my @args = @_;
+    for (@args) {
+	# append a slash to each argument unless it has one there
+	$_ .= "/" unless substr($_,length($_)-1,1) eq "/";
+    }
+    my $result = join('', @args);
+    # remove a trailing slash unless we are root
+    substr($result,length($result)-1,1) = ""
+	if length($result) > 1 && substr($result,length($result)-1,1) eq "/";
     $result;
 }
 
 =item catfile
 
-Concatenate two or more directory names and a filename to form a
+Concatenate one or more directory names and a filename to form a
 complete path ending with a filename
 
 =cut
 
 sub catfile {
-    shift;
-    my $result = join('/',@_);
-    $result =~ s:/(\./)+:/:g;
-    $result =~ s:/+:/:g;
-    $result;
+    my $self = shift @_;
+    my $file = pop @_;
+    return $file unless @_;
+    my $dir = $self->catdir(@_);
+    for ($dir) {
+	$_ .= "/" unless substr($_,length($_)-1,1) eq "/";
+    }
+    return $dir.$file;
 }
 
-sub ExtUtils::MM_Unix::guess_name ;
-sub ExtUtils::MM_Unix::init_main ;
-sub ExtUtils::MM_Unix::init_dirscan ;
-sub ExtUtils::MM_Unix::init_others ;
-sub ExtUtils::MM_Unix::find_perl ;
-sub ExtUtils::MM_Unix::post_initialize ;
+=item curdir
+
+Returns a string representing of the current directory.  "." on UNIX.
+
+=cut
+
+sub curdir {
+    return "." ;
+}
+
+=item rootdir
+
+Returns a string representing of the root directory.  "/" on UNIX.
+
+=cut
+
+sub rootdir {
+    return "/";
+}
+
+=item updir
+
+Returns a string representing of the parent directory.  ".." on UNIX.
+
+=cut
+
+sub updir {
+    return "..";
+}
+
+sub ExtUtils::MM_Unix::c_o ;
+sub ExtUtils::MM_Unix::clean ;
+sub ExtUtils::MM_Unix::const_cccmd ;
 sub ExtUtils::MM_Unix::const_config ;
-sub ExtUtils::MM_Unix::constants ;
 sub ExtUtils::MM_Unix::const_loadlibs ;
-sub ExtUtils::MM_Unix::const_cccmd ;
-sub ExtUtils::MM_Unix::tool_autosplit ;
-sub ExtUtils::MM_Unix::tool_xsubpp ;
-sub ExtUtils::MM_Unix::xsubpp_version ;
-sub ExtUtils::MM_Unix::tools_other ;
-sub ExtUtils::MM_Unix::dist ;
-sub ExtUtils::MM_Unix::macro ;
+sub ExtUtils::MM_Unix::constants ;
 sub ExtUtils::MM_Unix::depend ;
-sub ExtUtils::MM_Unix::post_constants ;
-sub ExtUtils::MM_Unix::pasthru ;
-sub ExtUtils::MM_Unix::c_o ;
-sub ExtUtils::MM_Unix::xs_c ;
-sub ExtUtils::MM_Unix::xs_o ;
-sub ExtUtils::MM_Unix::top_targets ;
-sub ExtUtils::MM_Unix::linkext ;
+sub ExtUtils::MM_Unix::dir_target ;
+sub ExtUtils::MM_Unix::dist ;
+sub ExtUtils::MM_Unix::dist_basics ;
+sub ExtUtils::MM_Unix::dist_ci ;
+sub ExtUtils::MM_Unix::dist_core ;
+sub ExtUtils::MM_Unix::dist_dir ;
+sub ExtUtils::MM_Unix::dist_test ;
 sub ExtUtils::MM_Unix::dlsyms ;
 sub ExtUtils::MM_Unix::dynamic ;
 sub ExtUtils::MM_Unix::dynamic_bs ;
 sub ExtUtils::MM_Unix::dynamic_lib ;
-sub ExtUtils::MM_Unix::static ;
-sub ExtUtils::MM_Unix::static_lib ;
-#sub ExtUtils::MM_Unix::installpm ;
-#sub ExtUtils::MM_Unix::installpm_x ;
-sub ExtUtils::MM_Unix::pm_to_blib ;
+sub ExtUtils::MM_Unix::exescan ;
+sub ExtUtils::MM_Unix::extliblist ;
+sub ExtUtils::MM_Unix::file_name_is_absolute ;
+sub ExtUtils::MM_Unix::find_perl ;
+sub ExtUtils::MM_Unix::force ;
+sub ExtUtils::MM_Unix::guess_name ;
+sub ExtUtils::MM_Unix::has_link_code ;
+sub ExtUtils::MM_Unix::init_dirscan ;
+sub ExtUtils::MM_Unix::init_main ;
+sub ExtUtils::MM_Unix::init_others ;
+sub ExtUtils::MM_Unix::install ;
+sub ExtUtils::MM_Unix::installbin ;
+sub ExtUtils::MM_Unix::libscan ;
+sub ExtUtils::MM_Unix::linkext ;
+sub ExtUtils::MM_Unix::lsdir ;
+sub ExtUtils::MM_Unix::macro ;
+sub ExtUtils::MM_Unix::makeaperl ;
+sub ExtUtils::MM_Unix::makefile ;
 sub ExtUtils::MM_Unix::manifypods ;
+sub ExtUtils::MM_Unix::maybe_command ;
+sub ExtUtils::MM_Unix::maybe_command_in_dirs ;
+sub ExtUtils::MM_Unix::needs_linking ;
+sub ExtUtils::MM_Unix::nicetext ;
+sub ExtUtils::MM_Unix::parse_version ;
+sub ExtUtils::MM_Unix::pasthru ;
+sub ExtUtils::MM_Unix::path ;
+sub ExtUtils::MM_Unix::perl_script ;
+sub ExtUtils::MM_Unix::perldepend ;
+sub ExtUtils::MM_Unix::pm_to_blib ;
+sub ExtUtils::MM_Unix::post_constants ;
+sub ExtUtils::MM_Unix::post_initialize ;
+sub ExtUtils::MM_Unix::postamble ;
+sub ExtUtils::MM_Unix::prefixify ;
 sub ExtUtils::MM_Unix::processPL ;
-sub ExtUtils::MM_Unix::installbin ;
-sub ExtUtils::MM_Unix::subdirs ;
-sub ExtUtils::MM_Unix::subdir_x ;
-sub ExtUtils::MM_Unix::clean ;
 sub ExtUtils::MM_Unix::realclean ;
-sub ExtUtils::MM_Unix::dist_basics ;
-sub ExtUtils::MM_Unix::dist_core ;
-sub ExtUtils::MM_Unix::dist_dir ;
-sub ExtUtils::MM_Unix::dist_test ;
-sub ExtUtils::MM_Unix::dist_ci ;
-sub ExtUtils::MM_Unix::install ;
-sub ExtUtils::MM_Unix::force ;
-sub ExtUtils::MM_Unix::perldepend ;
-sub ExtUtils::MM_Unix::makefile ;
+sub ExtUtils::MM_Unix::replace_manpage_separator ;
+sub ExtUtils::MM_Unix::static ;
+sub ExtUtils::MM_Unix::static_lib ;
 sub ExtUtils::MM_Unix::staticmake ;
+sub ExtUtils::MM_Unix::subdir_x ;
+sub ExtUtils::MM_Unix::subdirs ;
 sub ExtUtils::MM_Unix::test ;
 sub ExtUtils::MM_Unix::test_via_harness ;
 sub ExtUtils::MM_Unix::test_via_script ;
-sub ExtUtils::MM_Unix::postamble ;
-sub ExtUtils::MM_Unix::makeaperl ;
-sub ExtUtils::MM_Unix::extliblist ;
-sub ExtUtils::MM_Unix::dir_target ;
-sub ExtUtils::MM_Unix::needs_linking ;
-sub ExtUtils::MM_Unix::has_link_code ;
+sub ExtUtils::MM_Unix::tool_autosplit ;
+sub ExtUtils::MM_Unix::tool_xsubpp ;
+sub ExtUtils::MM_Unix::tools_other ;
+sub ExtUtils::MM_Unix::top_targets ;
 sub ExtUtils::MM_Unix::writedoc ;
-sub ExtUtils::MM_Unix::perl_script ;
-sub ExtUtils::MM_Unix::maybe_command ;
-sub ExtUtils::MM_Unix::maybe_command_in_dirs ;
-sub ExtUtils::MM_Unix::prefixify ;
-sub ExtUtils::MM_Unix::file_name_is_absolute ;
-sub ExtUtils::MM_Unix::replace_manpage_separator ;
-sub ExtUtils::MM_Unix::path ;
-sub ExtUtils::MM_Unix::lsdir ;
-sub ExtUtils::MM_Unix::exescan ;
-sub ExtUtils::MM_Unix::libscan ;
-sub ExtUtils::MM_Unix::nicetext ;
+sub ExtUtils::MM_Unix::xs_c ;
+sub ExtUtils::MM_Unix::xs_o ;
+sub ExtUtils::MM_Unix::xsubpp_version ;
 
 package ExtUtils::MM_Unix;
 
-use SelfLoader;
-#sub AUTOLOAD {
-#    my $code;
-#    if (defined fileno(DATA)) {
-#	while (<DATA>) {
-#	    last if /^__END__/;
-#	    $code .= $_;
-#	}
-#	close DATA;
-#	eval $code;
-#	if ($@) {
-#	    $@ =~ s/ at .*\n//;
-#	    Carp::croak $@;
-#	}
-#    } else {
-#	warn "AUTOLOAD called unexpectedly for $AUTOLOAD"; 
-#    }
-#    defined(&$AUTOLOAD) or die "Myloader inconsistency error";
-#    goto &$AUTOLOAD;
-#}
-
-
+#use SelfLoader;
 
 1;
-__DATA__
+#__DATA__
 
 =head2 SelfLoaded methods
 
-=item nicetext
+=item c_o (o)
 
-misnamed method (will have to be changed). The MM_Unix method just
-returns the argument without further processing.
+Defines the suffix rules to compile different flavors of C files to
+object files.
 
-On VMS used to insure that colons marking targets are preceded by
-space - most Unix Makes don't need this, but it's necessary under VMS
-to distinguish the target delimiter from a colon appearing as part of
-a filespec.
+=cut
+
+sub c_o {
+# --- Translation Sections ---
+
+    my($self) = shift;
+    return '' unless $self->needs_linking();
+    my(@m);
+    push @m, '
+.c$(OBJ_EXT):
+	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
+
+.C$(OBJ_EXT):
+	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
+
+.cpp$(OBJ_EXT):
+	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cpp
+
+.cxx$(OBJ_EXT):
+	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cxx
+
+.cc$(OBJ_EXT):
+	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cc
+';
+    join "", @m;
+}
+
+=item cflags (o)
+
+Does very much the same as the cflags script in the perl
+distribution. It doesn't return the whole compiler command line, but
+initializes all of its parts. The const_cccmd method then actually
+returns the definition of the CCCMD macro which uses these parts.
 
 =cut
 
-sub nicetext {
-    my($self,$text) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+#'
+
+sub cflags {
+    my($self,$libperl)=@_;
+    return $self->{CFLAGS} if $self->{CFLAGS};
+    return '' unless $self->needs_linking();
+
+    my($prog, $uc, $perltype, %cflags);
+    $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
+    $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
+
+    @cflags{qw(cc ccflags optimize large split shellflags)}
+	= @Config{qw(cc ccflags optimize large split shellflags)};
+    my($optdebug) = "";
+
+    $cflags{shellflags} ||= '';
+
+    my(%map) =  (
+		D =>   '-DDEBUGGING',
+		E =>   '-DEMBED',
+		DE =>  '-DDEBUGGING -DEMBED',
+		M =>   '-DEMBED -DMULTIPLICITY',
+		DM =>  '-DDEBUGGING -DEMBED -DMULTIPLICITY',
+		);
+
+    if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
+	$uc = uc($1);
+    } else {
+	$uc = ""; # avoid warning
     }
-    $text;
+    $perltype = $map{$uc} ? $map{$uc} : "";
+
+    if ($uc =~ /^D/) {
+	$optdebug = "-g";
+    }
+
+
+    my($name);
+    ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
+    if ($prog = $Config::Config{$name}) {
+	# Expand hints for this extension via the shell
+	print STDOUT "Processing $name hint:\n" if $Verbose;
+	my(@o)=`cc=\"$cflags{cc}\"
+	  ccflags=\"$cflags{ccflags}\"
+	  optimize=\"$cflags{optimize}\"
+	  perltype=\"$cflags{perltype}\"
+	  optdebug=\"$cflags{optdebug}\"
+	  large=\"$cflags{large}\"
+	  split=\"$cflags{'split'}\"
+	  eval '$prog'
+	  echo cc=\$cc
+	  echo ccflags=\$ccflags
+	  echo optimize=\$optimize
+	  echo perltype=\$perltype
+	  echo optdebug=\$optdebug
+	  echo large=\$large
+	  echo split=\$split
+	  `;
+	my($line);
+	foreach $line (@o){
+	    chomp $line;
+	    if ($line =~ /(.*?)=\s*(.*)\s*$/){
+		$cflags{$1} = $2;
+		print STDOUT "	$1 = $2\n" if $Verbose;
+	    } else {
+		print STDOUT "Unrecognised result from hint: '$line'\n";
+	    }
+	}
+    }
+
+    if ($optdebug) {
+	$cflags{optimize} = $optdebug;
+    }
+
+    for (qw(ccflags optimize perltype large split)) {
+	$cflags{$_} =~ s/^\s+//;
+	$cflags{$_} =~ s/\s+/ /g;
+	$cflags{$_} =~ s/\s+$//;
+	$self->{uc $_} ||= $cflags{$_}
+    }
+
+    return $self->{CFLAGS} = qq{
+CCFLAGS = $self->{CCFLAGS}
+OPTIMIZE = $self->{OPTIMIZE}
+PERLTYPE = $self->{PERLTYPE}
+LARGE = $self->{LARGE}
+SPLIT = $self->{SPLIT}
+};
+
 }
 
-=item libscan (o)
+=item clean (o)
 
-Takes a path to a file that is found by init_dirscan and returns false
-if we don't want to include this file in the library. Mainly used to
-exclude RCS, CVS, and SCCS directories from installation.
+Defines the clean target.
 
 =cut
 
-# ';
+sub clean {
+# --- Cleanup and Distribution Sections ---
 
-sub libscan {
-    my($self,$path) = @_;
-    return '' if $path =~ m:/(RCS|CVS|SCCS)/: ;
-    $path;
+    my($self, %attribs) = @_;
+    my(@m,$dir);
+    push(@m, '
+# Delete temporary files but do not touch installed files. We don\'t delete
+# the Makefile here so a later make realclean still has a makefile to use.
+
+clean ::
+');
+    # clean subdirectories first
+    for $dir (@{$self->{DIR}}) {
+	push @m, "\t-cd $dir && test -f $self->{MAKEFILE} && \$(MAKE) clean\n";
+    }
+
+    my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
+    push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
+    push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
+			 perlmain.c mon.out core so_locations pm_to_blib
+			 *~ */*~ */*/*~ *$(OBJ_EXT) *$(LIB_EXT) perl.exe
+			 $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def
+			 $(BASEEXT).exp
+			]);
+    push @m, "\t-$self->{RM_RF} @otherfiles\n";
+    # See realclean and ext/utils/make_ext for usage of Makefile.old
+    push(@m,
+	 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old 2>/dev/null\n");
+    push(@m,
+	 "\t$attribs{POSTOP}\n")   if $attribs{POSTOP};
+    join("", @m);
 }
 
-=item exescan
+=item const_cccmd (o)
 
-Deprecated method. Use libscan instead.
+Returns the full compiler call for C programs and stores the
+definition in CONST_CCCMD.
 
 =cut
 
-sub exescan {
-    my($self,$path) = @_;
-    $path;
+sub const_cccmd {
+    my($self,$libperl)=@_;
+    return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
+    return '' unless $self->needs_linking();
+    return $self->{CONST_CCCMD} =
+	q{CCCMD = $(CC) -c $(INC) $(CCFLAGS) $(OPTIMIZE) \\
+	$(PERLTYPE) $(LARGE) $(SPLIT) $(DEFINE_VERSION) \\
+	$(XS_DEFINE_VERSION)};
 }
 
-=item lsdir
+=item const_config (o)
 
-Takes as arguments a directory name and a regular expression. Returns
-all entries in the directory that match the regular expression.
+Defines a couple of constants in the Makefile that are imported from
+%Config.
 
 =cut
 
-sub lsdir {
+sub const_config {
+# --- Constants Sections ---
+
     my($self) = shift;
-    my($dir, $regex) = @_;
-    my(@ls);
-    my $dh = new DirHandle;
-    $dh->open($dir || ".") or return ();
-    @ls = $dh->read;
-    $dh->close;
-    @ls = grep(/$regex/, @ls) if $regex;
-    @ls;
+    my(@m,$m);
+    push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
+    push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
+    my(%once_only);
+    foreach $m (@{$self->{CONFIG}}){
+	# SITE*EXP macros are defined in &constants; avoid duplicates here
+	next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
+	push @m, "\U$m\E = ".$self->{uc $m}."\n";
+	$once_only{$m} = 1;
+    }
+    join('', @m);
 }
 
-=item path
+=item const_loadlibs (o)
 
-Takes no argument, returns the environment variable PATH as an array.
+Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
+L<ExtUtils::Liblist> for details.
 
 =cut
 
-sub path {
+sub const_loadlibs {
+    my($self) = shift;
+    return "" unless $self->needs_linking;
+    my @m;
+    push @m, qq{
+# $self->{NAME} might depend on some other libraries:
+# See ExtUtils::Liblist for details
+#
+};
+    my($tmp);
+    for $tmp (qw/
+	 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
+	 /) {
+	next unless defined $self->{$tmp};
+	push @m, "$tmp = $self->{$tmp}\n";
+    }
+    return join "", @m;
+}
+
+=item constants (o)
+
+Initializes lots of constants and .SUFFIXES and .PHONY
+
+=cut
+
+sub constants {
     my($self) = @_;
-    my $path_sep = $Is_OS2 ? ";" : ":";
-    my $path = $ENV{PATH};
-    $path =~ s:\\:/:g if $Is_OS2;
-    my @path = split $path_sep, $path;
+    my(@m,$tmp);
+
+    for $tmp (qw/
+
+	      AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION
+	      VERSION_SYM XS_VERSION INST_BIN INST_EXE INST_LIB
+	      INST_ARCHLIB INST_SCRIPT PREFIX INSTALLDIRS
+	      INSTALLPRIVLIB INSTALLARCHLIB INSTALLSITELIB
+	      INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
+	      PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
+	      FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC
+	      PERL_INC PERL FULLPERL
+
+	      / ) {
+	next unless defined $self->{$tmp};
+	push @m, "$tmp = $self->{$tmp}\n";
+    }
+
+    push @m, qq{
+VERSION_MACRO = VERSION
+DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
+XS_VERSION_MACRO = XS_VERSION
+XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
+};
+
+    push @m, qq{
+MAKEMAKER = $INC{'ExtUtils/MakeMaker.pm'}
+MM_VERSION = $ExtUtils::MakeMaker::VERSION
+};
+
+    push @m, q{
+# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
+# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
+# ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)  !!! Deprecated from MM 5.32  !!!
+# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
+# DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
+};
+
+    for $tmp (qw/
+	      FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
+	      LDFROM LINKTYPE
+	      /	) {
+	next unless defined $self->{$tmp};
+	push @m, "$tmp = $self->{$tmp}\n";
+    }
+
+    push @m, "
+# Handy lists of source code files:
+XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
+C_FILES = ".join(" \\\n\t", @{$self->{C}})."
+O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
+H_FILES = ".join(" \\\n\t", @{$self->{H}})."
+MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
+MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
+";
+
+    for $tmp (qw/
+	      INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
+	      /) {
+	next unless defined $self->{$tmp};
+	push @m, "$tmp = $self->{$tmp}\n";
+    }
+
+    push @m, q{
+.NO_CONFIG_REC: Makefile
+} if $ENV{CLEARCASE_ROOT};
+
+    # why not q{} ? -- emacs
+    push @m, qq{
+# work around a famous dec-osf make(1) feature(?):
+makemakerdflt: all
+
+.SUFFIXES: .xs .c .C .cpp .cxx .cc \$(OBJ_EXT)
+
+# Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
+# some make implementations will delete the Makefile when we rebuild it. Because
+# we call false(1) when we rebuild it. So make(1) is not completely wrong when it
+# does so. Our milage may vary.
+# .PRECIOUS: Makefile    # seems to be not necessary anymore
+
+.PHONY: all config static dynamic test linkext manifest
+
+# Where is the Config information that we are using/depend on
+CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
+};
+
+    my @parentdir = split(/::/, $self->{PARENT_NAME});
+    push @m, q{
+# Where to put things:
+INST_LIBDIR      = }. $self->catdir('$(INST_LIB)',@parentdir)        .q{
+INST_ARCHLIBDIR  = }. $self->catdir('$(INST_ARCHLIB)',@parentdir)    .q{
+
+INST_AUTODIR     = }. $self->catdir('$(INST_LIB)','auto','$(FULLEXT)')       .q{
+INST_ARCHAUTODIR = }. $self->catdir('$(INST_ARCHLIB)','auto','$(FULLEXT)')   .q{
+};
+
+    if ($self->has_link_code()) {
+	push @m, '
+INST_STATIC  = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
+INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
+INST_BOOT    = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
+';
+    } else {
+	push @m, '
+INST_STATIC  =
+INST_DYNAMIC =
+INST_BOOT    =
+';
+    }
+
+    if ($Is_OS2) {
+	$tmp = "$self->{BASEEXT}.def";
+    } else {
+	$tmp = "";
+    }
+    push @m, "
+EXPORT_LIST = $tmp
+";
+
+    if ($Is_OS2) {
+	$tmp = "\$(PERL_INC)/libperl\$(LIB_EXT)";
+    } else {
+	$tmp = "";
+    }
+    push @m, "
+PERL_ARCHIVE = $tmp
+";
+
+#    push @m, q{
+#INST_PM = }.join(" \\\n\t", sort values %{$self->{PM}}).q{
+#
+#PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
+#};
+
+    push @m, q{
+TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
+
+PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
+};
+
+    join('',@m);
 }
 
-=item replace_manpage_separator
+=item depend (o)
 
-Takes the name of a package, which may be a nested package, in the
-form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
+Same as macro for the depend attribute.
 
 =cut
 
-sub replace_manpage_separator {
-    my($self,$man) = @_;
-    $man =~ s,/+,::,g;
-    $man;
+sub depend {
+    my($self,%attribs) = @_;
+    my(@m,$key,$val);
+    while (($key,$val) = each %attribs){
+	last unless defined $key;
+	push @m, "$key: $val\n";
+    }
+    join "", @m;
 }
 
-=item file_name_is_absolute
+=item dir_target (o)
 
-Takes as argument a path and returns true, it it is an absolute path.
+Takes an array of directories that need to exist and returns a
+Makefile entry for a .exists file in these directories. Returns
+nothing, if the entry has already been processed. We're helpless
+though, if the same directory comes as $(FOO) _and_ as "bar". Both of
+them get an entry, that's why we use "::".
 
 =cut
 
-sub file_name_is_absolute {
-    my($self,$file) = @_;
-    $file =~ m:^/: ;
+sub dir_target {
+# --- Make-Directories section (internal method) ---
+# dir_target(@array) returns a Makefile entry for the file .exists in each
+# named directory. Returns nothing, if the entry has already been processed.
+# We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
+# Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
+# prerequisite, because there has to be one, something that doesn't change
+# too often :)
+
+    my($self,@dirs) = @_;
+    my(@m,$dir);
+    foreach $dir (@dirs) {
+	my($src) = $self->catfile($self->{PERL_INC},'perl.h');
+	my($targ) = $self->catfile($dir,'.exists');
+	my($targdir) = $targ;       # Necessary because catfile may have
+	$targdir =~ s:/?.exists$::; # adapted syntax of $dir to target OS
+	next if $self->{DIR_TARGET}{$self}{$targdir}++;
+	push @m, qq{
+$targ :: $src
+	$self->{NOECHO}\$(MKPATH) $targdir
+	$self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
+};
+	push(@m,qq{
+	-$self->{NOECHO}\$(CHMOD) 755 $targdir
+}) unless $Is_VMS;
+    }
+    join "", @m;
 }
 
-=item prefixify
+=item dist (o)
 
-Check a path variable in $self from %Config, if it contains a prefix,
-and replace it with another one.
+Defines a lot of macros for distribution support.
 
-Takes as arguments an attribute name, a search prefix and a
-replacement prefix. Changes the attribute in the object.
+=cut
+
+sub dist {
+    my($self, %attribs) = @_;
+
+    my(@m);
+    # VERSION should be sanitised before use as a file name
+    my($version)  = $attribs{VERSION}  || '$(VERSION)';
+    my($name)     = $attribs{NAME}     || '$(DISTNAME)';
+    my($tar)      = $attribs{TAR}      || 'tar';        # eg /usr/bin/gnutar
+    my($tarflags) = $attribs{TARFLAGS} || 'cvf';
+    my($zip)      = $attribs{ZIP}      || 'zip';        # eg pkzip Yuck!
+    my($zipflags) = $attribs{ZIPFLAGS} || '-r';
+    my($compress) = $attribs{COMPRESS} || 'compress';   # eg gzip
+    my($suffix)   = $attribs{SUFFIX}   || '.Z';          # eg .gz
+    my($shar)     = $attribs{SHAR}     || 'shar';       # eg "shar --gzip"
+    my($preop)    = $attribs{PREOP}    || "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
+    my($postop)   = $attribs{POSTOP}   || "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
+
+    my($to_unix)  = $attribs{TO_UNIX} || ($Is_OS2
+					  ? "$self->{NOECHO}"
+					  . 'test -f tmp.zip && $(RM) tmp.zip;'
+					  . ' $(ZIP) -ll -mr tmp.zip $(DISTVNAME) && unzip -o tmp.zip && $(RM) tmp.zip'
+					  : "$self->{NOECHO}\$(NOOP)");
+
+    my($ci)       = $attribs{CI}       || 'ci -u';
+    my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
+    my($dist_cp)  = $attribs{DIST_CP}  || 'best';
+    my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
+
+    push @m, "
+DISTVNAME = ${name}-$version
+TAR  = $tar
+TARFLAGS = $tarflags
+ZIP  = $zip
+ZIPFLAGS = $zipflags
+COMPRESS = $compress
+SUFFIX = $suffix
+SHAR = $shar
+PREOP = $preop
+POSTOP = $postop
+TO_UNIX = $to_unix
+CI = $ci
+RCS_LABEL = $rcs_label
+DIST_CP = $dist_cp
+DIST_DEFAULT = $dist_default
+";
+    join "", @m;
+}
+
+=item dist_basics (o)
+
+Defines the targets distclean, distcheck, skipcheck, manifest.
 
 =cut
 
-sub prefixify {
-    my($self,$var,$sprefix,$rprefix) = @_;
-    $self->{uc $var} ||= $Config{lc $var};
-    $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
-    $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
+sub dist_basics {
+    my($self) = shift;
+    my @m;
+    push @m, q{
+distclean :: realclean distcheck
+};
+
+    push @m, q{
+distcheck :
+	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&fullcheck";' \\
+		-e 'fullcheck();'
+};
+
+    push @m, q{
+skipcheck :
+	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&skipcheck";' \\
+		-e 'skipcheck();'
+};
+
+    push @m, q{
+manifest :
+	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&mkmanifest";' \\
+		-e 'mkmanifest();'
+};
+    join "", @m;
 }
 
-=item maybe_command_in_dirs
+=item dist_ci (o)
 
-method under development. Not yet used. Ask Ilya :-)
+Defines a check in target for RCS.
 
 =cut
 
-sub maybe_command_in_dirs {	# $ver is optional argument if looking for perl
-# Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
-    my($self, $names, $dirs, $trace, $ver) = @_;
+sub dist_ci {
+    my($self) = shift;
+    my @m;
+    push @m, q{
+ci :
+	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&maniread";' \\
+		-e '@all = keys %{ maniread() };' \\
+		-e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
+		-e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
+};
+    join "", @m;
+}
+
+=item dist_core (o)
+
+Defeines the targets dist, tardist, zipdist, uutardist, shdist
+
+=cut
+
+sub dist_core {
+    my($self) = shift;
+    my @m;
+    push @m, q{
+dist : $(DIST_DEFAULT)
+	}.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
+	    -e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
+
+tardist : $(DISTVNAME).tar$(SUFFIX)
+
+zipdist : $(DISTVNAME).zip
+
+$(DISTVNAME).tar$(SUFFIX) : distdir
+	$(PREOP)
+	$(TO_UNIX)
+	$(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
+	$(RM_RF) $(DISTVNAME)
+	$(COMPRESS) $(DISTVNAME).tar
+	$(POSTOP)
+
+$(DISTVNAME).zip : distdir
+	$(PREOP)
+	$(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
+	$(RM_RF) $(DISTVNAME)
+	$(POSTOP)
+
+uutardist : $(DISTVNAME).tar$(SUFFIX)
+	uuencode $(DISTVNAME).tar$(SUFFIX) \\
+		$(DISTVNAME).tar$(SUFFIX) > \\
+		$(DISTVNAME).tar$(SUFFIX)_uu
+
+shdist : distdir
+	$(PREOP)
+	$(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
+	$(RM_RF) $(DISTVNAME)
+	$(POSTOP)
+};
+    join "", @m;
+}
+
+=item dist_dir (o)
+
+Defines the scratch directory target that will hold the distribution
+before tar-ing (or shar-ing).
+
+=cut
+
+sub dist_dir {
+    my($self) = shift;
+    my @m;
+    push @m, q{
+distdir :
+	$(RM_RF) $(DISTVNAME)
+	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Manifest=manicopy,maniread \\
+		-e 'manicopy(maniread(),"$(DISTVNAME)", "$(DIST_CP)");'
+};
+    join "", @m;
+}
+
+=item dist_test (o)
+
+Defines a target that produces the distribution in the
+scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
+subdirectory.
+
+=cut
+
+sub dist_test {
+    my($self) = shift;
+    my @m;
+    push @m, q{
+disttest : distdir
+	cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
+	cd $(DISTVNAME) && $(MAKE)
+	cd $(DISTVNAME) && $(MAKE) test
+};
+    join "", @m;
+}
+
+=item dlsyms (o)
+
+Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
+files.
+
+=cut
+
+sub dlsyms {
+    my($self,%attribs) = @_;
+
+    return '' unless ($^O eq 'aix' && $self->needs_linking() );
+
+    my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
+    my($vars)  = $attribs{DL_VARS} || $self->{DL_VARS} || [];
+    my(@m);
+
+    push(@m,"
+dynamic :: $self->{BASEEXT}.exp
+
+") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
+
+    push(@m,"
+static :: $self->{BASEEXT}.exp
+
+") unless $self->{SKIPHASH}{'static'};  # we avoid a warning if we tick them
+
+    push(@m,"
+$self->{BASEEXT}.exp: Makefile.PL
+",'	$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
+	Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
+	neatvalue($funcs),', "DL_VARS" => ', neatvalue($vars), ');\'
+');
+
+    join('',@m);
+}
+
+=item dynamic (o)
+
+Defines the dynamic target.
+
+=cut
+
+sub dynamic {
+# --- Dynamic Loading Sections ---
+
+    my($self) = shift;
+    '
+## $(INST_PM) has been moved to the all: target.
+## It remains here for awhile to allow for old usage: "make dynamic"
+#dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
+dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
+	'.$self->{NOECHO}.'$(NOOP)
+';
+}
+
+=item dynamic_bs (o)
+
+Defines targets for bootstrap files.
+
+=cut
+
+sub dynamic_bs {
+    my($self, %attribs) = @_;
+    return '
+BOOTSTRAP =
+' unless $self->has_link_code();
+
+    return '
+BOOTSTRAP = '."$self->{BASEEXT}.bs".'
+
+# As Mkbootstrap might not write a file (if none is required)
+# we use touch to prevent make continually trying to remake it.
+# The DynaLoader only reads a non-empty file.
+$(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
+	'.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
+	'.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
+		-e \'use ExtUtils::Mkbootstrap;\' \
+		-e \'Mkbootstrap("$(BASEEXT)","$(BSLOADLIBS)");\'
+	'.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
+	$(CHMOD) 644 $@
+
+$(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
+	'."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
+	-'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
+	$(CHMOD) 644 $@
+';
+}
+
+=item dynamic_lib (o)
+
+Defines how to produce the *.so (or equivalent) files.
+
+=cut
+
+sub dynamic_lib {
+    my($self, %attribs) = @_;
+    return '' unless $self->needs_linking(); #might be because of a subdir
+
+    return '' unless $self->has_link_code;
+
+    my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
+    my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
+    my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
+    my($ldfrom) = '$(LDFROM)';
+    $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
+    my(@m);
+    push(@m,'
+# This section creates the dynamically loadable $(INST_DYNAMIC)
+# from $(OBJECT) and possibly $(MYEXTLIB).
+ARMAYBE = '.$armaybe.'
+OTHERLDFLAGS = '.$otherldflags.'
+INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
+
+$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
+');
+    if ($armaybe ne ':'){
+	$ldfrom = 'tmp$(LIB_EXT)';
+	push(@m,'	$(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
+	push(@m,'	$(RANLIB) '."$ldfrom\n");
+    }
+    $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
+    push(@m,'	LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ $(LDDLFLAGS) '.$ldfrom.
+		' $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) $(EXPORT_LIST)');
+    push @m, '
+	$(CHMOD) 755 $@
+';
+
+    push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
+    join('',@m);
+}
+
+=item exescan
+
+Deprecated method. Use libscan instead.
+
+=cut
+
+sub exescan {
+    my($self,$path) = @_;
+    $path;
+}
+
+=item extliblist
+
+Called by init_others, and calls ext ExtUtils::Liblist. See
+L<ExtUtils::Liblist> for details.
+
+=cut
+
+sub extliblist {
+    my($self,$libs) = @_;
+    require ExtUtils::Liblist;
+    $self->ext($libs, $Verbose);
+}
+
+=item file_name_is_absolute
+
+Takes as argument a path and returns true, it it is an absolute path.
+
+=cut
+
+sub file_name_is_absolute {
+    my($self,$file) = @_;
+    $file =~ m:^/: ;
+}
+
+=item find_perl
+
+Finds the executables PERL and FULLPERL
+
+=cut
+
+sub find_perl {
+    my($self, $ver, $names, $dirs, $trace) = @_;
     my($name, $dir);
+    if ($trace >= 2){
+	print "Looking for perl $ver by these names:
+@$names
+in these dirs:
+@$dirs
+";
+    }
     foreach $dir (@$dirs){
 	next unless defined $dir; # $self->{PERL_SRC} may be undefined
 	foreach $name (@$names){
-	    my($abs,$tryabs);
-	    if ($self->file_name_is_absolute($name)) {
+	    my $abs;
+	    if ($self->file_name_is_absolute($name)) { # /foo/bar
 		$abs = $name;
-	    } elsif ($name =~ m|/|) {
-		$abs = $self->catfile(".", $name); # not absolute
-	    } else {
+	    } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # foo
 		$abs = $self->catfile($dir, $name);
+	    } else { # foo/bar
+		$abs = $self->canonpath($self->catfile($self->curdir, $name));
 	    }
-	    print "Checking $abs for $name\n" if ($trace >= 2);
-	    next unless $tryabs = $self->maybe_command($abs);
-	    print "Substituting $tryabs instead of $abs\n"
-		if ($trace >= 2 and $tryabs ne $abs);
-	    $abs = $tryabs;
-	    if (defined $ver) {
-		print "Executing $abs\n" if ($trace >= 2);
-		if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
-		    print "Using PERL=$abs\n" if $trace;
-		    return $abs;
-		}
-	    } else { # Do not look for perl
-		return $abs;
+	    print "Checking $abs\n" if ($trace >= 2);
+	    next unless $self->maybe_command($abs);
+	    print "Executing $abs\n" if ($trace >= 2);
+	    if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
+	        print "Using PERL=$abs\n" if $trace;
+	        return $abs;
 	    }
 	}
     }
+    print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
+    0; # false and not empty
 }
 
-=item maybe_command
-
-Returns true, if the argument is likely to be a command.
-
-=cut
+=head2 Methods to actually produce chunks of text for the Makefile
 
-sub maybe_command {
-    my($self,$file) = @_;
-    return $file if -x $file && ! -d $file;
-    return;
-}
+The methods here are called in the order specified by
+@ExtUtils::MakeMaker::MM_Sections. This manpage reflects the order as
+well as possible. Some methods call each other, so in doubt refer to
+the code.
 
-=item perl_script
+=item force (o)
 
-Returns true, if the argument is likely to be a perl script. On
-MM_Unix this is true for any ordinary, readable file.
+Just writes FORCE:
 
 =cut
 
-sub perl_script {
-    my($self,$file) = @_;
-    return 1 if -r $file && ! -d $file;
-    return;
+sub force {
+    my($self) = shift;
+    '# Phony target to force checking subdirectories.
+FORCE:
+';
 }
 
 =item guess_name
@@ -407,16 +1108,233 @@ NAME attribute.
 sub guess_name {
     my($self) = @_;
     use Cwd 'cwd';
-    my $name = cwd();
-    $name =~ s:.*/:: unless ($name =~ s:^.*/ext/::);
-    $name =~ s#/#::#g;
-    $name =~  s#[\-_][\d.\-]+$##;  # this is new with MM 5.00
+    my $name = basename(cwd());
+    $name =~ s|[\-_][\d\.\-]+$||;   # this is new with MM 5.00, we
+                                    # strip minus or underline
+                                    # followed by a float or some such
+    print "Warning: Guessing NAME [$name] from current directory name.\n";
     $name;
 }
 
+=item has_link_code
+
+Returns true if C, XS, MYEXTLIB or similar objects exist within this
+object that need a compiler. Does not descend into subdirectories as
+needs_linking() does.
+
+=cut
+
+sub has_link_code {
+    my($self) = shift;
+    return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
+    if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
+	$self->{HAS_LINK_CODE} = 1;
+	return 1;
+    }
+    return $self->{HAS_LINK_CODE} = 0;
+}
+
+=item init_dirscan
+
+Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
+
+=cut
+
+sub init_dirscan {	# --- File and Directory Lists (.xs .pm .pod etc)
+    my($self) = @_;
+    my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
+    local(%pm); #the sub in find() has to see this hash
+    $ignore{'test.pl'} = 1;
+    $ignore{'makefile.pl'} = 1 if $Is_VMS;
+    foreach $name ($self->lsdir($self->curdir)){
+	next if $name eq $self->curdir or $name eq $self->updir or $ignore{$name};
+	next unless $self->libscan($name);
+	if (-d $name){
+	    next if -l $name; # We do not support symlinks at all
+	    $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
+	} elsif ($name =~ /\.xs$/){
+	    my($c); ($c = $name) =~ s/\.xs$/.c/;
+	    $xs{$name} = $c;
+	    $c{$c} = 1;
+	} elsif ($name =~ /\.c(pp|xx|c)?$/i){  # .c .C .cpp .cxx .cc
+	    $c{$name} = 1
+		unless $name =~ m/perlmain\.c/; # See MAP_TARGET
+	} elsif ($name =~ /\.h$/i){
+	    $h{$name} = 1;
+	} elsif ($name =~ /\.(p[ml]|pod)$/){
+	    $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
+	} elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
+	    ($pl_files{$name} = $name) =~ s/\.PL$// ;
+	} elsif ($Is_VMS && $name =~ /\.pl$/ && $name ne 'makefile.pl' &&
+	         $name ne 'test.pl') {  # case-insensitive filesystem
+	    ($pl_files{$name} = $name) =~ s/\.pl$// ;
+	}
+    }
+
+    # Some larger extensions often wish to install a number of *.pm/pl
+    # files into the library in various locations.
+
+    # The attribute PMLIBDIRS holds an array reference which lists
+    # subdirectories which we should search for library files to
+    # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].  We
+    # recursively search through the named directories (skipping any
+    # which don't exist or contain Makefile.PL files).
+
+    # For each *.pm or *.pl file found $self->libscan() is called with
+    # the default installation path in $_[1]. The return value of
+    # libscan defines the actual installation location.  The default
+    # libscan function simply returns the path.  The file is skipped
+    # if libscan returns false.
+
+    # The default installation location passed to libscan in $_[1] is:
+    #
+    #  ./*.pm		=> $(INST_LIBDIR)/*.pm
+    #  ./xyz/...	=> $(INST_LIBDIR)/xyz/...
+    #  ./lib/...	=> $(INST_LIB)/...
+    #
+    # In this way the 'lib' directory is seen as the root of the actual
+    # perl library whereas the others are relative to INST_LIBDIR
+    # (which includes PARENT_NAME). This is a subtle distinction but one
+    # that's important for nested modules.
+
+    $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
+	unless $self->{PMLIBDIRS};
+
+    #only existing directories that aren't in $dir are allowed
+
+    # Avoid $_ wherever possible:
+    # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
+    my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
+    my ($pmlibdir);
+    @{$self->{PMLIBDIRS}} = ();
+    foreach $pmlibdir (@pmlibdirs) {
+	-d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
+    }
+
+    if (@{$self->{PMLIBDIRS}}){
+	print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
+	    if ($Verbose >= 2);
+	require File::Find;
+	File::Find::find(sub {
+	    if (-d $_){
+		if ($_ eq "CVS" || $_ eq "RCS"){
+		    $File::Find::prune = 1;
+		}
+		return;
+	    }
+	    my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
+	    my($striplibpath,$striplibname);
+	    $prefix =  '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:);
+	    ($striplibname,$striplibpath) = fileparse($striplibpath);
+	    my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
+	    local($_) = $inst; # for backwards compatibility
+	    $inst = $self->libscan($inst);
+	    print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
+	    return unless $inst;
+	    $pm{$path} = $inst;
+	}, @{$self->{PMLIBDIRS}});
+    }
+
+    $self->{DIR} = [sort keys %dir] unless $self->{DIR};
+    $self->{XS}  = \%xs             unless $self->{XS};
+    $self->{PM}  = \%pm             unless $self->{PM};
+    $self->{C}   = [sort keys %c]   unless $self->{C};
+    my(@o_files) = @{$self->{C}};
+    $self->{O_FILES} = [grep s/\.c(pp|xx|c)?$/$self->{OBJ_EXT}/i, @o_files] ;
+    $self->{H}   = [sort keys %h]   unless $self->{H};
+    $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
+
+    # Set up names of manual pages to generate from pods
+    if ($self->{MAN1PODS}) {
+    } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
+    	$self->{MAN1PODS} = {};
+    } else {
+	my %manifypods = ();
+	if ( exists $self->{EXE_FILES} ) {
+	    foreach $name (@{$self->{EXE_FILES}}) {
+#		use FileHandle ();
+#		my $fh = new FileHandle;
+		local *FH;
+		my($ispod)=0;
+		# one day test, if $/ can be set to '' safely (is the bug fixed that was in 5.001m?)
+#		if ($fh->open("<$name")) {
+		if (open(FH,"<$name")) {
+#		    while (<$fh>) {
+		    while (<FH>) {
+			if (/^=head1\s+\w+/) {
+			    $ispod=1;
+			    last;
+			}
+		    }
+#		    $fh->close;
+		    close FH;
+		} else {
+		    # If it doesn't exist yet, we assume, it has pods in it
+		    $ispod = 1;
+		}
+		if( $ispod ) {
+		    $manifypods{$name} = $self->catfile('$(INST_MAN1DIR)',basename($name).'.$(MAN1EXT)');
+		}
+	    }
+	}
+	$self->{MAN1PODS} = \%manifypods;
+    }
+    if ($self->{MAN3PODS}) {
+    } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
+    	$self->{MAN3PODS} = {};
+    } else {
+	my %manifypods = (); # we collect the keys first, i.e. the files
+			     # we have to convert to pod
+	foreach $name (keys %{$self->{PM}}) {
+	    if ($name =~ /\.pod$/ ) {
+		$manifypods{$name} = $self->{PM}{$name};
+	    } elsif ($name =~ /\.p[ml]$/ ) {
+#		use FileHandle ();
+#		my $fh = new FileHandle;
+		local *FH;
+		my($ispod)=0;
+#		$fh->open("<$name");
+		if (open(FH,"<$name")) {
+		    #		while (<$fh>) {
+		    while (<FH>) {
+			if (/^=head1\s+\w+/) {
+			    $ispod=1;
+			    last;
+			}
+		    }
+		    #		$fh->close;
+		    close FH;
+		} else {
+		    $ispod = 1;
+		}
+		if( $ispod ) {
+		    $manifypods{$name} = $self->{PM}{$name};
+		}
+	    }
+	}
+
+	# Remove "Configure.pm" and similar, if it's not the only pod listed
+	# To force inclusion, just name it "Configure.pod", or override MAN3PODS
+	foreach $name (keys %manifypods) {
+	    if ($name =~ /(config|setup).*\.pm/i) {
+		delete $manifypods{$name};
+		next;
+	    }
+	    my($manpagename) = $name;
+	    unless ($manpagename =~ s!^\W*lib\W+!!) { # everything below lib is ok
+		$manpagename = $self->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
+	    }
+	    $manpagename =~ s/\.p(od|m|l)$//;
+	    $manpagename = $self->replace_manpage_separator($manpagename);
+	    $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
+	}
+	$self->{MAN3PODS} = \%manifypods;
+    }
+}
+
 =item init_main
 
-Initializes NAME, FULLEXT, BASEEXT, ROOTEXT, DLBASE, PERL_SRC,
+Initializes NAME, FULLEXT, BASEEXT, PARENT_NAME, DLBASE, PERL_SRC,
 PERL_LIB, PERL_ARCHLIB, PERL_INC, INSTALLDIRS, INST_*, INSTALL*,
 PREFIX, CONFIG, AR, AR_STATIC_ARGS, LD, OBJ_EXT, LIB_EXT, MAP_TARGET,
 LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
@@ -425,19 +1343,19 @@ LIBPERL_A, VERSION_FROM, VERSION, DISTNAME, VERSION_SYM.
 
 sub init_main {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 
     # --- Initialize Module Name and Paths
 
-    # NAME    = The perl module name for this extension (eg DBD::Oracle).
-    # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
-    # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
-    # ROOTEXT = Directory part of FULLEXT with leading /.
-    ($self->{FULLEXT} =
-     $self->{NAME}) =~ s!::!/!g ;		             #eg. BSD/Foo/Socket
+    # NAME    = Foo::Bar::Oracle
+    # FULLEXT = Foo/Bar/Oracle
+    # BASEEXT = Oracle
+    # ROOTEXT = Directory part of FULLEXT with leading /. !!! Deprecated from MM 5.32 !!!
+    # PARENT_NAME = Foo::Bar
+### Only UNIX:
+###    ($self->{FULLEXT} =
+###     $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
+    $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
+
 
     # Copied from DynaLoader:
 
@@ -454,20 +1372,20 @@ sub init_main {
     }
 
 
-    ($self->{BASEEXT} =
-     $self->{NAME}) =~ s!.*::!! ;		             #eg. Socket
+    ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!([\w:]+::)?(\w+)$! ;
 
     if (defined &DynaLoader::mod2fname or $Is_OS2) {
 	# As of 5.001m, dl_os2 appends '_'
-	$self->{DLBASE} = $modfname;                    #eg. Socket_
+	$self->{DLBASE} = $modfname;
     } else {
 	$self->{DLBASE} = '$(BASEEXT)';
     }
 
-    ($self->{ROOTEXT} =
-     $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ;      #eg. /BSD/Foo
 
-    $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
+    ### ROOTEXT deprecated from MM 5.32
+###    ($self->{ROOTEXT} =
+###     $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ;      #eg. /BSD/Foo
+###    $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
 
 
     # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
@@ -478,10 +1396,14 @@ sub init_main {
 
     unless ($self->{PERL_SRC}){
 	my($dir);
-	foreach $dir (qw(.. ../.. ../../..)){
-	    if ( -f "$dir/config.sh"
-		&& -f "$dir/perl.h"
-		&& -f "$dir/lib/Exporter.pm") {
+	foreach $dir ($self->updir(),$self->catdir($self->updir(),$self->updir()),$self->catdir($self->updir(),$self->updir(),$self->updir())){
+	    if (
+		-f $self->catfile($dir,"config.sh")
+		&&
+		-f $self->catfile($dir,"perl.h")
+		&&
+		-f $self->catfile($dir,"lib","Exporter.pm")
+	       ) {
 		$self->{PERL_SRC}=$dir ;
 		last;
 	    }
@@ -492,7 +1414,8 @@ sub init_main {
 	$self->{PERL_ARCHLIB} = $self->{PERL_LIB};
 	$self->{PERL_INC}     = $self->{PERL_SRC};
 	# catch a situation that has occurred a few times in the past:
-	warn <<EOM unless (-s $self->catfile($self->{PERL_SRC},'cflags') or $Is_VMS && -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt'));
+
+	warn <<EOM unless (-s $self->catfile($self->{PERL_SRC},'cflags') or $Is_VMS && -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt') or $Is_Mac);
 You cannot build extensions below the perl source tree after executing
 a 'make clean' in the perl source tree.
 
@@ -547,11 +1470,15 @@ EOM
 	if (defined $self->{PERL_SRC} and $self->{INSTALLDIRS} eq "perl") {
 	    $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
 	} else {
-	    $self->{INST_LIB} = $self->catdir(".","blib","lib");
+	    $self->{INST_LIB} = $self->catdir($self->curdir,"blib","lib");
 	}
     }
-    $self->{INST_ARCHLIB} ||= $self->catdir(".","blib","arch");
-    $self->{INST_EXE} ||= $self->catdir('.','blib','bin');
+    $self->{INST_ARCHLIB} ||= $self->catdir($self->curdir,"blib","arch");
+    $self->{INST_BIN} ||= $self->catdir($self->curdir,'blib','bin');
+
+    # INST_EXE is deprecated, should go away March '97
+    $self->{INST_EXE} ||= $self->catdir($self->curdir,'blib','script');
+    $self->{INST_SCRIPT} ||= $self->catdir($self->curdir,'blib','script');
 
     # The user who requests an installation directory explicitly
     # should not have to tell us a architecture installation directory
@@ -589,8 +1516,13 @@ EOM
 	$self->{PREFIX} = $prefix;
     }
     my($install_variable);
-    for $install_variable (qw/INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN INSTALLMAN1DIR
-			   INSTALLMAN3DIR INSTALLSITELIB INSTALLSITEARCH/) {
+    for $install_variable (qw/
+
+			   INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN
+			   INSTALLMAN1DIR INSTALLMAN3DIR INSTALLSCRIPT
+			   INSTALLSITELIB INSTALLSITEARCH
+
+			   /) {
 	$self->prefixify($install_variable,$prefix,q[$(PREFIX)]);
     }
 
@@ -603,7 +1535,7 @@ EOM
 	if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
 	    $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
 	} else {
-	    $self->{INST_MAN1DIR} = $self->catdir('.','blib','man1');
+	    $self->{INST_MAN1DIR} = $self->catdir($self->curdir,'blib','man1');
 	}
     }
     $self->{MAN1EXT} ||= $Config::Config{man1ext};
@@ -614,7 +1546,7 @@ EOM
 	if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
 	    $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
 	} else {
-	    $self->{INST_MAN3DIR} = $self->catdir('.','blib','man3');
+	    $self->{INST_MAN3DIR} = $self->catdir($self->curdir,'blib','man3');
 	}
     }
     $self->{MAN3EXT} ||= $Config::Config{man3ext};
@@ -662,42 +1594,17 @@ EOM
     # Determine VERSION and VERSION_FROM
     ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
     if ($self->{VERSION_FROM}){
-#	use FileHandle ();
-#	my $fh = new FileHandle;
-	local *FH;
-#	$fh->open($self->{VERSION_FROM}) or die "Could not open '$self->{VERSION_FROM}' (attribute VERSION_FROM): $!";
-	open(FH,$self->{VERSION_FROM}) or
-	    die "Could not open '$self->{VERSION_FROM}' (attribute VERSION_FROM): $!";
-#	while (<$fh>) {
-	while (<FH>) {
-	    chop;
-	    next unless /\$([\w:]*\bVERSION)\b.*=/;
-	    local $ExtUtils::MakeMaker::module_version_variable = $1;
-	    my($eval) = "$_;";
-	    eval $eval;
-	    die "Could not eval '$eval': $@" if $@;
-	    if ($self->{VERSION} = $ {$ExtUtils::MakeMaker::module_version_variable}){
-		print "$self->{NAME} VERSION is $self->{VERSION} (from $self->{VERSION_FROM})\n" if $Verbose;
-	    } else {
-		# XXX this should probably croak
-		print "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n";
-	    }
-	    last;
-	}
-#	close $fh;
-	close FH;
+	$self->{VERSION} = $self->parse_version($self->{VERSION_FROM}) or
+	    Carp::carp "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n"
     }
 
-    # if your FOO.pm says
-    #	$VERSION = substr(q$Revision: 1.14 $, 10);
-    # then MM says something like
-    #	-DXS_VERSION=\"n.nn \"
+    # strip blanks
     if ($self->{VERSION}) {
 	$self->{VERSION} =~ s/^\s+//;
 	$self->{VERSION} =~ s/\s+$//;
     }
 
-    $self->{VERSION} = "0.10" unless $self->{VERSION};
+    $self->{VERSION} ||= "0.10";
     ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
 
 
@@ -727,213 +1634,6 @@ EOM
 	unless ($self->{FULLPERL});
 }
 
-=item init_dirscan
-
-Initializes DIR, XS, PM, C, O_FILES, H, PL_FILES, MAN*PODS, EXE_FILES.
-
-=cut
-
-sub init_dirscan {	# --- File and Directory Lists (.xs .pm .pod etc)
-    my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
-    local(%pm); #the sub in find() has to see this hash
-    $ignore{'test.pl'} = 1;
-    $ignore{'makefile.pl'} = 1 if $Is_VMS;
-    foreach $name ($self->lsdir(".")){
-	next if ($name =~ /^\./ or $ignore{$name});
-	next unless $self->libscan($name);
-	if (-d $name){
-	    $dir{$name} = $name if (-f "$name/Makefile.PL");
-	} elsif ($name =~ /\.xs$/){
-	    my($c); ($c = $name) =~ s/\.xs$/.c/;
-	    $xs{$name} = $c;
-	    $c{$c} = 1;
-	} elsif ($name =~ /\.c(pp|xx|c)?$/i){  # .c .C .cpp .cxx .cc
-	    $c{$name} = 1
-		unless $name =~ m/perlmain\.c/; # See MAP_TARGET
-	} elsif ($name =~ /\.h$/i){
-	    $h{$name} = 1;
-	} elsif ($name =~ /\.(p[ml]|pod)$/){
-	    $pm{$name} = $self->catfile('$(INST_LIBDIR)',$name);
-	} elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
-	    ($pl_files{$name} = $name) =~ s/\.PL$// ;
-	} elsif ($Is_VMS && $name =~ /\.pl$/ && $name ne 'makefile.pl' &&
-	         $name ne 'test.pl') {  # case-insensitive filesystem
-	    ($pl_files{$name} = $name) =~ s/\.pl$// ;
-	}
-    }
-
-    # Some larger extensions often wish to install a number of *.pm/pl
-    # files into the library in various locations.
-
-    # The attribute PMLIBDIRS holds an array reference which lists
-    # subdirectories which we should search for library files to
-    # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].  We
-    # recursively search through the named directories (skipping any
-    # which don't exist or contain Makefile.PL files).
-
-    # For each *.pm or *.pl file found $self->libscan() is called with
-    # the default installation path in $_[1]. The return value of
-    # libscan defines the actual installation location.  The default
-    # libscan function simply returns the path.  The file is skipped
-    # if libscan returns false.
-
-    # The default installation location passed to libscan in $_[1] is:
-    #
-    #  ./*.pm		=> $(INST_LIBDIR)/*.pm
-    #  ./xyz/...	=> $(INST_LIBDIR)/xyz/...
-    #  ./lib/...	=> $(INST_LIB)/...
-    #
-    # In this way the 'lib' directory is seen as the root of the actual
-    # perl library whereas the others are relative to INST_LIBDIR
-    # (which includes ROOTEXT). This is a subtle distinction but one
-    # that's important for nested modules.
-
-    $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
-	unless $self->{PMLIBDIRS};
-
-    #only existing directories that aren't in $dir are allowed
-
-    # Avoid $_ wherever possible:
-    # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
-    my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
-    my ($pmlibdir);
-    @{$self->{PMLIBDIRS}} = ();
-    foreach $pmlibdir (@pmlibdirs) {
-	-d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
-    }
-
-    if (@{$self->{PMLIBDIRS}}){
-	print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
-	    if ($Verbose >= 2);
-	require File::Find;
-	File::Find::find(sub {
-	    if (-d $_){
-		if ($_ eq "CVS" || $_ eq "RCS"){
-		    $File::Find::prune = 1;
-		}
-		return;
-	    }
-	    my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
-	    my($striplibpath,$striplibname);
-	    $prefix =  '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:);
-	    ($striplibname,$striplibpath) = fileparse($striplibpath);
-	    my($inst) = $self->catfile($prefix,$striplibpath,$striplibname);
-	    local($_) = $inst; # for backwards compatibility
-	    $inst = $self->libscan($inst);
-	    print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
-	    return unless $inst;
-	    $pm{$path} = $inst;
-	}, @{$self->{PMLIBDIRS}});
-    }
-
-    $self->{DIR} = [sort keys %dir] unless $self->{DIR};
-    $self->{XS}  = \%xs             unless $self->{XS};
-    $self->{PM}  = \%pm             unless $self->{PM};
-    $self->{C}   = [sort keys %c]   unless $self->{C};
-    my(@o_files) = @{$self->{C}};
-    $self->{O_FILES} = [grep s/\.c(pp|xx|c)?$/$self->{OBJ_EXT}/i, @o_files] ;
-    $self->{H}   = [sort keys %h]   unless $self->{H};
-    $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
-
-    # Set up names of manual pages to generate from pods
-    if ($self->{MAN1PODS}) {
-    } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
-    	$self->{MAN1PODS} = {};
-    } else {
-	my %manifypods = ();
-	if ( exists $self->{EXE_FILES} ) {
-	    foreach $name (@{$self->{EXE_FILES}}) {
-#		use FileHandle ();
-#		my $fh = new FileHandle;
-		local *FH;
-		my($ispod)=0;
-		# one day test, if $/ can be set to '' safely (is the bug fixed that was in 5.001m?)
-#		if ($fh->open("<$name")) {
-		if (open(FH,"<$name")) {
-		    my $testpodline;
-#		    while ($testpodline = <$fh>) {
-		    while ($testpodline = <FH>) {
-			if($testpodline =~ /^=head1\s+\w+/) {
-			    $ispod=1;
-			    last;
-			}
-		    }
-#		    $fh->close;
-		    close FH;
-		} else {
-		    # If it doesn't exist yet, we assume, it has pods in it
-		    $ispod = 1;
-		}
-		if( $ispod ) {
-		    $manifypods{$name} = $self->catfile('$(INST_MAN1DIR)',basename($name).'.$(MAN1EXT)');
-		}
-	    }
-	}
-	$self->{MAN1PODS} = \%manifypods;
-    }
-    if ($self->{MAN3PODS}) {
-    } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
-    	$self->{MAN3PODS} = {};
-    } else {
-	my %manifypods = (); # we collect the keys first, i.e. the files
-			     # we have to convert to pod
-	foreach $name (keys %{$self->{PM}}) {
-	    if ($name =~ /\.pod$/ ) {
-		$manifypods{$name} = $self->{PM}{$name};
-	    } elsif ($name =~ /\.p[ml]$/ ) {
-#		use FileHandle ();
-#		my $fh = new FileHandle;
-		local *FH;
-		my($ispod)=0;
-#		$fh->open("<$name");
-		open(FH,"<$name");
-		my $testpodline;
-#		while ($testpodline = <$fh>) {
-		while ($testpodline = <FH>) {
-		    if($testpodline =~ /^=head1\s+\w+/) {
-			$ispod=1;
-			last;
-		    }
-		    #Speculation on the future (K.A., not A.K. :)
-		    #if(/^=don't\S+install/) { $ispod=0; last}
-		}
-#		$fh->close;
-		close FH;
-
-		if( $ispod ) {
-		    $manifypods{$name} = $self->{PM}{$name};
-		}
-	    }
-	}
-
-	# Remove "Configure.pm" and similar, if it's not the only pod listed
-	# To force inclusion, just name it "Configure.pod", or override MAN3PODS
-	foreach $name (keys %manifypods) {
-	    if ($name =~ /(config|setup).*\.pm/i) {
-		delete $manifypods{$name};
-		next;
-	    }
-	    my($manpagename) = $name;
-	    unless ($manpagename =~ s!^(\W*)lib\W!$1!) {
-		$manpagename = $self->catfile($self->{ROOTEXT},$manpagename);
-	    }
-	    $manpagename =~ s/\.p(od|m|l)$//;
-	    # Strip leading slashes
-	    $manpagename =~ s!^/+!!;
-	    # Turn other slashes into colons
-#	    $manpagename =~ s,/+,::,g;
-	    $manpagename = $self->replace_manpage_separator($manpagename);
-	    $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
-	}
-	$self->{MAN3PODS} = \%manifypods;
-    }
-}
-
 =item init_others
 
 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
@@ -944,10 +1644,6 @@ MAKEFILE, NOECHO, RM_F, RM_RF, TOUCH, CP, MV, CHMOD, UMASK_NULL
 
 sub init_others {	# --- Initialize Other Attributes
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 
     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
     # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
@@ -971,8 +1667,7 @@ sub init_others {	# --- Initialize Other Attributes
 
     if ( $self->{OBJECT} ) {
 	$self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
-    }
-    else {
+    } else {
 	# init_dirscan should have found out, if we have C files
 	$self->{OBJECT} = "";
 	$self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
@@ -1007,683 +1702,190 @@ sub init_others {	# --- Initialize Other Attributes
     $self->{UMASK_NULL} ||= "umask 0";
 }
 
-=item extliblist
-
-Called by init_others, and calls ext ExtUtils::Liblist. See
-L<ExtUtils::Liblist> for details.
-
-=cut
-
-sub extliblist {
-    my($self,$libs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    require ExtUtils::Liblist;
-    $self->ext($libs, $Verbose);
-}
-
-=item find_perl
+=item install (o)
 
-Finds the executables PERL and FULLPERL
+Defines the install target.
 
 =cut
 
-sub find_perl {
-    my($self, $ver, $names, $dirs, $trace) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my($name, $dir);
-    if ($trace >= 2){
-	print "Looking for perl $ver by these names:
-@$names
-in these dirs:
-@$dirs
-";
-    }
-    foreach $dir (@$dirs){
-	next unless defined $dir; # $self->{PERL_SRC} may be undefined
-	foreach $name (@$names){
-	    my $abs;
-	    if ($self->file_name_is_absolute($name)) {
-		$abs = $name;
-	    } elsif (($name =~ m|/|) && ($name !~ m|^\.{1,2}/|)) {
-		# name is a path that does not begin with dot or dotdot
-		$abs = $self->catfile(".", $name);
-	    } else {
-		$abs = $self->catfile($dir, $name);
-	    }
-	    print "Checking $abs\n" if ($trace >= 2);
-	    next unless $self->maybe_command($abs);
-	    print "Executing $abs\n" if ($trace >= 2);
-	    if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
-	        print "Using PERL=$abs\n" if $trace;
-	        return $abs;
-	    }
-	}
-    }
-    print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
-    0; # false and not empty
-}
-
-=head2 Methods to actually produce chunks of text for the Makefile
-
-The methods here are called in the order specified by
-@ExtUtils::MakeMaker::MM_Sections. This manpage reflects the order as
-well as possible. Some methods call each other, so in doubt refer to
-the code.
-
-=item post_initialize (o)
-
-Returns an ampty string per default. Used in Makefile.PLs to add some
-chunk of text to the Makefile after the object is initialized.
+sub install {
+    my($self, %attribs) = @_;
+    my(@m);
 
-=cut
+    push @m, q{
+install :: all pure_install doc_install
 
-sub post_initialize {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    "";
-}
+install_perl :: all pure_perl_install doc_perl_install
 
-=item const_config (o)
+install_site :: all pure_site_install doc_site_install
 
-Defines a couple of constants in the Makefile that are inported from
-%Config.
+install_ :: install_site
+	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
 
-=cut
+pure_install :: pure_$(INSTALLDIRS)_install
 
-sub const_config {
-# --- Constants Sections ---
+doc_install :: doc_$(INSTALLDIRS)_install
+	}.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
 
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m,$m);
-    push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
-    push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
-    my(%once_only);
-    foreach $m (@{$self->{CONFIG}}){
-	# SITE*EXP macros are defined in &constants; avoid duplicates here
-	next if $once_only{$m} or $m eq 'sitelibexp' or $m eq 'sitearchexp';
-	push @m, "\U$m\E = ".$self->{uc $m}."\n";
-	$once_only{$m} = 1;
-    }
-    join('', @m);
-}
+pure__install : pure_site_install
+	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
 
-=item constants (o)
+doc__install : doc_site_install
+	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
 
-Initializes lots of constants and .SUFFIXES and .PHONY
+pure_perl_install ::
+	}.$self->{NOECHO}.q{$(MOD_INSTALL) \
+		read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
+		write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
+		$(INST_LIB) $(INSTALLPRIVLIB) \
+		$(INST_ARCHLIB) $(INSTALLARCHLIB) \
+		$(INST_BIN) $(INSTALLBIN) \
+		$(INST_SCRIPT) $(INSTALLSCRIPT) \
+		$(INST_MAN1DIR) $(INSTALLMAN1DIR) \
+		$(INST_MAN3DIR) $(INSTALLMAN3DIR)
+	}.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
+		}.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
 
-=cut
 
-sub constants {
-    my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m,$tmp);
+pure_site_install ::
+	}.$self->{NOECHO}.q{$(MOD_INSTALL) \
+		read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
+		write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
+		$(INST_LIB) $(INSTALLSITELIB) \
+		$(INST_ARCHLIB) $(INSTALLSITEARCH) \
+		$(INST_BIN) $(INSTALLBIN) \
+		$(INST_SCRIPT) $(INSTALLSCRIPT) \
+		$(INST_MAN1DIR) $(INSTALLMAN1DIR) \
+		$(INST_MAN3DIR) $(INSTALLMAN3DIR)
+	}.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
+		}.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
 
-    for $tmp (qw/
-	      AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION VERSION_SYM XS_VERSION
-	      INST_LIB INST_ARCHLIB INST_EXE PREFIX INSTALLDIRS INSTALLPRIVLIB
-	      INSTALLARCHLIB INSTALLSITELIB INSTALLSITEARCH INSTALLBIN PERL_LIB
-	      PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
-	      FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC PERL_INC PERL FULLPERL
-	      / ) {
-	next unless defined $self->{$tmp};
-	push @m, "$tmp = $self->{$tmp}\n";
-    }
+doc_perl_install ::
+	}.$self->{NOECHO}.q{$(DOC_INSTALL) \
+		"$(NAME)" \
+		"installed into" "$(INSTALLPRIVLIB)" \
+		LINKTYPE "$(LINKTYPE)" \
+		VERSION "$(VERSION)" \
+		EXE_FILES "$(EXE_FILES)" \
+		>> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
 
-    push @m, qq{
-VERSION_MACRO = VERSION
-DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
-XS_VERSION_MACRO = XS_VERSION
-XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
-};
+doc_site_install ::
+	}.$self->{NOECHO}.q{$(DOC_INSTALL) \
+		"Module $(NAME)" \
+		"installed into" "$(INSTALLSITELIB)" \
+		LINKTYPE "$(LINKTYPE)" \
+		VERSION "$(VERSION)" \
+		EXE_FILES "$(EXE_FILES)" \
+		>> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
 
-    push @m, qq{
-MAKEMAKER = \$(PERL_LIB)/ExtUtils/MakeMaker.pm
-MM_VERSION = $ExtUtils::MakeMaker::VERSION
 };
 
     push @m, q{
-# FULLEXT = Pathname for extension directory (eg DBD/Oracle).
-# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
-# ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
-# DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
-};
-
-    for $tmp (qw/
-	      FULLEXT BASEEXT ROOTEXT DLBASE VERSION_FROM INC DEFINE OBJECT
-	      LDFROM LINKTYPE
-	      /	) {
-	next unless defined $self->{$tmp};
-	push @m, "$tmp = $self->{$tmp}\n";
-    }
-
-    push @m, "
-# Handy lists of source code files:
-XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
-C_FILES = ".join(" \\\n\t", @{$self->{C}})."
-O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
-H_FILES = ".join(" \\\n\t", @{$self->{H}})."
-MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
-MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
-";
-
-    for $tmp (qw/
-	      INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
-	      /) {
-	next unless defined $self->{$tmp};
-	push @m, "$tmp = $self->{$tmp}\n";
-    }
-
-    push @m, "
-# work around a famous dec-osf make(1) feature(?):
-makemakerdflt: all
-
-.SUFFIXES: .xs .c .C .cpp .cxx .cc \$(OBJ_EXT)
-
-# Nick wanted to get rid of .PRECIOUS. I don't remember why. I seem to recall, that
-# some make implementations will delete the Makefile when we rebuild it. Because
-# we call false(1) when we rebuild it. So make(1) is not completely wrong when it
-# does so. Our milage may vary.
-# .PRECIOUS: Makefile    # seems to be not necessary anymore
-
-.PHONY: all config static dynamic test linkext manifest
-
-# Where is the Config information that we are using/depend on
-CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h
-";
-
-    push @m, '
-# Where to put things:
-INST_LIBDIR     = $(INST_LIB)$(ROOTEXT)
-INST_ARCHLIBDIR = $(INST_ARCHLIB)$(ROOTEXT)
-
-INST_AUTODIR      = $(INST_LIB)/auto/$(FULLEXT)
-INST_ARCHAUTODIR  = $(INST_ARCHLIB)/auto/$(FULLEXT)
-';
-
-    if ($self->has_link_code()) {
-	push @m, '
-INST_STATIC  = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
-INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
-INST_BOOT    = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
-';
-    } else {
-	push @m, '
-INST_STATIC  =
-INST_DYNAMIC =
-INST_BOOT    =
-';
-    }
-
-    if ($Is_OS2) {
-	$tmp = "$self->{BASEEXT}.def";
-    } else {
-	$tmp = "";
-    }
-    push @m, "
-EXPORT_LIST = $tmp
-";
-
-    if ($Is_OS2) {
-	$tmp = "\$(PERL_INC)/libperl.lib";
-    } else {
-	$tmp = "";
-    }
-    push @m, "
-PERL_ARCHIVE = $tmp
-";
-
-#    push @m, q{
-#INST_PM = }.join(" \\\n\t", sort values %{$self->{PM}}).q{
-#
-#PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
-#};
+uninstall :: uninstall_from_$(INSTALLDIRS)dirs
 
-    push @m, q{
-TO_INST_PM = }.join(" \\\n\t", sort keys %{$self->{PM}}).q{
+uninstall_from_perldirs ::
+	}.$self->{NOECHO}.
+	q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
 
-PM_TO_BLIB = }.join(" \\\n\t", %{$self->{PM}}).q{
+uninstall_from_sitedirs ::
+	}.$self->{NOECHO}.
+	q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
 };
 
-    join('',@m);
+    join("",@m);
 }
 
-=item const_loadlibs
+=item installbin (o)
 
-Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
-L<ExtUtils::Liblist> for details.
+Defines targets to install EXE_FILES.
 
 =cut
 
-sub const_loadlibs {
+sub installbin {
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    return "" unless $self->needs_linking;
-    my @m;
-    push @m, qq{
-# $self->{NAME} might depend on some other libraries:
-# See ExtUtils::Liblist for details
-#
-};
-    my($tmp);
-    for $tmp (qw/
-	 EXTRALIBS LDLOADLIBS BSLOADLIBS LD_RUN_PATH
-	 /) {
-	next unless defined $self->{$tmp};
-	push @m, "$tmp = $self->{$tmp}\n";
-    }
-    return join "", @m;
-}
-
-=item cflags
-
-Does very much the same as the cflags script in the perl
-distribution. It doesn't return the whole compiler command line, but
-initializes all of its parts. The const_cccmd method then actually
-returns the definition of the CCCMD macro which uses these parts.
-
-=cut
-
-#'
-
-sub cflags {
-    my($self,$libperl)=@_;
-    return $self->{CFLAGS} if $self->{CFLAGS};
-    return '' unless $self->needs_linking();
-
-    my($prog, $uc, $perltype, %cflags);
-    $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
-    $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
-
-    @cflags{qw(cc ccflags optimize large split shellflags)}
-	= @Config{qw(cc ccflags optimize large split shellflags)};
-    my($optdebug) = "";
-
-    $cflags{shellflags} ||= '';
-
-    my(%map) =  (
-		D =>   '-DDEBUGGING',
-		E =>   '-DEMBED',
-		DE =>  '-DDEBUGGING -DEMBED',
-		M =>   '-DEMBED -DMULTIPLICITY',
-		DM =>  '-DDEBUGGING -DEMBED -DMULTIPLICITY',
-		);
-
-    if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
-	$uc = uc($1);
-    } else {
-	$uc = ""; # avoid warning
-    }
-    $perltype = $map{$uc} ? $map{$uc} : "";
-
-    if ($uc =~ /^D/) {
-	$optdebug = "-g";
+    return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
+    return "" unless @{$self->{EXE_FILES}};
+    my(@m, $from, $to, %fromto, @to);
+    push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
+    for $from (@{$self->{EXE_FILES}}) {
+	my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
+	local($_) = $path; # for backwards compatibility
+	$to = $self->libscan($path);
+	print "libscan($from) => '$to'\n" if ($Verbose >=2);
+	$fromto{$from}=$to;
     }
+    @to   = values %fromto;
+    push(@m, "
+EXE_FILES = @{$self->{EXE_FILES}}
 
+all :: @to
 
-    my($name);
-    ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
-    if ($prog = $Config::Config{$name}) {
-	# Expand hints for this extension via the shell
-	print STDOUT "Processing $name hint:\n" if $Verbose;
-	my(@o)=`cc=\"$cflags{cc}\"
-	  ccflags=\"$cflags{ccflags}\"
-	  optimize=\"$cflags{optimize}\"
-	  perltype=\"$cflags{perltype}\"
-	  optdebug=\"$cflags{optdebug}\"
-	  large=\"$cflags{large}\"
-	  split=\"$cflags{'split'}\"
-	  eval '$cflags{prog}'
-	  echo cc=\$cflags{cc}
-	  echo ccflags=\$cflags{ccflags}
-	  echo optimize=\$cflags{optimize}
-	  echo perltype=\$cflags{perltype}
-	  echo optdebug=\$cflags{optdebug}
-	  echo large=\$cflags{large}
-	  echo split=\$cflags{'split'}
-	  `;
-	my($line);
-	foreach $line (@o){
-	    chomp $line;
-	    if ($line =~ /(.*?)=\s*(.*)\s*$/){
-		$cflags{$1} = $2;
-		print STDOUT "	$1 = $2\n" if $Verbose;
-	    } else {
-		print STDOUT "Unrecognised result from hint: '$line'\n";
-	    }
-	}
-    }
-
-    if ($optdebug) {
-	$cflags{optimize} = $optdebug;
-    }
+realclean ::
+	$self->{RM_F} @to
+");
 
-    for (qw(ccflags optimize perltype large split)) {
-	$cflags{$_} =~ s/^\s+//;
-	$cflags{$_} =~ s/\s+/ /g;
-	$cflags{$_} =~ s/\s+$//;
-	$self->{uc $_} ||= $cflags{$_}
+    while (($from,$to) = each %fromto) {
+	last unless defined $from;
+	my $todir = dirname($to);
+	push @m, "
+$to: $from $self->{MAKEFILE} $todir/.exists
+	$self->{NOECHO}$self->{RM_F} $to
+	$self->{CP} $from $to
+";
     }
-
-    return $self->{CFLAGS} = qq{
-CCFLAGS = $self->{CCFLAGS}
-OPTIMIZE = $self->{OPTIMIZE}
-PERLTYPE = $self->{PERLTYPE}
-LARGE = $self->{LARGE}
-SPLIT = $self->{SPLIT}
-};
-
+    join "", @m;
 }
 
+=item libscan (o)
 
-
-=item const_cccmd
-
-Returns the full compiler call for C programs and stores the
-definition in CONST_CCCMD.
+Takes a path to a file that is found by init_dirscan and returns false
+if we don't want to include this file in the library. Mainly used to
+exclude RCS, CVS, and SCCS directories from installation.
 
 =cut
 
-sub const_cccmd {
-    my($self,$libperl)=@_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
-    return '' unless $self->needs_linking();
-    return $self->{CONST_CCCMD} =
-	q{CCCMD = $(CC) -c $(INC) $(CCFLAGS) $(OPTIMIZE) \\
-	$(PERLTYPE) $(LARGE) $(SPLIT) $(DEFINE_VERSION) \\
-	$(XS_DEFINE_VERSION)};
-}
-
-=item pm_to_blib
-
-Defines target that copies all files in the hash PM to their
-destination and autosplits them. See L<ExtUtils::Install/pm_to_blib>
-
-=cut
+# ';
 
-sub pm_to_blib {
-    my $self = shift;
-    my($autodir) = $self->catdir('$(INST_LIB)','auto');
-    return q{
-pm_to_blib: $(TO_INST_PM)
-	}.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
-	"-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
-	-e 'pm_to_blib({@ARGV},"}.$autodir.q{")' $(PM_TO_BLIB)
-	}.$self->{NOECHO}.q{$(TOUCH) $@
-};
+sub libscan {
+    my($self,$path) = @_;
+    return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
+    $path;
 }
 
-=item tool_autosplit (o)
+=item linkext (o)
 
-Defines a simple perl call that runs autosplit. May be deprecated by
-pm_to_blib soon.
+Defines the linkext target which in turn defines the LINKTYPE.
 
 =cut
 
-sub tool_autosplit {
-# --- Tool Sections ---
-
+sub linkext {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my($asl) = "";
-    $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
-    q{
-# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
-AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
-};
-}
-
-=item tool_xsubpp (o)
-
-Determines typemaps, xsubpp version, prototype behaviour.
-
-=cut
-
-sub tool_xsubpp {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
-    my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
-    if( $self->{TYPEMAPS} ){
-	my $typemap;
-	foreach $typemap (@{$self->{TYPEMAPS}}){
-		if( ! -f  $typemap ){
-			warn "Typemap $typemap not found.\n";
-		}
-		else{
-			push(@tmdeps,  $typemap);
-		}
-	}
-    }
-    push(@tmdeps, "typemap") if -f "typemap";
-    my(@tmargs) = map("-typemap $_", @tmdeps);
-    if( exists $self->{XSOPT} ){
- 	unshift( @tmargs, $self->{XSOPT} );
-    }
-
-
-    my $xsubpp_version = $self->xsubpp_version("$xsdir/xsubpp");
-
-    # What are the correct thresholds for version 1 && 2 Paul?
-    if ( $xsubpp_version > 1.923 ){
-	$self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
-    } else {
-	if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
-	    print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
-	Your version of xsubpp is $xsubpp_version and cannot handle this.
-	Please upgrade to a more recent version of xsubpp.
-};
-	} else {
-	    $self->{XSPROTOARG} = "";
-	}
-    }
-
-    return qq{
-XSUBPPDIR = $xsdir
-XSUBPP = \$(XSUBPPDIR)/xsubpp
-XSPROTOARG = $self->{XSPROTOARG}
-XSUBPPDEPS = @tmdeps
-XSUBPPARGS = @tmargs
-};
-};
-
-sub xsubpp_version
-{
-    my($self,$xsubpp) = @_;
-    return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
-
-    my ($version) ;
-
-    # try to figure out the version number of the xsubpp on the system
-
-    # first try the -v flag, introduced in 1.921 & 2.000a2
-
-    my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
-    print "Running $command\n" if $Verbose >= 2;
-    $version = `$command` ;
-    warn "Running '$command' exits with status " . ($?>>8) if $?;
-    chop $version ;
-
-    return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
-
-    # nope, then try something else
-
-    my $counter = '000';
-    my ($file) = 'temp' ;
-    $counter++ while -e "$file$counter"; # don't overwrite anything
-    $file .= $counter;
-
-    open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
-    print F <<EOM ;
-MODULE = fred PACKAGE = fred
-
-int
-fred(a)
-        int     a;
-EOM
-
-    close F ;
-
-    $command = "$self->{PERL} $xsubpp $file 2>&1";
-    print "Running $command\n" if $Verbose >= 2;
-    my $text = `$command` ;
-    warn "Running '$command' exits with status " . ($?>>8) if $?;
-    unlink $file ;
-
-    # gets 1.2 -> 1.92 and 2.000a1
-    return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
-
-    # it is either 1.0 or 1.1
-    return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
-
-    # none of the above, so 1.0
-    return $Xsubpp_Version = "1.0" ;
+    # LINKTYPE => static or dynamic or ''
+    my($linktype) = defined $attribs{LINKTYPE} ?
+      $attribs{LINKTYPE} : '$(LINKTYPE)';
+    "
+linkext :: $linktype
+	$self->{NOECHO}\$(NOOP)
+";
 }
 
-=item tools_other (o)
+=item lsdir
 
-Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
-the Makefile. Also defines the perl programs MKPATH,
-WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
+Takes as arguments a directory name and a regular expression. Returns
+all entries in the directory that match the regular expression.
 
 =cut
 
-sub tools_other {
+sub lsdir {
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my @m;
-    push @m, qq{
-SHELL = /bin/sh
-LD = $self->{LD}
-TOUCH = $self->{TOUCH}
-CP = $self->{CP}
-MV = $self->{MV}
-RM_F  = $self->{RM_F}
-RM_RF = $self->{RM_RF}
-CHMOD = $self->{CHMOD}
-UMASK_NULL = $self->{UMASK_NULL}
-};
-
-    push @m, q{
-# The following is a portable way to say mkdir -p
-# To see which directories are created, change the if 0 to if 1
-MKPATH = $(PERL) -wle '$$"="/"; foreach $$p (@ARGV){' \\
--e 'next if -d $$p; my(@p); foreach(split(/\//,$$p)){' \\
--e 'push(@p,$$_); next if -d "@p/"; print "mkdir @p" if 0;' \\
--e 'mkdir("@p",0777)||die $$! } } exit 0;'
-
-# This helps us to minimize the effect of the .exists files A yet
-# better solution would be to have a stable file in the perl
-# distribution with a timestamp of zero. But this solution doesn't
-# need any changes to the core distribution and works with older perls
-EQUALIZE_TIMESTAMP = $(PERL) -we 'open F, ">$$ARGV[1]"; close F;' \\
--e 'utime ((stat("$$ARGV[0]"))[8,9], $$ARGV[1])'
-};
-
-    return join "", @m if $self->{PARENT};
-
-    push @m, q{
-# Here we warn users that an old packlist file was found somewhere,
-# and that they should call some uninstall routine
-WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
--e 'print "WARNING: I have found an old package in\n";' \\
--e 'print "\t$$ARGV[0].\n";' \\
--e 'print "Please make sure the two installations are not conflicting\n";'
-
-MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
--e 'install({@ARGV},1);'
-
-DOC_INSTALL = $(PERL) -e '$$\="\n\n";print "=head3 ", scalar(localtime), ": C<", shift, ">";' \
--e 'print "=over 4";' \
--e 'while ($$key = shift and $$val = shift){print "=item *";print "C<$$key: $$val>";}' \
--e 'print "=back";'
-
-UNINSTALL =   $(PERL) -MExtUtils::Install \
--e 'uninstall($$ARGV[0],1);'
-
-};
-
-    return join "", @m;
-}
-
-=item dist (o)
-
-Defines a lot of macros for distribution support.
-
-=cut
-
-sub dist {
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-
-    my(@m);
-    # VERSION should be sanitised before use as a file name
-    my($name)     = $attribs{NAME}     || '$(DISTVNAME)';
-    my($tar)      = $attribs{TAR}      || 'tar';        # eg /usr/bin/gnutar
-    my($tarflags) = $attribs{TARFLAGS} || 'cvf';
-    my($zip)      = $attribs{ZIP}      || 'zip';        # eg pkzip Yuck!
-    my($zipflags) = $attribs{ZIPFLAGS} || '-r';
-    my($compress) = $attribs{COMPRESS} || 'compress';   # eg gzip
-    my($suffix)   = $attribs{SUFFIX}   || '.Z';          # eg .gz
-    my($shar)     = $attribs{SHAR}     || 'shar';       # eg "shar --gzip"
-    my($preop)    = $attribs{PREOP}    || "$self->{NOECHO}\$(NOOP)"; # eg update MANIFEST
-    my($postop)   = $attribs{POSTOP}   || "$self->{NOECHO}\$(NOOP)"; # eg remove the distdir
-    my($ci)       = $attribs{CI}       || 'ci -u';
-    my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
-    my($dist_cp)  = $attribs{DIST_CP}  || 'best';
-    my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
-
-    push @m, "
-DISTVNAME = \$(DISTNAME)-\$(VERSION_SYM)
-TAR  = $tar
-TARFLAGS = $tarflags
-ZIP  = $zip
-ZIPFLAGS = $zipflags
-COMPRESS = $compress
-SUFFIX = $suffix
-SHAR = $shar
-PREOP = $preop
-POSTOP = $postop
-CI = $ci
-RCS_LABEL = $rcs_label
-DIST_CP = $dist_cp
-DIST_DEFAULT = $dist_default
-";
-    join "", @m;
+    my($dir, $regex) = @_;
+    my(@ls);
+    my $dh = new DirHandle;
+    $dh->open($dir || ".") or return ();
+    @ls = $dh->read;
+    $dh->close;
+    @ls = grep(/$regex/, @ls) if $regex;
+    @ls;
 }
 
 =item macro (o)
@@ -1695,10 +1897,6 @@ into the Makefile.
 
 sub macro {
     my($self,%attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m,$key,$val);
     while (($key,$val) = each %attribs){
 	last unless defined $key;
@@ -1707,525 +1905,261 @@ sub macro {
     join "", @m;
 }
 
-=item depend (o)
+=item makeaperl (o)
 
-Same as macro for the depend attribute.
+Called by staticmake. Defines how to write the Makefile to produce a
+static new perl.
 
 =cut
 
-sub depend {
-    my($self,%attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m,$key,$val);
-    while (($key,$val) = each %attribs){
-	last unless defined $key;
-	push @m, "$key : $val\n\t$self->{NOECHO}\$(NOOP)\n\n";
-    }
-    join "", @m;
-}
+sub makeaperl {
+    my($self, %attribs) = @_;
+    my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
+	@attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
+    my(@m);
+    push @m, "
+# --- MakeMaker makeaperl section ---
+MAP_TARGET    = $target
+FULLPERL      = $self->{FULLPERL}
+";
+    return join '', @m if $self->{PARENT};
 
-=item post_constants (o)
+    my($dir) = join ":", @{$self->{DIR}};
 
-Returns an empty string per default. Dedicated to overrides from
-within Makefile.PL after all constants have been defined.
+    unless ($self->{MAKEAPERL}) {
+	push @m, q{
+$(MAP_TARGET) :: static $(MAKE_APERL_FILE)
+	$(MAKE) -f $(MAKE_APERL_FILE) $@
 
-=cut
+$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
+	}.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
+	}.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
+		Makefile.PL DIR=}, $dir, q{ \
+		MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
+		MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
 
-sub post_constants{
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+	foreach (@ARGV){
+		if( /\s/ ){
+			s/=(.*)/='$1'/;
+		}
+		push @m, " \\\n\t\t$_";
+	}
+#	push @m, map( " \\\n\t\t$_", @ARGV );
+	push @m, "\n";
+
+	return join '', @m;
     }
-    "";
-}
 
-=item pasthru (o)
 
-Defines the string that is passed to recursive make calls in
-subdirectories.
 
-=cut
+    my($cccmd, $linkcmd, $lperl);
 
-sub pasthru {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m,$key);
 
-    my(@pasthru);
+    $cccmd = $self->const_cccmd($libperl);
+    $cccmd =~ s/^CCCMD\s*=\s*//;
+    $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
+    $cccmd .= " $Config::Config{cccdlflags}" if ($Config::Config{d_shrplib});
+    $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
 
-# We don't have to pass thru the install thingies anymore: make
-# install is run in base directory only:
+    # The front matter of the linkcommand...
+    $linkcmd = join ' ', "\$(CC)",
+	    grep($_, @Config{qw(large split ldflags ccdlflags)});
+    $linkcmd =~ s/\s+/ /g;
 
-#    foreach $key (qw(INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN
-#		     INSTALLMAN1DIR INSTALLMAN3DIR LIBPERL_A
-#		     LINKTYPE PREFIX INSTALLSITELIB
-#		     INSTALLSITEARCH INSTALLDIRS)){
+    # Which *.a files could we make use of...
+    local(%static);
+    require File::Find;
+    File::Find::find(sub {
+	return unless m/\Q$self->{LIB_EXT}\E$/;
+	return if m/^libperl/;
 
-    foreach $key (qw(LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
-	push @pasthru, "$key=\"\$($key)\"";
-    }
+	if( exists $self->{INCLUDE_EXT} ){
+		my $found = 0;
+		my $incl;
+		my $xx;
+
+		($xx = $File::Find::name) =~ s,.*?/auto/,,;
+		$xx =~ s,/?$_,,;
+		$xx =~ s,/,::,g;
+
+		# Throw away anything not explicitly marked for inclusion.
+		# DynaLoader is implied.
+		foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
+			if( $xx eq $incl ){
+				$found++;
+				last;
+			}
+		}
+		return unless $found;
+	}
+	elsif( exists $self->{EXCLUDE_EXT} ){
+		my $excl;
+		my $xx;
 
-    push @m, "\nPASTHRU = ", join ("\\\n\t", @pasthru), "\n";
-    join "", @m;
-}
+		($xx = $File::Find::name) =~ s,.*?/auto/,,;
+		$xx =~ s,/?$_,,;
+		$xx =~ s,/,::,g;
 
-=item c_o (o)
+		# Throw away anything explicitly marked for exclusion
+		foreach $excl (@{$self->{EXCLUDE_EXT}}){
+			return if( $xx eq $excl );
+		}
+	}
 
-Defines the suffix rules to compile different flavors of C files to
-object files.
+	# don't include the installed version of this extension. I
+	# leave this line here, although it is not necessary anymore:
+	# I patched minimod.PL instead, so that Miniperl.pm won't
+	# enclude duplicates
 
-=cut
+	# Once the patch to minimod.PL is in the distribution, I can
+	# drop it
+	return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
+	use Cwd 'cwd';
+	$static{cwd() . "/" . $_}++;
+    }, grep( -d $_, @{$searchdirs || []}) );
 
-sub c_o {
-# --- Translation Sections ---
+    # We trust that what has been handed in as argument, will be buildable
+    $static = [] unless $static;
+    @static{@{$static}} = (1) x @{$static};
 
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+    $extra = [] unless $extra && ref $extra eq 'ARRAY';
+    for (sort keys %static) {
+	next unless /\Q$self->{LIB_EXT}\E$/;
+	$_ = dirname($_) . "/extralibs.ld";
+	push @$extra, $_;
     }
-    return '' unless $self->needs_linking();
-    my(@m);
-    push @m, '
-.c$(OBJ_EXT):
-	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
-
-.C$(OBJ_EXT):
-	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
-
-.cpp$(OBJ_EXT):
-	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cpp
-
-.cxx$(OBJ_EXT):
-	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cxx
 
-.cc$(OBJ_EXT):
-	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.cc
-';
-    join "", @m;
-}
+    grep(s/^/-I/, @{$perlinc || []});
 
-=item xs_c (o)
+    $target = "perl" unless $target;
+    $tmp = "." unless $tmp;
 
-Defines the suffix rules to compile XS files to C.
+# MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
+# regenerate the Makefiles, MAP_STATIC and the dependencies for
+# extralibs.all are computed correctly
+    push @m, "
+MAP_LINKCMD   = $linkcmd
+MAP_PERLINC   = @{$perlinc || []}
+MAP_STATIC    = ",
+join(" \\\n\t", reverse sort keys %static), "
 
-=cut
+MAP_PRELIBS   = $Config::Config{libs} $Config::Config{cryptlib}
+";
 
-sub xs_c {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+    if (defined $libperl) {
+	($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
     }
-    return '' unless $self->needs_linking();
-    '
-.xs.c:
-	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && mv $*.tc $@
-';
-}
-
-=item xs_o (o)
-
-Defines suffix rules to go from XS to object files directly. This is
-only intended for broken make implementations.
-
-=cut
-
-sub xs_o {	# many makes are too dumb to use xs_c then c_o
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+    unless ($libperl && -f $lperl) { # Ilya's code...
+	my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
+	$libperl ||= "libperl$self->{LIB_EXT}";
+	$libperl   = "$dir/$libperl";
+	$lperl   ||= "libperl$self->{LIB_EXT}";
+	$lperl     = "$dir/$lperl";
+	print STDOUT "Warning: $libperl not found
+    If you're going to build a static perl binary, make sure perl is installed
+    otherwise ignore this warning\n"
+		unless (-f $lperl || defined($self->{PERL_SRC}));
     }
-    return '' unless $self->needs_linking();
-    '
-.xs$(OBJ_EXT):
-	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && mv xstmp.c $*.c
-	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
-';
-}
-
-=item top_targets (o)
-
-Defines the targets all, subdirs, config, and O_FILES
 
-=cut
+    push @m, "
+MAP_LIBPERL = $libperl
+";
 
-sub top_targets {
-# --- Target Sections ---
+    push @m, "
+\$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
+	$self->{NOECHO}$self->{RM_F} \$\@
+	$self->{NOECHO}\$(TOUCH) \$\@
+";
 
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+    my $catfile;
+    foreach $catfile (@$extra){
+	push @m, "\tcat $catfile >> \$\@\n";
     }
-    my(@m);
-    push @m, '
-#all ::	config $(INST_PM) subdirs linkext manifypods
 
-all :: pure_all manifypods
-	'.$self->{NOECHO}.'$(NOOP)
-
-pure_all :: config pm_to_blib subdirs linkext
-	'.$self->{NOECHO}.'$(NOOP)
-
-subdirs :: $(MYEXTLIB)
-	'.$self->{NOECHO}.'$(NOOP)
-
-config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
-	'.$self->{NOECHO}.'$(NOOP)
-
-config :: $(INST_ARCHAUTODIR)/.exists
-	'.$self->{NOECHO}.'$(NOOP)
+    push @m, "
+\$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
+	\$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
+	$self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
+	$self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
+	$self->{NOECHO}echo 'To remove the intermediate files say'
+	$self->{NOECHO}echo '    make -f $makefilename map_clean'
 
-config :: $(INST_AUTODIR)/.exists
-	'.$self->{NOECHO}.'$(NOOP)
-';
+$tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
+";
+    push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
 
     push @m, qq{
-config :: Version_check
-	$self->{NOECHO}\$(NOOP)
-
-} unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
-
-    push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
-
-    if (%{$self->{MAN1PODS}}) {
-	push @m, qq[
-config :: \$(INST_MAN1DIR)/.exists
-	$self->{NOECHO}\$(NOOP)
-
-];
-	push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
-    }
-    if (%{$self->{MAN3PODS}}) {
-	push @m, qq[
-config :: \$(INST_MAN3DIR)/.exists
-	$self->{NOECHO}\$(NOOP)
-
-];
-	push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
-    }
-
-    push @m, '
-$(O_FILES): $(H_FILES)
-' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
+$tmp/perlmain.c: $makefilename}, q{
+	}.$self->{NOECHO}.q{echo Writing $@
+	}.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -e 'use ExtUtils::Miniperl; \\
+		writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)' > $@.tmp && mv $@.tmp $@
 
-    push @m, q{
-help:
-	perldoc ExtUtils::MakeMaker
 };
 
     push @m, q{
-Version_check:
-	}.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
-		-MExtUtils::MakeMaker=Version_check \
-		-e 'Version_check("$(MM_VERSION)")'
-};
-
-    join('',@m);
-}
-
-=item linkext (o)
-
-Defines the linkext target which in turn defines the LINKTYPE.
-
-=cut
-
-sub linkext {
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    # LINKTYPE => static or dynamic or ''
-    my($linktype) = defined $attribs{LINKTYPE} ?
-      $attribs{LINKTYPE} : '$(LINKTYPE)';
-    "
-linkext :: $linktype
-	$self->{NOECHO}\$(NOOP)
-";
-}
-
-=item dlsyms (o)
-
-Used by AIX and VMS to define DL_FUNCS and DL_VARS and write the *.exp
-files.
-
-=cut
-
-sub dlsyms {
-    my($self,%attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-
-    return '' unless ($^O eq 'aix' && $self->needs_linking() );
-
-    my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
-    my($vars)  = $attribs{DL_VARS} || $self->{DL_VARS} || [];
-    my(@m);
+doc_inst_perl:
+	}.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
+	}.$self->{NOECHO}.q{$(DOC_INSTALL) \
+		"Perl binary $(MAP_TARGET)" \
+		MAP_STATIC "$(MAP_STATIC)" \
+		MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
+		MAP_LIBPERL "$(MAP_LIBPERL)" \
+		>> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
 
-    push(@m,"
-dynamic :: $self->{BASEEXT}.exp
+};
 
-") unless $self->{SKIPHASH}{'dynamic'}; # dynamic and static are subs, so...
+    push @m, q{
+inst_perl: pure_inst_perl doc_inst_perl
 
-    push(@m,"
-static :: $self->{BASEEXT}.exp
+pure_inst_perl: $(MAP_TARGET)
+	}.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
 
-") unless $self->{SKIPHASH}{'static'};  # we avoid a warning if we tick them
+clean :: map_clean
 
-    push(@m,"
-$self->{BASEEXT}.exp: Makefile.PL
-",'	$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::Mksymlists; \\
-	Mksymlists("NAME" => "',$self->{NAME},'", "DL_FUNCS" => ',
-	neatvalue($funcs),', "DL_VARS" => ', neatvalue($vars), ');\'
-');
+map_clean :
+	}.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
+};
 
-    join('',@m);
+    join '', @m;
 }
 
-=item dynamic (o)
+=item makefile (o)
 
-Defines the dynamic target.
+Defines how to rewrite the Makefile.
 
 =cut
 
-sub dynamic {
-# --- Dynamic Loading Sections ---
-
+sub makefile {
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    '
-## $(INST_PM) has been moved to the all: target.
-## It remains here for awhile to allow for old usage: "make dynamic"
-#dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
-dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT)
-	'.$self->{NOECHO}.'$(NOOP)
-';
-}
-
-=item dynamic_bs (o)
-
-Defines targets for bootstrap files.
-
-=cut
-
-sub dynamic_bs {
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    return '
-BOOTSTRAP =
-' unless $self->has_link_code();
-
-    return '
-BOOTSTRAP = '."$self->{BASEEXT}.bs".'
-
-# As Mkbootstrap might not write a file (if none is required)
-# we use touch to prevent make continually trying to remake it.
-# The DynaLoader only reads a non-empty file.
-$(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
-	'.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
-	'.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
-		-e \'use ExtUtils::Mkbootstrap;\' \
-		-e \'Mkbootstrap("$(BASEEXT)","$(BSLOADLIBS)");\'
-	'.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
-	$(CHMOD) 644 $@
-
-$(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
-	'."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
-	-'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
-	$(CHMOD) 644 $@
-';
-}
-
-=item dynamic_lib (o)
-
-Defines how to produce the *.so (or equivalent) files.
-
-=cut
-
-sub dynamic_lib {
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    return '' unless $self->needs_linking(); #might be because of a subdir
-
-    return '' unless $self->has_link_code;
-
-    my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
-    my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
-    my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
-    my($ldfrom) = '$(LDFROM)';
-    $armaybe = 'ar' if ($^O eq 'dec_osf' and $armaybe eq ':');
-    my(@m);
-    push(@m,'
-# This section creates the dynamically loadable $(INST_DYNAMIC)
-# from $(OBJECT) and possibly $(MYEXTLIB).
-ARMAYBE = '.$armaybe.'
-OTHERLDFLAGS = '.$otherldflags.'
-INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
-
-$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
-');
-    if ($armaybe ne ':'){
-	$ldfrom = 'tmp$(LIB_EXT)';
-	push(@m,'	$(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
-	push(@m,'	$(RANLIB) '."$ldfrom\n");
-    }
-    $ldfrom = "-all $ldfrom -none" if ($^O eq 'dec_osf');
-    push(@m,'	LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ $(LDDLFLAGS) '.$ldfrom.
-		' $(OTHERLDFLAGS) $(MYEXTLIB) $(LDLOADLIBS) $(EXPORT_LIST) $(PERL_ARCHIVE)');
+    my @m;
+    # We do not know what target was originally specified so we
+    # must force a manual rerun to be sure. But as it should only
+    # happen very rarely it is not a significant problem.
     push @m, '
-	$(CHMOD) 755 $@
-';
-
-    push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
-    join('',@m);
-}
-
-=item static (o)
-
-Defines the static target.
-
-=cut
-
-sub static {
-# --- Static Loading Sections ---
-
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    '
-## $(INST_PM) has been moved to the all: target.
-## It remains here for awhile to allow for old usage: "make static"
-#static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
-static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
-	'.$self->{NOECHO}.'$(NOOP)
-';
-}
-
-=item static_lib (o)
-
-Defines how to produce the *.a (or equivalent) files.
-
-=cut
-
-sub static_lib {
-    my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-# Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
-#    return '' unless $self->needs_linking(); #might be because of a subdir
-
-    return '' unless $self->has_link_code;
+$(OBJECT) : $(FIRST_MAKEFILE)
+' if $self->{OBJECT};
 
-    my(@m);
-    push(@m, <<'END');
-$(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
-END
-    # If this extension has it's own library (eg SDBM_File)
-    # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
-    push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
+    push @m, q{
+# We take a very conservative approach here, but it\'s worth it.
+# We move Makefile to Makefile.old here to avoid gnu make looping.
+}.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
+	}.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
+	}.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
+	-}.$self->{NOECHO}.q{mv }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
+	-$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean >/dev/null 2>&1 || true
+	$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
+	}.$self->{NOECHO}.q{echo ">>> Your Makefile has been rebuilt. <<<"
+	}.$self->{NOECHO}.q{echo ">>> Please rerun the make command.  <<<"; false
 
-    push @m,
-q{	$(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
-	}.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
-	$(CHMOD) 755 $@
+# To change behavior to :: would be nice, but would break Tk b9.02
+# so you find such a warning below the dist target.
+#}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
+#	}.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
 };
 
-# Old mechanism - still available:
-
-    push @m, "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs}."\n\n"
-	if $self->{PERL_SRC};
-
-    push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
-    join('', "\n",@m);
+    join "", @m;
 }
 
-# =item installpm
-#
-# Cares for copying and autosplitting the files in PM (which may be more
-# than just *.pm files) into the INST_* directories.
-#
-# =cut
-#
-# sub installpm {
-#     my($self, %attribs) = @_;
-#     unless (ref $self){
-# 	  ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-# 	  $self = $ExtUtils::MakeMaker::Parent[-1];
-#     }
-#     # By default .pm files are split into the architecture independent
-#     # library. This is a good thing. If a specific module requires that
-#     # its .pm files are split into the architecture specific library
-#     # then it should use: installpm => {SPLITLIB=>'$(INST_ARCHLIB)'}
-#     # Note that installperl currently interferes with this (Config.pm)
-#     # User can disable split by saying: installpm => {SPLITLIB=>''}
-#     my($splitlib) = '$(INST_LIB)'; # NOT arch specific by default
-#     $splitlib = $attribs{SPLITLIB} if exists $attribs{SPLITLIB};
-#     my(@m, $dist);
-#     push @m, "inst_pm :: \$(INST_PM)\n\n";
-#     foreach $dist (sort keys %{$self->{PM}}){
-# 	  my($inst) = $self->{PM}->{$dist};
-# 	  push(@m, "\n# installpm: $dist => $inst, splitlib=$splitlib\n");
-# 	  push(@m, $self->installpm_x($dist, $inst, $splitlib));
-# 	  push(@m, "\n");
-#     }
-#     join('', @m);
-# }
-#
-# =item installpm_x
-#
-# Helper subroutine to installpm.
-#
-# =cut
-#
-# sub installpm_x { # called by installpm per file
-#     my($self, $dist, $inst, $splitlib) = @_;
-#     unless (ref $self){
-# 	  ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-# 	  $self = $ExtUtils::MakeMaker::Parent[-1];
-#     }
-#     if ($inst =~ m,[:\#],){
-# 	  warn "Warning: 'make' would have problems processing this file: '$inst', SKIPPED\n";
-# 	  return '';
-#     }
-#     my($instdir) = $inst =~ m|(.*)/|;
-#     my(@m);
-#     push(@m,"
-# $inst: $dist $self->{FIRST_MAKEFILE} $instdir/.exists \$(INST_ARCHAUTODIR)/.exists
-# 	  $self->{NOECHO}$self->{RM_F}".' $@
-# 	  $(UMASK_NULL) && '."$self->{CP} $dist".' $@
-# ');
-#     push(@m, "\t$self->{NOECHO}\$(AUTOSPLITFILE) \$@ $splitlib/auto\n")
-# 	  if ($splitlib and $inst =~ m/\.pm$/);
-#
-#     push @m, $self->dir_target($instdir);
-#     join('', @m);
-# }
-
 =item manifypods (o)
 
 Defines targets and routines to translate the pods into manpages and
@@ -2235,17 +2169,13 @@ put them into the INST_* directories.
 
 sub manifypods {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    return "\nmanifypods :\n" unless %{$self->{MAN3PODS}};
+    return "\nmanifypods :\n\t$self->{NOECHO}\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
     my($dist);
     my($pod2man_exe);
     if (defined $self->{PERL_SRC}) {
 	$pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
     } else {
-	$pod2man_exe = $self->catfile($Config{bin},'pod2man');
+	$pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
     }
     unless ($self->perl_script($pod2man_exe)) {
 	# No pod2man but some MAN3PODS to be installed
@@ -2263,7 +2193,7 @@ qq[POD2MAN_EXE = $pod2man_exe\n],
 q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
 -e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
 -e 'print "Manifying $$m{$$_}\n";' \\
--e 'system("$$^X \\"-I$(PERL_ARCHLIB)\\" \\"-I$(PERL_LIB)\\" $(POD2MAN_EXE) $$_>$$m{$$_}")==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
+-e 'system(qq[$$^X ].q["-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
 -e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
 ];
     push @m, "\nmanifypods : ";
@@ -2277,559 +2207,419 @@ q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
     join('', @m);
 }
 
-=item processPL (o)
+=item maybe_command
 
-Defines targets to run *.PL files.
+Returns true, if the argument is likely to be a command.
 
 =cut
 
-sub processPL {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    return "" unless $self->{PL_FILES};
-    my(@m, $plfile);
-    foreach $plfile (sort keys %{$self->{PL_FILES}}) {
-	push @m, "
-all :: $self->{PL_FILES}->{$plfile}
-
-$self->{PL_FILES}->{$plfile} :: $plfile
-	\$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
-";
-    }
-    join "", @m;
+sub maybe_command {
+    my($self,$file) = @_;
+    return $file if -x $file && ! -d $file;
+    return;
 }
 
-=item installbin (o)
+=item maybe_command_in_dirs
 
-Defines targets to install EXE_FILES.
+method under development. Not yet used. Ask Ilya :-)
 
 =cut
 
-sub installbin {
-    my($self) = shift;
-    return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
-    return "" unless @{$self->{EXE_FILES}};
-    my(@m, $from, $to, %fromto, @to);
-    push @m, $self->dir_target(qw[$(INST_EXE)]);
-    for $from (@{$self->{EXE_FILES}}) {
-	my($path)= '$(INST_EXE)/' . basename($from);
-	local($_) = $path; # for backwards compatibility
-	$to = $self->libscan($path);
-	print "libscan($from) => '$to'\n" if ($Verbose >=2);
-	$fromto{$from}=$to;
-    }
-    @to   = values %fromto;
-    push(@m, "
-EXE_FILES = @{$self->{EXE_FILES}}
-
-all :: @to
-
-realclean ::
-	$self->{RM_F} @to
-");
-
-    while (($from,$to) = each %fromto) {
-	last unless defined $from;
-	my $todir = dirname($to);
-	push @m, "
-$to: $from $self->{MAKEFILE} $todir/.exists
-	$self->{NOECHO}$self->{RM_F} $to
-	$self->{CP} $from $to
-";
+sub maybe_command_in_dirs {	# $ver is optional argument if looking for perl
+# Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
+    my($self, $names, $dirs, $trace, $ver) = @_;
+    my($name, $dir);
+    foreach $dir (@$dirs){
+	next unless defined $dir; # $self->{PERL_SRC} may be undefined
+	foreach $name (@$names){
+	    my($abs,$tryabs);
+	    if ($self->file_name_is_absolute($name)) { # /foo/bar
+		$abs = $name;
+	    } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
+		$abs = $self->catfile($dir, $name);
+	    } else { # foo/bar
+		$abs = $self->catfile($self->curdir, $name);
+	    }
+	    print "Checking $abs for $name\n" if ($trace >= 2);
+	    next unless $tryabs = $self->maybe_command($abs);
+	    print "Substituting $tryabs instead of $abs\n"
+		if ($trace >= 2 and $tryabs ne $abs);
+	    $abs = $tryabs;
+	    if (defined $ver) {
+		print "Executing $abs\n" if ($trace >= 2);
+		if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
+		    print "Using PERL=$abs\n" if $trace;
+		    return $abs;
+		}
+	    } else { # Do not look for perl
+		return $abs;
+	    }
+	}
     }
-    join "", @m;
 }
 
-=item subdirs (o)
+=item needs_linking (o)
 
-Defines targets to process subdirectories.
+Does this module need linking? Looks into subdirectory objects (see
+also has_link_code())
 
 =cut
 
-sub subdirs {
-# --- Sub-directory Sections ---
+sub needs_linking {
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m,$dir);
-    # This method provides a mechanism to automatically deal with
-    # subdirectories containing further Makefile.PL scripts.
-    # It calls the subdir_x() method for each subdirectory.
-    foreach $dir (@{$self->{DIR}}){
-	push(@m, $self->subdir_x($dir));
-####	print "Including $dir subdirectory\n";
+    my($child,$caller);
+    $caller = (caller(0))[3];
+    Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
+    return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
+    if ($self->has_link_code or $self->{MAKEAPERL}){
+	$self->{NEEDS_LINKING} = 1;
+	return 1;
     }
-    if (@m){
-	unshift(@m, "
-# The default clean, realclean and test targets in this Makefile
-# have automatically been given entries for each subdir.
-
-");
-    } else {
-	push(@m, "\n# none")
+    foreach $child (keys %{$self->{CHILDREN}}) {
+	if ($self->{CHILDREN}->{$child}->needs_linking) {
+	    $self->{NEEDS_LINKING} = 1;
+	    return 1;
+	}
     }
-    join('',@m);
+    return $self->{NEEDS_LINKING} = 0;
 }
 
-=item subdir_x (o)
+=item nicetext
 
-Helper subroutine for subdirs
+misnamed method (will have to be changed). The MM_Unix method just
+returns the argument without further processing.
+
+On VMS used to insure that colons marking targets are preceded by
+space - most Unix Makes don't need this, but it's necessary under VMS
+to distinguish the target delimiter from a colon appearing as part of
+a filespec.
 
 =cut
 
-sub subdir_x {
-    my($self, $subdir) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m);
-    qq{
+sub nicetext {
+    my($self,$text) = @_;
+    $text;
+}
 
-subdirs ::
-	$self->{NOECHO}-cd $subdir && \$(MAKE) all \$(PASTHRU)
+=item parse_version
 
-};
+parse a file and return what you think is $VERSION in this file set to
+
+=cut
+
+sub parse_version {
+    my($self,$parsefile) = @_;
+    my $result;
+    local *FH;
+    local $/ = "\n";
+    open(FH,$parsefile) or die "Could not open '$parsefile': $!";
+    my $inpod = 0;
+    while (<FH>) {
+	$inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
+	next if $inpod;
+	chop;
+	next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
+	local $ExtUtils::MakeMaker::module_version_variable = $1;
+	my($thispackage) = $2 || $current_package;
+	$thispackage =~ s/:+$//;
+	my($eval) = "$_;";
+	eval $eval;
+	die "Could not eval '$eval' in $parsefile: $@" if $@;
+	$result = $ {$ExtUtils::MakeMaker::module_version_variable} || 0;
+	last;
+    }
+    close FH;
+    return $result;
 }
 
-=item clean (o)
 
-Defines the clean target.
+=item pasthru (o)
+
+Defines the string that is passed to recursive make calls in
+subdirectories.
 
 =cut
 
-sub clean {
-# --- Cleanup and Distribution Sections ---
+sub pasthru {
+    my($self) = shift;
+    my(@m,$key);
 
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m,$dir);
-    push(@m, '
-# Delete temporary files but do not touch installed files. We don\'t delete
-# the Makefile here so a later make realclean still has a makefile to use.
+    my(@pasthru);
 
-clean ::
-');
-    # clean subdirectories first
-    for $dir (@{$self->{DIR}}) {
-	push @m, "\t-cd $dir && test -f $self->{MAKEFILE} && \$(MAKE) clean\n";
+    foreach $key (qw(LIBPERL_A LINKTYPE PREFIX OPTIMIZE)){
+	push @pasthru, "$key=\"\$($key)\"";
     }
 
-    my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
-    push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
-    push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
-			 perlmain.c mon.out core so_locations pm_to_blib
-			 *~ */*~ */*/*~ *$(OBJ_EXT) *$(LIB_EXT) perl.exe
-			 $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def
-			 $(BASEEXT).exp
-			]);
-    push @m, "\t-$self->{RM_RF} @otherfiles\n";
-    # See realclean and ext/utils/make_ext for usage of Makefile.old
-    push(@m,
-	 "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old 2>/dev/null\n");
-    push(@m,
-	 "\t$attribs{POSTOP}\n")   if $attribs{POSTOP};
-    join("", @m);
+    push @m, "\nPASTHRU = ", join ("\\\n\t", @pasthru), "\n";
+    join "", @m;
 }
 
-=item realclean (o)
+=item path
 
-Defines the realclean target.
+Takes no argument, returns the environment variable PATH as an array.
 
 =cut
 
-sub realclean {
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m);
-    push(@m,'
-# Delete temporary files (via clean) and also delete installed files
-realclean purge ::  clean
-');
-    # realclean subdirectories first (already cleaned)
-    my $sub = "\t-cd %s && test -f %s && \$(MAKE) %s realclean\n";
-    foreach(@{$self->{DIR}}){
-	push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
-	push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
-    }
-    push(@m, "	$self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
-    push(@m, "	$self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
-#    push(@m, "	$self->{RM_F} \$(INST_STATIC) \$(INST_PM)\n");
-    push(@m, "	$self->{RM_F} \$(INST_STATIC)\n");
-    my(@otherfiles) = ($self->{MAKEFILE},
-		       "$self->{MAKEFILE}.old"); # Makefiles last
-    push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
-    push(@m, "	$self->{RM_RF} @otherfiles\n") if @otherfiles;
-    push(@m, "	$attribs{POSTOP}\n")       if $attribs{POSTOP};
-    join("", @m);
+sub path {
+    my($self) = @_;
+    my $path_sep = $Is_OS2 ? ";" : ":";
+    my $path = $ENV{PATH};
+    $path =~ s:\\:/:g if $Is_OS2;
+    my @path = split $path_sep, $path;
 }
 
-=item dist_basics (o)
+=item perl_script
 
-Defines the targets distclean, distcheck, skipcheck, manifest.
+Takes one argument, a file name, and returns the file name, if the
+argument is likely to be a perl script. On MM_Unix this is true for
+any ordinary, readable file.
 
 =cut
 
-sub dist_basics {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my @m;
-    push @m, q{
-distclean :: realclean distcheck
-};
-
-    push @m, q{
-distcheck :
-	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&fullcheck";' \\
-		-e 'fullcheck();'
-};
-
-    push @m, q{
-skipcheck :
-	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&skipcheck";' \\
-		-e 'skipcheck();'
-};
-
-    push @m, q{
-manifest :
-	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&mkmanifest";' \\
-		-e 'mkmanifest();'
-};
-    join "", @m;
+sub perl_script {
+    my($self,$file) = @_;
+    return $file if -r $file && -f _;
+    return;
 }
 
-=item dist_core (o)
+=item perldepend (o)
 
-Defeines the targets dist, tardist, zipdist, uutardist, shdist
+Defines the dependency from all *.h files that come with the perl
+distribution.
 
 =cut
 
-sub dist_core {
+sub perldepend {
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my @m;
+    my(@m);
     push @m, q{
-dist : $(DIST_DEFAULT)
-	}.$self->{NOECHO}.q{$(PERL) -le 'print "Warning: Makefile possibly out of date with $$vf" if ' \
-    	-e '-e ($$vf="$(VERSION_FROM)") and -M $$vf < -M "}.$self->{MAKEFILE}.q{";'
+# Check for unpropogated config.sh changes. Should never happen.
+# We do NOT just update config.h because that is not sufficient.
+# An out of date config.h is not fatal but complains loudly!
+$(PERL_INC)/config.h: $(PERL_SRC)/config.sh
+	-}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
 
-tardist : $(DISTVNAME).tar$(SUFFIX)
+$(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
+	}.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
+	cd $(PERL_SRC) && $(MAKE) lib/Config.pm
+} if $self->{PERL_SRC};
 
-zipdist : $(DISTVNAME).zip
+    return join "", @m unless $self->needs_linking;
 
-$(DISTVNAME).tar$(SUFFIX) : distdir
-	$(PREOP)
-	$(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
-	$(RM_RF) $(DISTVNAME)
-	$(COMPRESS) $(DISTVNAME).tar
-	$(POSTOP)
+    push @m, q{
+PERL_HDRS = \
+$(PERL_INC)/EXTERN.h       $(PERL_INC)/gv.h           $(PERL_INC)/pp.h       \
+$(PERL_INC)/INTERN.h       $(PERL_INC)/handy.h        $(PERL_INC)/proto.h    \
+$(PERL_INC)/XSUB.h         $(PERL_INC)/hv.h           $(PERL_INC)/regcomp.h  \
+$(PERL_INC)/av.h           $(PERL_INC)/keywords.h     $(PERL_INC)/regexp.h   \
+$(PERL_INC)/config.h       $(PERL_INC)/mg.h           $(PERL_INC)/scope.h    \
+$(PERL_INC)/cop.h          $(PERL_INC)/op.h           $(PERL_INC)/sv.h	     \
+$(PERL_INC)/cv.h           $(PERL_INC)/opcode.h       $(PERL_INC)/unixish.h  \
+$(PERL_INC)/dosish.h       $(PERL_INC)/patchlevel.h   $(PERL_INC)/util.h     \
+$(PERL_INC)/embed.h        $(PERL_INC)/perl.h				     \
+$(PERL_INC)/form.h         $(PERL_INC)/perly.h
 
-$(DISTVNAME).zip : distdir
-	$(PREOP)
-	$(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
-	$(POSTOP)
+$(OBJECT) : $(PERL_HDRS)
+} if $self->{OBJECT};
 
-uutardist : $(DISTVNAME).tar$(SUFFIX)
-	uuencode $(DISTVNAME).tar$(SUFFIX) \\
-		$(DISTVNAME).tar$(SUFFIX) > \\
-		$(DISTVNAME).tar$(SUFFIX)_uu
+    push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
 
-shdist : distdir
-	$(PREOP)
-	$(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
-	$(RM_RF) $(DISTVNAME)
-	$(POSTOP)
-};
-    join "", @m;
+    join "\n", @m;
 }
 
-=item dist_dir (o)
+=item pm_to_blib
 
-Defines the scratch directory target that will hold the distribution
-before tar-ing (or shar-ing).
+Defines target that copies all files in the hash PM to their
+destination and autosplits them. See L<ExtUtils::Install/pm_to_blib>
 
 =cut
 
-sub dist_dir {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my @m;
-    push @m, q{
-distdir :
-	$(RM_RF) $(DISTVNAME)
-	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "/mani/";' \\
-		-e 'manicopy(maniread(),"$(DISTVNAME)", "$(DIST_CP)");'
+sub pm_to_blib {
+    my $self = shift;
+    my($autodir) = $self->catdir('$(INST_LIB)','auto');
+    return q{
+pm_to_blib: $(TO_INST_PM)
+	}.$self->{NOECHO}.q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" \
+	"-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -MExtUtils::Install \
+        -e 'pm_to_blib({qw{$(PM_TO_BLIB)}},"}.$autodir.q{")'
+	}.$self->{NOECHO}.q{$(TOUCH) $@
 };
-    join "", @m;
 }
 
-=item dist_test (o)
+=item post_constants (o)
 
-Defines a target that produces the distribution in the
-scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that
-subdirectory.
+Returns an empty string per default. Dedicated to overrides from
+within Makefile.PL after all constants have been defined.
 
 =cut
 
-sub dist_test {
+sub post_constants{
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my @m;
-    push @m, q{
-disttest : distdir
-	cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
-	cd $(DISTVNAME) && $(MAKE)
-	cd $(DISTVNAME) && $(MAKE) test
-};
-    join "", @m;
+    "";
 }
 
-=item dist_ci (o)
+=item post_initialize (o)
 
-Defines a check in target for RCS.
+Returns an ampty string per default. Used in Makefile.PLs to add some
+chunk of text to the Makefile after the object is initialized.
 
 =cut
 
-sub dist_ci {
+sub post_initialize {
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my @m;
-    push @m, q{
-ci :
-	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&maniread";' \\
-		-e '@all = keys %{ maniread() };' \\
-		-e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
-		-e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
-};
-    join "", @m;
+    "";
 }
 
-=item install (o)
+=item postamble (o)
 
-Defines the install target.
+Returns an empty string. Can be used in Makefile.PLs to write some
+text to the Makefile at the end.
 
 =cut
 
-sub install {
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m);
-
-    push @m, q{
-install :: all pure_install doc_install
-
-install_perl :: all pure_perl_install doc_perl_install
-
-install_site :: all pure_site_install doc_site_install
-
-install_ :: install_site
-	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
-
-pure_install :: pure_$(INSTALLDIRS)_install
-
-doc_install :: doc_$(INSTALLDIRS)_install
-	}.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
-
-pure__install : pure_site_install
-	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
-
-doc__install : doc_site_install
-	@echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
+sub postamble {
+    my($self) = shift;
+    "";
+}
 
-pure_perl_install ::
-	}.$self->{NOECHO}.q{$(MOD_INSTALL) \
-		read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
-		write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
-		$(INST_LIB) $(INSTALLPRIVLIB) \
-		$(INST_ARCHLIB) $(INSTALLARCHLIB) \
-		$(INST_EXE) $(INSTALLBIN) \
-		$(INST_MAN1DIR) $(INSTALLMAN1DIR) \
-		$(INST_MAN3DIR) $(INSTALLMAN3DIR)
-	}.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
-		}.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
+=item prefixify
 
+Check a path variable in $self from %Config, if it contains a prefix,
+and replace it with another one.
 
-pure_site_install ::
-	}.$self->{NOECHO}.q{$(MOD_INSTALL) \
-		read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
-		write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
-		$(INST_LIB) $(INSTALLSITELIB) \
-		$(INST_ARCHLIB) $(INSTALLSITEARCH) \
-		$(INST_EXE) $(INSTALLBIN) \
-		$(INST_MAN1DIR) $(INSTALLMAN1DIR) \
-		$(INST_MAN3DIR) $(INSTALLMAN3DIR)
-	}.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
-		}.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
+Takes as arguments an attribute name, a search prefix and a
+replacement prefix. Changes the attribute in the object.
 
-doc_perl_install ::
-	}.$self->{NOECHO}.q{$(DOC_INSTALL) \
-		"$(NAME)" \
-		"installed into" "$(INSTALLPRIVLIB)" \
-		LINKTYPE "$(LINKTYPE)" \
-		VERSION "$(VERSION)" \
-		EXE_FILES "$(EXE_FILES)" \
-		>> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
+=cut
 
-doc_site_install ::
-	}.$self->{NOECHO}.q{$(DOC_INSTALL) \
-		"Module $(NAME)" \
-		"installed into" "$(INSTALLSITELIB)" \
-		LINKTYPE "$(LINKTYPE)" \
-		VERSION "$(VERSION)" \
-		EXE_FILES "$(EXE_FILES)" \
-		>> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
+sub prefixify {
+    my($self,$var,$sprefix,$rprefix) = @_;
+    $self->{uc $var} ||= $Config{lc $var};
+    $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
+    $self->{uc $var} =~ s/\Q$sprefix\E/$rprefix/;
+}
 
-};
+=item processPL (o)
 
-    push @m, q{
-uninstall :: uninstall_from_$(INSTALLDIRS)dirs
+Defines targets to run *.PL files.
 
-uninstall_from_perldirs ::
-	}.$self->{NOECHO}.
-	q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
+=cut
 
-uninstall_from_sitedirs ::
-	}.$self->{NOECHO}.
-	q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
-};
+sub processPL {
+    my($self) = shift;
+    return "" unless $self->{PL_FILES};
+    my(@m, $plfile);
+    foreach $plfile (sort keys %{$self->{PL_FILES}}) {
+	push @m, "
+all :: $self->{PL_FILES}->{$plfile}
 
-    join("",@m);
+$self->{PL_FILES}->{$plfile} :: $plfile
+	\$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
+";
+    }
+    join "", @m;
 }
 
-=item force (o)
+=item realclean (o)
 
-Just writes FORCE:
+Defines the realclean target.
 
 =cut
 
-sub force {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+sub realclean {
+    my($self, %attribs) = @_;
+    my(@m);
+    push(@m,'
+# Delete temporary files (via clean) and also delete installed files
+realclean purge ::  clean
+');
+    # realclean subdirectories first (already cleaned)
+    my $sub = "\t-cd %s && test -f %s && \$(MAKE) %s realclean\n";
+    foreach(@{$self->{DIR}}){
+	push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
+	push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
     }
-    '# Phony target to force checking subdirectories.
-FORCE:
-';
+    push(@m, "	$self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
+    if( $self->has_link_code ){
+        push(@m, "	$self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
+        push(@m, "	$self->{RM_F} \$(INST_STATIC)\n");
+    }
+    push(@m, "	$self->{RM_F} " . join(" ", values %{$self->{PM}}) . "\n");
+    my(@otherfiles) = ($self->{MAKEFILE},
+		       "$self->{MAKEFILE}.old"); # Makefiles last
+    push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
+    push(@m, "	$self->{RM_RF} @otherfiles\n") if @otherfiles;
+    push(@m, "	$attribs{POSTOP}\n")       if $attribs{POSTOP};
+    join("", @m);
 }
 
-=item perldepend (o)
+=item replace_manpage_separator
 
-Defines the dependency from all *.h files that come with the perl
-distribution.
+Takes the name of a package, which may be a nested package, in the
+form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
 
 =cut
 
-sub perldepend {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m);
-    push(@m,'
-PERL_HDRS = $(PERL_INC)/EXTERN.h $(PERL_INC)/INTERN.h \
-    $(PERL_INC)/XSUB.h	$(PERL_INC)/av.h	$(PERL_INC)/cop.h \
-    $(PERL_INC)/cv.h	$(PERL_INC)/dosish.h	$(PERL_INC)/embed.h \
-    $(PERL_INC)/form.h	$(PERL_INC)/gv.h	$(PERL_INC)/handy.h \
-    $(PERL_INC)/hv.h	$(PERL_INC)/keywords.h	$(PERL_INC)/mg.h \
-    $(PERL_INC)/op.h	$(PERL_INC)/opcode.h	$(PERL_INC)/patchlevel.h \
-    $(PERL_INC)/perl.h	$(PERL_INC)/perly.h	$(PERL_INC)/pp.h \
-    $(PERL_INC)/proto.h	$(PERL_INC)/regcomp.h	$(PERL_INC)/regexp.h \
-    $(PERL_INC)/scope.h	$(PERL_INC)/sv.h	$(PERL_INC)/unixish.h \
-    $(PERL_INC)/util.h	$(PERL_INC)/config.h
+sub replace_manpage_separator {
+    my($self,$man) = @_;
+    $man =~ s,/+,::,g;
+    $man;
+}
 
-');
+=item static (o)
 
-    push @m, '
-$(OBJECT) : $(PERL_HDRS)
-' if $self->{OBJECT};
+Defines the static target.
 
-    push(@m,'
-# Check for unpropogated config.sh changes. Should never happen.
-# We do NOT just update config.h because that is not sufficient.
-# An out of date config.h is not fatal but complains loudly!
-$(PERL_INC)/config.h: $(PERL_SRC)/config.sh
-	-'.$self->{NOECHO}.'echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
+=cut
 
-$(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
-	'.$self->{NOECHO}.'echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
-	cd $(PERL_SRC) && $(MAKE) lib/Config.pm
-') if $self->{PERL_SRC};
+sub static {
+# --- Static Loading Sections ---
 
-    push(@m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n")
-	if %{$self->{XS}};
-    join("\n",@m);
+    my($self) = shift;
+    '
+## $(INST_PM) has been moved to the all: target.
+## It remains here for awhile to allow for old usage: "make static"
+#static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
+static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
+	'.$self->{NOECHO}.'$(NOOP)
+';
 }
 
-=item makefile (o)
+=item static_lib (o)
 
-Defines how to rewrite the Makefile.
+Defines how to produce the *.a (or equivalent) files.
 
 =cut
 
-sub makefile {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my @m;
-    # We do not know what target was originally specified so we
-    # must force a manual rerun to be sure. But as it should only
-    # happen very rarely it is not a significant problem.
-    push @m, '
-$(OBJECT) : $(FIRST_MAKEFILE)
-' if $self->{OBJECT};
+sub static_lib {
+    my($self) = @_;
+# Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
+#    return '' unless $self->needs_linking(); #might be because of a subdir
 
-    push @m, q{
-# We take a very conservative approach here, but it\'s worth it.
-# We move Makefile to Makefile.old here to avoid gnu make looping.
-}.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
-	}.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
-	}.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
-	-}.$self->{NOECHO}.q{mv }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
-	-$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean >/dev/null 2>&1 || true
-	$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
-	}.$self->{NOECHO}.q{echo ">>> Your Makefile has been rebuilt. <<<"
-	}.$self->{NOECHO}.q{echo ">>> Please rerun the make command.  <<<"; false
+    return '' unless $self->has_link_code;
 
-# To change behavior to :: would be nice, but would break Tk b9.02
-# so you find such a warning below the dist target.
-#}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
-#	}.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
+    my(@m);
+    push(@m, <<'END');
+$(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
+	$(RM_RF) $@
+END
+    # If this extension has it's own library (eg SDBM_File)
+    # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
+    push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
+
+    push @m,
+q{	$(AR) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
+	}.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
+	$(CHMOD) 755 $@
 };
 
-    join "", @m;
+# Old mechanism - still available:
+
+    push @m, "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs}."\n\n"
+	if $self->{PERL_SRC};
+
+    push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
+    join('', "\n",@m);
 }
 
 =item staticmake (o)
@@ -2840,10 +2630,6 @@ Calls makeaperl.
 
 sub staticmake {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@static);
 
     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
@@ -2878,6 +2664,52 @@ sub staticmake {
 		    );
 }
 
+=item subdir_x (o)
+
+Helper subroutine for subdirs
+
+=cut
+
+sub subdir_x {
+    my($self, $subdir) = @_;
+    my(@m);
+    qq{
+
+subdirs ::
+	$self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
+
+};
+}
+
+=item subdirs (o)
+
+Defines targets to process subdirectories.
+
+=cut
+
+sub subdirs {
+# --- Sub-directory Sections ---
+    my($self) = shift;
+    my(@m,$dir);
+    # This method provides a mechanism to automatically deal with
+    # subdirectories containing further Makefile.PL scripts.
+    # It calls the subdir_x() method for each subdirectory.
+    foreach $dir (@{$self->{DIR}}){
+	push(@m, $self->subdir_x($dir));
+####	print "Including $dir subdirectory\n";
+    }
+    if (@m){
+	unshift(@m, "
+# The default clean, realclean and test targets in this Makefile
+# have automatically been given entries for each subdir.
+
+");
+    } else {
+	push(@m, "\n# none")
+    }
+    join('',@m);
+}
+
 =item test (o)
 
 Defines the test targets.
@@ -2888,18 +2720,17 @@ sub test {
 # --- Test and Installation Sections ---
 
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($tests) = $attribs{TESTS} || (-d "t" ? "t/*.t" : "");
     my(@m);
     push(@m,"
 TEST_VERBOSE=0
 TEST_TYPE=test_\$(LINKTYPE)
+TEST_FILE = test.pl
+TESTDB_SW = -d
 
-test :: \$(TEST_TYPE)
 testdb :: testdb_\$(LINKTYPE)
+
+test :: \$(TEST_TYPE)
 ");
     push(@m, map("\t$self->{NOECHO}cd $_ && test -f $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
 		 @{$self->{DIR}}));
@@ -2912,11 +2743,9 @@ testdb :: testdb_\$(LINKTYPE)
     push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
     push(@m, "\n");
 
-    if (-f "test.pl") {
-	push(@m, "testdb_dynamic :: pure_all\n");
-	push(@m, $self->test_via_script('$(FULLPERL) -d', 'test.pl'));
-	push(@m, "\n");
-    }
+    push(@m, "testdb_dynamic :: pure_all\n");
+    push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
+    push(@m, "\n");
 
     # Occasionally we may face this degenerate target:
     push @m, "test_ : test_dynamic\n\n";
@@ -2926,11 +2755,9 @@ testdb :: testdb_\$(LINKTYPE)
 	push(@m, $self->test_via_harness('./$(MAP_TARGET)', $tests)) if $tests;
 	push(@m, $self->test_via_script('./$(MAP_TARGET)', 'test.pl')) if -f "test.pl";
 	push(@m, "\n");
-	if (-f "test.pl") {
-	    push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
-	    push(@m, $self->test_via_script('./$(MAP_TARGET) -d', 'test.pl'));
-	    push(@m, "\n");
-	}
+	push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
+	push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
+	push(@m, "\n");
     } else {
 	push @m, "test_static :: test_dynamic\n";
 	push @m, "testdb_static :: testdb_dynamic\n";
@@ -2946,10 +2773,6 @@ Helper method to write the test targets
 
 sub test_via_harness {
     my($self, $perl, $tests) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     "\tPERL_DL_NONLAZY=1 $perl".q! -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' !."$tests\n";
 }
 
@@ -2961,301 +2784,279 @@ Other helper method for test.
 
 sub test_via_script {
     my($self, $perl, $script) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     qq{\tPERL_DL_NONLAZY=1 $perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
 };
 }
 
-=item postamble (o)
+=item tool_autosplit (o)
 
-Returns an empty string. Can be used in Makefile.PLs to write some
-text to the Makefile at the end.
+Defines a simple perl call that runs autosplit. May be deprecated by
+pm_to_blib soon.
 
 =cut
 
-sub postamble {
-    my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    "";
+sub tool_autosplit {
+# --- Tool Sections ---
+
+    my($self, %attribs) = @_;
+    my($asl) = "";
+    $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
+    q{
+# Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
+AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
+};
 }
 
-=item makeaperl (o)
+=item tools_other (o)
 
-Called by staticmake. Defines how to write the Makefile to produce a
-static new perl.
+Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
+the Makefile. Also defines the perl programs MKPATH,
+WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
 
 =cut
 
-sub makeaperl {
-    my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
+sub tools_other {
+    my($self) = shift;
+    my @m;
+    my $bin_sh = $Config{sh} || '/bin/sh';
+    push @m, qq{
+SHELL = $bin_sh
+};
+
+    for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TOUCH UMASK_NULL / ) {
+	push @m, "$_ = $self->{$_}\n";
     }
-    my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
-	@attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
-    my(@m);
-    push @m, "
-# --- MakeMaker makeaperl section ---
-MAP_TARGET    = $target
-FULLPERL      = $self->{FULLPERL}
-";
-    return join '', @m if $self->{PARENT};
 
-    my($dir) = join ":", @{$self->{DIR}};
 
-    unless ($self->{MAKEAPERL}) {
-	push @m, q{
-$(MAP_TARGET) :: $(MAKE_APERL_FILE)
-	$(MAKE) -f $(MAKE_APERL_FILE) static $@
+    push @m, q{
+# The following is a portable way to say mkdir -p
+# To see which directories are created, change the if 0 to if 1
+MKPATH = $(PERL) -wle '$$"="/"; foreach $$p (@ARGV){' \\
+-e 'next if -d $$p; my(@p); foreach(split(/\//,$$p)){' \\
+-e 'push(@p,$$_); next if -d "@p/"; print "mkdir @p" if 0;' \\
+-e 'mkdir("@p",0777)||die $$! } } exit 0;'
 
-$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
-	}.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
-	}.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
-		Makefile.PL DIR=}, $dir, q{ \
-		MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
-		MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
+# This helps us to minimize the effect of the .exists files A yet
+# better solution would be to have a stable file in the perl
+# distribution with a timestamp of zero. But this solution doesn't
+# need any changes to the core distribution and works with older perls
+EQUALIZE_TIMESTAMP = $(PERL) -we 'open F, ">$$ARGV[1]"; close F;' \\
+-e 'utime ((stat("$$ARGV[0]"))[8,9], $$ARGV[1])'
+};
 
-	push @m, map( " \\\n\t\t$_", @ARGV );
-	push @m, "\n";
+    return join "", @m if $self->{PARENT};
 
-	return join '', @m;
-    }
+    push @m, q{
+# Here we warn users that an old packlist file was found somewhere,
+# and that they should call some uninstall routine
+WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
+-e 'print "WARNING: I have found an old package in\n";' \\
+-e 'print "\t$$ARGV[0].\n";' \\
+-e 'print "Please make sure the two installations are not conflicting\n";'
 
+UNINST=0
+VERBINST=1
 
+MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
+-e 'install({@ARGV},"$(VERBINST)",0,"$(UNINST)");'
 
-    my($cccmd, $linkcmd, $lperl);
+DOC_INSTALL = $(PERL) -e '$$\="\n\n";print "=head3 ", scalar(localtime), ": C<", shift, ">";' \
+-e 'print "=over 4";' \
+-e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
+-e 'print "=back";'
 
+UNINSTALL =   $(PERL) -MExtUtils::Install \
+-e 'uninstall($$ARGV[0],1);'
 
-    $cccmd = $self->const_cccmd($libperl);
-    $cccmd =~ s/^CCCMD\s*=\s*//;
-    $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
-    $cccmd .= " $Config::Config{cccdlflags}" if ($Config::Config{d_shrplib});
-    $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
+};
 
-    # The front matter of the linkcommand...
-    $linkcmd = join ' ', "\$(CC)",
-	    grep($_, @Config{qw(large split ldflags ccdlflags)});
-    $linkcmd =~ s/\s+/ /g;
+    return join "", @m;
+}
 
-    # Which *.a files could we make use of...
-    local(%static);
-    require File::Find;
-    File::Find::find(sub {
-	return unless m/\Q$self->{LIB_EXT}\E$/;
-	return if m/^libperl/;
-	# don't include the installed version of this extension. I
-	# leave this line here, although it is not necessary anymore:
-	# I patched minimod.PL instead, so that Miniperl.pm won't
-	# enclude duplicates
+=item tool_xsubpp (o)
 
-	# Once the patch to minimod.PL is in the distribution, I can
-	# drop it
-	return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
-	use Cwd 'cwd';
-	$static{cwd() . "/" . $_}++;
-    }, grep( -d $_, @{$searchdirs || []}) );
+Determines typemaps, xsubpp version, prototype behaviour.
 
-    # We trust that what has been handed in as argument, will be buildable
-    $static = [] unless $static;
-    @static{@{$static}} = (1) x @{$static};
+=cut
 
-    $extra = [] unless $extra && ref $extra eq 'ARRAY';
-    for (sort keys %static) {
-	next unless /\Q$self->{LIB_EXT}\E$/;
-	$_ = dirname($_) . "/extralibs.ld";
-	push @$extra, $_;
+sub tool_xsubpp {
+    my($self) = shift;
+    return "" unless $self->needs_linking;
+    my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
+    my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
+    if( $self->{TYPEMAPS} ){
+	my $typemap;
+	foreach $typemap (@{$self->{TYPEMAPS}}){
+		if( ! -f  $typemap ){
+			warn "Typemap $typemap not found.\n";
+		}
+		else{
+			push(@tmdeps,  $typemap);
+		}
+	}
+    }
+    push(@tmdeps, "typemap") if -f "typemap";
+    my(@tmargs) = map("-typemap $_", @tmdeps);
+    if( exists $self->{XSOPT} ){
+ 	unshift( @tmargs, $self->{XSOPT} );
     }
 
-    grep(s/^/-I/, @{$perlinc || []});
 
-    $target = "perl" unless $target;
-    $tmp = "." unless $tmp;
+    my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
 
-# MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
-# regenerate the Makefiles, MAP_STATIC and the dependencies for
-# extralibs.all are computed correctly
-    push @m, "
-MAP_LINKCMD   = $linkcmd
-MAP_PERLINC   = @{$perlinc || []}
-MAP_STATIC    = ",
-join(" \\\n\t", reverse sort keys %static), "
+    # What are the correct thresholds for version 1 && 2 Paul?
+    if ( $xsubpp_version > 1.923 ){
+	$self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
+    } else {
+	if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
+	    print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
+	Your version of xsubpp is $xsubpp_version and cannot handle this.
+	Please upgrade to a more recent version of xsubpp.
+};
+	} else {
+	    $self->{XSPROTOARG} = "";
+	}
+    }
 
-MAP_PRELIBS   = $Config::Config{libs} $Config::Config{cryptlib}
-";
+    return qq{
+XSUBPPDIR = $xsdir
+XSUBPP = \$(XSUBPPDIR)/xsubpp
+XSPROTOARG = $self->{XSPROTOARG}
+XSUBPPDEPS = @tmdeps
+XSUBPPARGS = @tmargs
+};
+};
 
-    if (defined $libperl) {
-	($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
-    }
-    unless ($libperl && -f $lperl) { # Ilya's code...
-	my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
-	$libperl ||= "libperl$self->{LIB_EXT}";
-	$libperl   = "$dir/$libperl";
-	$lperl   ||= "libperl$self->{LIB_EXT}";
-	$lperl     = "$dir/$lperl";
-	print STDOUT "Warning: $libperl not found
-    If you're going to build a static perl binary, make sure perl is installed
-    otherwise ignore this warning\n"
-		unless (-f $lperl || defined($self->{PERL_SRC}));
-    }
+sub xsubpp_version
+{
+    my($self,$xsubpp) = @_;
+    return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
 
-    push @m, "
-MAP_LIBPERL = $libperl
-";
+    my ($version) ;
 
-    push @m, "
-\$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
-	$self->{NOECHO}$self->{RM_F} \$\@
-	$self->{NOECHO}\$(TOUCH) \$\@
-";
+    # try to figure out the version number of the xsubpp on the system
 
-    my $catfile;
-    foreach $catfile (@$extra){
-	push @m, "\tcat $catfile >> \$\@\n";
-    }
+    # first try the -v flag, introduced in 1.921 & 2.000a2
 
-    push @m, "
-\$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
-	\$(MAP_LINKCMD) -o \$\@ $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
-	$self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
-	$self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
-	$self->{NOECHO}echo 'To remove the intermediate files say'
-	$self->{NOECHO}echo '    make -f $makefilename map_clean'
+    return "" unless $self->needs_linking;
 
-$tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
-";
-    push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
+    my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
+    print "Running $command\n" if $Verbose >= 2;
+    $version = `$command` ;
+    warn "Running '$command' exits with status " . ($?>>8) if $?;
+    chop $version ;
 
-    push @m, qq{
-$tmp/perlmain.c: $makefilename}, q{
-	}.$self->{NOECHO}.q{echo Writing $@
-	}.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -e 'use ExtUtils::Miniperl; \\
-		writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)' > $@.tmp && mv $@.tmp $@
+    return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
 
-};
+    # nope, then try something else
 
-    push @m, q{
-doc_inst_perl:
-	}.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
-	}.$self->{NOECHO}.q{$(DOC_INSTALL) \
-		"Perl binary $(MAP_TARGET)" \
-		MAP_STATIC "$(MAP_STATIC)" \
-		MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
-		MAP_LIBPERL "$(MAP_LIBPERL)" \
-		>> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
+    my $counter = '000';
+    my ($file) = 'temp' ;
+    $counter++ while -e "$file$counter"; # don't overwrite anything
+    $file .= $counter;
 
-};
+    open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
+    print F <<EOM ;
+MODULE = fred PACKAGE = fred
 
-    push @m, qq{
-inst_perl: pure_inst_perl doc_inst_perl
+int
+fred(a)
+        int     a;
+EOM
 
-pure_inst_perl: \$(MAP_TARGET)
-	$self->{CP} \$(MAP_TARGET) \$(INSTALLBIN)/\$(MAP_TARGET)
+    close F ;
 
-clean :: map_clean
+    $command = "$self->{PERL} $xsubpp $file 2>&1";
+    print "Running $command\n" if $Verbose >= 2;
+    my $text = `$command` ;
+    warn "Running '$command' exits with status " . ($?>>8) if $?;
+    unlink $file ;
 
-map_clean :
-	$self->{RM_F} $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
-};
+    # gets 1.2 -> 1.92 and 2.000a1
+    return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
 
-    join '', @m;
+    # it is either 1.0 or 1.1
+    return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
+
+    # none of the above, so 1.0
+    return $Xsubpp_Version = "1.0" ;
 }
 
-=item dir_target (o)
+=item top_targets (o)
 
-Takes an array of directories that need to exist and returns a
-Makefile entry for a .exists file in these directories. Returns
-nothing, if the entry has already been processed. We're helpless
-though, if the same directory comes as $(FOO) _and_ as "bar". Both of
-them get an entry, that's why we use "::".
+Defines the targets all, subdirs, config, and O_FILES
 
 =cut
 
-sub dir_target {
-# --- Make-Directories section (internal method) ---
-# dir_target(@array) returns a Makefile entry for the file .exists in each
-# named directory. Returns nothing, if the entry has already been processed.
-# We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
-# Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
-# prerequisite, because there has to be one, something that doesn't change
-# too often :)
+sub top_targets {
+# --- Target Sections ---
 
-    my($self,@dirs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    my(@m,$dir);
-    foreach $dir (@dirs) {
-	my($src) = $self->catfile($self->{PERL_INC},'perl.h');
-	my($targ) = $self->catfile($dir,'.exists');
-	my($targdir) = $targ;       # Necessary because catfile may have
-	$targdir =~ s:/?.exists$::; # adapted syntax of $dir to target OS
-	next if $self->{DIR_TARGET}{$self}{$targdir}++;
-	push @m, qq{
-$targ :: $src
-	$self->{NOECHO}\$(MKPATH) $targdir
-	$self->{NOECHO}\$(EQUALIZE_TIMESTAMP) $src $targ
-};
-	push(@m,qq{
-	-$self->{NOECHO}\$(CHMOD) 755 $targdir
-}) unless $Is_VMS;
-    }
-    join "", @m;
-}
+    my($self) = shift;
+    my(@m);
+    push @m, '
+#all ::	config $(INST_PM) subdirs linkext manifypods
 
-=item needs_linking (o)
+all :: pure_all manifypods
+	'.$self->{NOECHO}.'$(NOOP)
 
-Does this module need linking? Looks into subdirectory objects (see
-also has_link_code())
+pure_all :: config pm_to_blib subdirs linkext
+	'.$self->{NOECHO}.'$(NOOP)
 
-=cut
+subdirs :: $(MYEXTLIB)
+	'.$self->{NOECHO}.'$(NOOP)
 
-sub needs_linking {
-    my($self) = shift;
-    my($child,$caller);
-    $caller = (caller(0))[3];
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse($caller);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
-    return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
-    if ($self->has_link_code or $self->{MAKEAPERL}){
-	$self->{NEEDS_LINKING} = 1;
-	return 1;
+config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
+	'.$self->{NOECHO}.'$(NOOP)
+
+config :: $(INST_ARCHAUTODIR)/.exists
+	'.$self->{NOECHO}.'$(NOOP)
+
+config :: $(INST_AUTODIR)/.exists
+	'.$self->{NOECHO}.'$(NOOP)
+';
+
+    push @m, qq{
+config :: Version_check
+	$self->{NOECHO}\$(NOOP)
+
+} unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
+
+    push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
+
+    if (%{$self->{MAN1PODS}}) {
+	push @m, qq[
+config :: \$(INST_MAN1DIR)/.exists
+	$self->{NOECHO}\$(NOOP)
+
+];
+	push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
     }
-    foreach $child (keys %{$self->{CHILDREN}}) {
-	if ($self->{CHILDREN}->{$child}->needs_linking) {
-	    $self->{NEEDS_LINKING} = 1;
-	    return 1;
-	}
+    if (%{$self->{MAN3PODS}}) {
+	push @m, qq[
+config :: \$(INST_MAN3DIR)/.exists
+	$self->{NOECHO}\$(NOOP)
+
+];
+	push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
     }
-    return $self->{NEEDS_LINKING} = 0;
-}
 
-=item has_link_code
+    push @m, '
+$(O_FILES): $(H_FILES)
+' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
 
-Returns true if C, XS, MYEXTLIB or similar objects exist within this
-object that need a compiler. Does not descend into subdirectories as
-needs_linking() does.
+    push @m, q{
+help:
+	perldoc ExtUtils::MakeMaker
+};
 
-=cut
+    push @m, q{
+Version_check:
+	}.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
+		-MExtUtils::MakeMaker=Version_check \
+		-e 'Version_check("$(MM_VERSION)")'
+};
 
-sub has_link_code {
-    my($self) = shift;
-    return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
-    if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
-	$self->{HAS_LINK_CODE} = 1;
-	return 1;
-    }
-    return $self->{HAS_LINK_CODE} = 0;
+    join('',@m);
 }
 
 =item writedoc
@@ -3267,16 +3068,44 @@ Obsolete, depecated method. Not used since Version 5.21.
 sub writedoc {
 # --- perllocal.pod section ---
     my($self,$what,$name,@attribs)=@_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my $time = localtime;
     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
     print "\n\n=back\n\n";
 }
 
+=item xs_c (o)
+
+Defines the suffix rules to compile XS files to C.
+
+=cut
+
+sub xs_c {
+    my($self) = shift;
+    return '' unless $self->needs_linking();
+    '
+.xs.c:
+	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && mv $*.tc $@
+';
+}
+
+=item xs_o (o)
+
+Defines suffix rules to go from XS to object files directly. This is
+only intended for broken make implementations.
+
+=cut
+
+sub xs_o {	# many makes are too dumb to use xs_c then c_o
+    my($self) = shift;
+    return '' unless $self->needs_linking();
+    '
+.xs$(OBJ_EXT):
+	$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && mv xstmp.c $*.c
+	$(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
+';
+}
+
 1;
 
 
diff --git a/lib/ExtUtils/MM_VMS.pm b/lib/ExtUtils/MM_VMS.pm
index 9b9889ac8f..9a382284d1 100644
--- a/lib/ExtUtils/MM_VMS.pm
+++ b/lib/ExtUtils/MM_VMS.pm
@@ -6,7 +6,7 @@
 #   Author:  Charles Bailey  bailey@genetics.upenn.edu
 
 package ExtUtils::MM_VMS;
-$ExtUtils::MM_VMS::Revision=$ExtUtils::MM_VMS::Revision = '5.26 (17-Mar-1996)';
+$ExtUtils::MM_VMS::Revision=$ExtUtils::MM_VMS::Revision = '5.35 (23-Jun-1996)';
 unshift @MM::ISA, 'ExtUtils::MM_VMS';
 
 use Config;
@@ -42,10 +42,6 @@ as a file specification in Unix syntax.
 
 sub eliminate_macros {
     my($self,$path) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     unless ($path) {
 	print "eliminate_macros('') = ||\n" if $Verbose >= 3;
 	return '';
@@ -81,10 +77,6 @@ specification.
 
 sub fixpath {
     my($self,$path,$force_path) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     unless ($path) {
 	print "eliminate_macros('') = ||\n" if $Verbose >= 3;
 	return '';
@@ -123,10 +115,6 @@ VMS-syntax directory specification.
 
 sub catdir {
     my($self,@dirs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($dir) = pop @dirs;
     @dirs = grep($_,@dirs);
     my($rslt);
@@ -151,10 +139,6 @@ VMS-syntax directory specification.
 
 sub catfile {
     my($self,@files) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($file) = pop @files;
     @files = grep($_,@files);
     my($rslt);
@@ -173,6 +157,36 @@ sub catfile {
     $rslt;
 }
 
+=item curdir (override)
+
+Returns a string representing of the current directory.
+
+=cut
+
+sub curdir {
+    return '[]';
+}
+
+=item rootdir (override)
+
+Returns a string representing of the root directory.
+
+=cut
+
+sub rootdir {
+    return '';
+}
+
+=item updir (override)
+
+Returns a string representing of the parent directory.
+
+=cut
+
+sub updir {
+    return '[-]';
+}
+
 package ExtUtils::MM_VMS;
 
 sub ExtUtils::MM_VMS::guess_name;
@@ -226,10 +240,12 @@ sub ExtUtils::MM_VMS::nicetext;
 sub AUTOLOAD {
     my $code;
     if (defined fileno(DATA)) {
-	while (<DATA>) {
-	    last if /^__END__/;
-	    $code .= $_;
-	}
+	my $fh = select DATA;
+	my $o = $/;			# For future reads from the file.
+	$/ = "\n__END__\n";
+	$code = <DATA>;
+	$/ = $o;
+	select $fh;
 	close DATA;
 	eval $code;
 	if ($@) {
@@ -245,7 +261,7 @@ sub AUTOLOAD {
 
 1;
 
-__DATA__
+#__DATA__
 
 =head2 SelfLoaded methods
 
@@ -268,18 +284,12 @@ package name.
 
 sub guess_name {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($defname,$defpm);
     local *PM;
 
-    $defname = $ENV{'DEFAULT'};
-    $defname =~ s:.*?([^.\]]+)\]:$1:
-        unless ($defname =~ s:.*[.\[]ext\.(.*)\]:$1:i);
-    $defname =~ s#[.\]]#::#g;
-    ($defpm = $defname) =~ s/.*:://;
+    $defname = basename(fileify($ENV{'DEFAULT'}));
+    $defname =~ s![\d\-_]*\.dir.*$!!;  # Clip off .dir;1 suffix, and package version
+    $defpm = $defname;
     if (open(PM,"${defpm}.pm")){
         while (<PM>) {
             if (/^\s*package\s+([^;]+)/i) {
@@ -296,7 +306,7 @@ sub guess_name {
         print STDOUT "Warning (non-fatal): Couldn't find ${defpm}.pm;\n\t",
                      "defaulting package name to $defname\n";
     }
-    $defname =~ s#[\-_][\d.\-]+$##;
+    $defname =~ s#[\d.\-_]+$##;
     $defname;
 }
 
@@ -309,10 +319,6 @@ invoke Perl images.
 
 sub find_perl{
     my($self, $ver, $names, $dirs, $trace) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($name,$dir,$vmsfile,@sdirs,@snames,@cand);
     # Check in relative directories first, so we pick up the current
     # version of Perl if we're running MakeMaker as part of the main build.
@@ -344,6 +350,7 @@ sub find_perl{
     foreach $name (@cand) {
 	print "Checking $name\n" if ($trace >= 2);
 	next unless $vmsfile = $self->maybe_command($name);
+	$vmsfile =~ s/;[\d\-]*$//;  # Clip off version number; we can use a newer version as well
 	print "Executing $vmsfile\n" if ($trace >= 2);
 	if (`MCR $vmsfile -e "require $ver; print ""VER_OK\n"""` =~ /VER_OK/) {
 	    print "Using PERL=MCR $vmsfile\n" if $trace;
@@ -475,10 +482,6 @@ off to the default MM_Unix method.
 
 sub init_others {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 
     $self->{NOOP} = "\t@ Continue";
     $self->{FIRST_MAKEFILE} ||= 'Descrip.MMS';
@@ -505,10 +508,6 @@ and makes lists of files comma-separated.
 
 sub constants {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m,$def,$macro);
 
     if ($self->{DEFINE} ne '') {
@@ -543,10 +542,11 @@ sub constants {
     $self->{ROOTEXT} = $self->{ROOTEXT} ? $self->fixpath($self->{ROOTEXT},1)
                                         : '[]';
     foreach $macro ( qw [
-            INST_LIB INST_ARCHLIB INST_EXE INSTALLPRIVLIB INSTALLARCHLIB
-            INSTALLBIN PERL_LIB PERL_ARCHLIB PERL_INC PERL_SRC FULLEXT
-            INST_MAN1DIR INSTALLMAN1DIR INST_MAN3DIR INSTALLMAN3DIR
-            INSTALLSITELIB INSTALLSITEARCH SITELIBEXP SITEARCHEXP ] ) {
+            INST_BIN INST_SCRIPT INST_LIB INST_ARCHLIB INST_EXE INSTALLPRIVLIB
+            INSTALLARCHLIB INSTALLSCRIPT INSTALLBIN PERL_LIB PERL_ARCHLIB
+            PERL_INC PERL_SRC FULLEXT INST_MAN1DIR INSTALLMAN1DIR
+            INST_MAN3DIR INSTALLMAN3DIR INSTALLSITELIB INSTALLSITEARCH
+            SITELIBEXP SITEARCHEXP ] ) {
 	next unless defined $self->{$macro};
 	$self->{$macro} = $self->fixpath($self->{$macro},1);
     }
@@ -561,16 +561,17 @@ sub constants {
 	$self->{$macro} = $self->fixpath($self->{$macro});
     }
 
-    for $tmp (qw/
+    foreach $macro (qw/
 	      AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION VERSION_SYM XS_VERSION
-	      INST_LIB INST_ARCHLIB INST_EXE PREFIX INSTALLDIRS INSTALLPRIVLIB
-	      INSTALLARCHLIB INSTALLSITELIB INSTALLSITEARCH INSTALLBIN PERL_LIB
+	      INST_BIN INST_EXE INST_LIB INST_ARCHLIB INST_SCRIPT PREFIX
+	      INSTALLDIRS INSTALLPRIVLIB  INSTALLARCHLIB INSTALLSITELIB
+	      INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
 	      PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
 	      FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC PERL_VMS
 	      PERL_INC PERL FULLPERL
 	      / ) {
-	next unless defined $self->{$tmp};
-	push @m, "$tmp = $self->{$tmp}\n";
+	next unless defined $self->{$macro};
+	push @m, "$macro = $self->{$macro}\n";
     }
 
 
@@ -587,18 +588,36 @@ MM_VMS_REVISION = $ExtUtils::MM_VMS::Revision
 
 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
-# ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
+# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
 # DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
 ];
 
     for $tmp (qw/
-	      FULLEXT BASEEXT ROOTEXT DLBASE VERSION_FROM INC DEFINE OBJECT
+	      FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
 	      LDFROM LINKTYPE
 	      /	) {
 	next unless defined $self->{$tmp};
 	push @m, "$tmp = $self->{$tmp}\n";
     }
 
+    for $tmp (qw/ XS MAN1PODS MAN3PODS PM /) {
+	next unless defined $self->{$tmp};
+	my(%tmp,$key);
+	for $key (keys %{$self->{$tmp}}) {
+	    $tmp{$self->fixpath($key)} = $self->fixpath($self->{$tmp}{$key});
+	}
+	$self->{$tmp} = \%tmp;
+    }
+
+    for $tmp (qw/ C O_FILES H /) {
+	next unless defined $self->{$tmp};
+	my(@tmp,$val);
+	for $val (@{$self->{$tmp}}) {
+	    push(@tmp,$self->fixpath($val));
+	}
+	$self->{$tmp} = \@tmp;
+    }
+
     push @m,'
 
 # Handy lists of source code files:
@@ -619,7 +638,7 @@ MAN3PODS = ',join(', ', sort keys %{$self->{MAN3PODS}}),'
     }
 
 push @m,"
-.SUFFIXES : .xs .c .cpp .cxx \$(OBJ_EXT)
+.SUFFIXES : \$(OBJ_EXT) .c .cpp .cxx .xs
 
 # Here is the Config.pm that we are using/depend on
 CONFIGDEP = \$(PERL_ARCHLIB)Config.pm, \$(PERL_INC)config.h \$(VERSION_FROM)
@@ -648,8 +667,8 @@ PERL_ARCHIVE = ',($ENV{'PERLSHR'} ? $ENV{'PERLSHR'} : 'Sys$Share:PerlShr.Exe'),'
 ';
     }
 
-    $self->{TO_INST_PM} = [ map($self->fixpath($_),sort keys %{$self->{PM}}) ];
-    $self->{PM_TO_BLIB} = [ map($self->fixpath($_),%{$self->{PM}}) ];
+    $self->{TO_INST_PM} = [ sort keys %{$self->{PM}} ];
+    $self->{PM_TO_BLIB} = [ %{$self->{PM}} ];
     push @m,'
 TO_INST_PM = ',join(', ',@{$self->{TO_INST_PM}}),'
 
@@ -669,10 +688,6 @@ to ExtUtils::Liblist.
 
 sub const_loadlibs{
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my (@m);
     push @m, "
 # $self->{NAME} might depend on some other libraries.
@@ -726,10 +741,6 @@ on the command line.
 
 sub cflags {
     my($self,$libperl) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($quals) = $Config{'ccflags'};
     my($name,$sys,@m);
     my($optimize) = '/Optimize';
@@ -796,10 +807,6 @@ command line a bit differently than MM_Unix method.
 
 sub const_cccmd {
     my($self,$libperl) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m);
 
     return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
@@ -839,10 +846,6 @@ command line to find args.
 
 sub pm_to_blib {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($line,$from,$to,@m);
     my($autodir) = $self->catdir('$(INST_LIB)','auto');
     my(@files) = @{$self->{PM_TO_BLIB}};
@@ -861,6 +864,7 @@ pm_to_blib : $(TO_INST_PM)
 	    $line = '';
 	}
     }
+    push(@m,"\t$self->{NOECHO}\$(PERL) -e \"print '$line'\" >>.MM_tmp\n") if $line;
 
     push(@m,q[	$(PERL) "-I$(PERL_LIB)" "-MExtUtils::Install" -e "pm_to_blib({split(' ',<STDIN>)},'].$autodir.q[')" <.MM_tmp]);
     push(@m,qq[
@@ -879,10 +883,6 @@ Use VMS-style quoting on command line.
 
 sub tool_autosplit{
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($asl) = "";
     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
     q{
@@ -897,12 +897,9 @@ Use VMS-style quoting on xsubpp command line.
 
 =cut
 
-sub tool_xsubpp{
+sub tool_xsubpp {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
+    return '' unless $self->needs_linking;
     my($xsdir) = $self->catdir($self->{PERL_LIB},'ExtUtils');
     # drop back to old location if xsubpp is not in new location yet
     $xsdir = $self->catdir($self->{PERL_SRC},'ext') unless (-f $self->catfile($xsdir,'xsubpp'));
@@ -960,6 +957,7 @@ sub xsubpp_version
 {
     my($self,$xsubpp) = @_;
     my ($version) ;
+    return '' unless $self->needs_linking;
 
     # try to figure out the version number of the xsubpp on the system
 
@@ -1021,10 +1019,6 @@ to be updated.
 
 sub tools_other {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     qq!
 # Assumes \$(MMS) invokes MMS or MMK
 # (It is assumed in some cases later that the default makefile name
@@ -1041,12 +1035,13 @@ MV = $self->{MV}
 RM_F  = $self->{RM_F}
 RM_RF = $self->{RM_RF}
 UMASK_NULL = $self->{UMASK_NULL}
+NOOP = $self->{NOOP}
 MKPATH = Create/Directory
 EQUALIZE_TIMESTAMP = \$(PERL) -we "open F,qq{>\$ARGV[1]};close F;utime(0,(stat(\$ARGV[0]))[9]+1,\$ARGV[1])"
 !. ($self->{PARENT} ? '' : 
-q!WARN_IF_OLD_PACKLIST = \$(PERL) -e "if (-f \$ARGV[0]){print qq[WARNING: Old package found (\$ARGV[0]); please check for collisions\\n]}"
+qq!WARN_IF_OLD_PACKLIST = \$(PERL) -e "if (-f \$ARGV[0]){print qq[WARNING: Old package found (\$ARGV[0]); please check for collisions\\n]}"
 MOD_INSTALL = \$(PERL) "-I\$(PERL_LIB)" "-MExtUtils::Install" -e "install({split(' ',<STDIN>)},1);"
-DOC_INSTALL = \$(PERL) -e "@ARGV=split('|',<STDIN>);print '=head3 ',scalar(localtime),': C<',shift,qq[>\\n\\n=over 4\\n\\n];while(\$key=shift && \$val=shift){print qq[=item *\\n\\nC<\$key: \$val>\\n\\n];}print qq[=back\\n\\n]"
+DOC_INSTALL = \$(PERL) -e "\@ARGV=split('|',<STDIN>);print '=head3 ',scalar(localtime),': C<',shift,qq[>\\n\\n=over 4\\n\\n];while(\$key=shift && \$val=shift){print qq[=item *\\n\\nC<\$key: \$val>\\n\\n];}print qq[=back\\n\\n]"
 UNINSTALL = \$(PERL) "-I\$(PERL_LIB)" "-MExtUtils::Install" -e "uninstall(\$ARGV[0],1);"
 !);
 }
@@ -1060,10 +1055,7 @@ default MM_Unix method.
 
 sub dist {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
+    $attribs{VERSION}      ||= $self->{VERSION_SYM};
     $attribs{ZIPFLAGS}     ||= '-Vu';
     $attribs{COMPRESS}     ||= 'gzip';
     $attribs{SUFFIX}       ||= '-gz';
@@ -1082,10 +1074,6 @@ $(PERL_INC) have been pulled into $(CCCMD).  Also use MM[SK] macros.
 
 sub c_o {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return '' unless $self->needs_linking();
     '
 .c$(OBJ_EXT) :
@@ -1108,10 +1096,6 @@ Use MM[SK] macros.
 
 sub xs_c {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return '' unless $self->needs_linking();
     '
 .xs.c :
@@ -1127,10 +1111,6 @@ Use MM[SK] macros, and VMS command line for C compiler.
 
 sub xs_o {	# many makes are too dumb to use xs_c then c_o
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return '' unless $self->needs_linking();
     '
 .xs$(OBJ_EXT) :
@@ -1147,10 +1127,6 @@ Use VMS quoting on command line for Version_check.
 
 sub top_targets {
     my($self) = shift;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m);
     push @m, '
 all :: pure_all manifypods
@@ -1223,10 +1199,6 @@ libraries to which it should be linked.
 
 sub dlsyms {
     my($self,%attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 
     return '' unless $self->needs_linking();
 
@@ -1285,10 +1257,6 @@ Use VMS Link command.
 
 sub dynamic_lib {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return '' unless $self->needs_linking(); #might be because of a subdir
 
     return '' unless $self->has_link_code();
@@ -1320,10 +1288,6 @@ Use VMS-style quoting on Mkbootstrap command line.
 
 sub dynamic_bs {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return '
 BOOTSTRAP =
 ' unless $self->has_link_code();
@@ -1353,10 +1317,6 @@ Use VMS commands to manipulate object library.
 
 sub static_lib {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return '' unless $self->needs_linking();
 
     return '
@@ -1387,10 +1347,6 @@ $(INST_STATIC) : $(OBJECT) $(MYEXTLIB)
 
 # sub installpm_x { # called by installpm perl file
 #     my($self, $dist, $inst, $splitlib) = @_;
-#     unless (ref $self){
-# 	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-# 	$self = $ExtUtils::MakeMaker::Parent[-1];
-#     }
 #     if ($inst =~ m!#!) {
 # 	warn "Warning: MM[SK] would have problems processing this file: $inst, SKIPPED\n";
 # 	return '';
@@ -1421,19 +1377,16 @@ to specify fallback location at build time if we can't find pod2man.
 
 =cut
 
+
 sub manifypods {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
-    return "\nmanifypods :\n\t\$(NOOP)\n" unless %{$self->{MAN3PODS}};
+    return "\nmanifypods :\n\t\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
     my($dist);
-    my($pod2man_exe,$found_pod2man);
+    my($pod2man_exe);
     if (defined $self->{PERL_SRC}) {
 	$pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
     } else {
-	$pod2man_exe = $self->catfile($Config{bin},'pod2man');
+	$pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
     }
     if ($pod2man_exe = $self->perl_script($pod2man_exe)) { $found_pod2man = 1; }
     else {
@@ -1478,10 +1431,6 @@ Use VMS-style quoting on command line.
 
 sub processPL {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return "" unless $self->{PL_FILES};
     my(@m, $plfile);
     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
@@ -1506,15 +1455,11 @@ in C<realclean> target.
 
 sub installbin {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     return '' unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
     return '' unless @{$self->{EXE_FILES}};
     my(@m, $from, $to, %fromto, @to, $line);
     for $from (@{$self->{EXE_FILES}}) {
-	my($path) = '$(INST_EXE)' . basename($from);
+	my($path) = '$(INST_SCRIPT)' . basename($from);
 	local($_) = $path;  # backward compatibility
 	$to = $self->libscan($path);
 	print "libscan($from) => '$to'\n" if ($Verbose >=2);
@@ -1537,7 +1482,7 @@ realclean ::
 	}
 	else { $line .= " $to"; }
     }
-    push @m, "\t\$(RM_F) $line\n\n";
+    push @m, "\t\$(RM_F) $line\n\n" if $line;
 
     while (($from,$to) = each %fromto) {
 	last unless defined $from;
@@ -1562,10 +1507,6 @@ Use VMS commands to change default directory.
 
 sub subdir_x {
     my($self, $subdir) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m,$key);
     $subdir = $self->fixpath($subdir,1);
     push @m, '
@@ -1589,10 +1530,6 @@ commands for handling subdirectories.
 
 sub clean {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m,$dir);
     push @m, '
 # Delete temporary files but do not touch installed files. We don\'t delete
@@ -1621,7 +1558,7 @@ clean ::
 	}
 	else { $line .= " $file"; }
     }
-    push @m, "\t\$(RM_RF) $line\n\n";
+    push @m, "\t\$(RM_RF) $line\n" if line;
     push(@m, "	$attribs{POSTOP}\n") if $attribs{POSTOP};
     join('', @m);
 }
@@ -1634,10 +1571,6 @@ Guess what we're working around?  Also, use MM[SK] for subdirectories.
 
 sub realclean {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m);
     push(@m,'
 # Delete temporary files (via clean) and also delete installed files
@@ -1655,7 +1588,10 @@ realclean :: clean
     # combination of macros).  In order to stay below DCL's 255 char limit,
     # we put only 2 on a line.
     my($file,$line,$fcnt);
-    my(@files) = qw{ $(INST_DYNAMIC) $(INST_STATIC) $(INST_BOOT) $(OBJECT) $(MAKEFILE) $(MAKEFILE)_old };
+    my(@files) = qw{ $(MAKEFILE) $(MAKEFILE)_old };
+    if ($self->has_link_code) {
+	push(@files,qw{ $(INST_DYNAMIC) $(INST_STATIC) $(INST_BOOT) $(OBJECT) });
+    }
     push(@files, values %{$self->{PM}});
     $line = '';  #avoid unitialized var warning
     foreach $file (@files) {
@@ -1667,7 +1603,7 @@ realclean :: clean
 	}
 	else { $line .= " $file"; }
     }
-    push @m, "\t\$(RM_F) $line\n";
+    push @m, "\t\$(RM_F) $line\n" if $line;
     if ($attribs{FILES} && ref $attribs{FILES} eq 'ARRAY') {
 	$line = '';
 	foreach $file (@{$attribs{'FILES'}}) {
@@ -1678,7 +1614,7 @@ realclean :: clean
 	    }
 	    else { $line .= " $file"; }
 	}
-	push @m, "\t\$(RM_RF) $line\n";
+	push @m, "\t\$(RM_RF) $line\n" if $line;
     }
     push(@m, "	$attribs{POSTOP}\n")                     if $attribs{POSTOP};
     join('', @m);
@@ -1692,10 +1628,6 @@ Use VMS-style quoting on command line.
 
 sub dist_basics {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 '
 distclean :: realclean distcheck
 	$(NOOP)
@@ -1711,7 +1643,7 @@ manifest :
 ';
 }
 
-=sub dist_core (override)
+=item dist_core (override)
 
 Syntax for invoking F<VMS_Share> differs from that for Unix F<shar>,
 so C<shdist> target actions are VMS-specific.
@@ -1720,10 +1652,6 @@ so C<shdist> target actions are VMS-specific.
 
 sub dist_core {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 q[
 dist : $(DIST_DEFAULT)
 	].$self->{NOECHO}.q[$(PERL) -le "print 'Warning: $m older than $vf' if -e ($vf = '$(VERSION_FROM)') && -M $vf < -M ($m = '$(MAKEFILE)'"
@@ -1737,6 +1665,14 @@ $(DISTVNAME).zip : distdir
 	$(RM_RF) $(DISTVNAME)
 	$(POSTOP)
 
+$(DISTVNAME).tar$(SUFFIX) : distdir
+	$(PREOP)
+	$(TO_UNIX)
+	$(TAR) "$(TARFLAGS)" $(DISTVNAME).tar $(SRC)
+	$(RM_RF) $(DISTVNAME)
+	$(COMPRESS) $(DISTVNAME).tar
+	$(POSTOP)
+
 shdist : distdir
 	$(PREOP)
 	$(SHARE) $(SRC) $(DISTVNAME).share
@@ -1753,10 +1689,6 @@ Use VMS-style quoting on command line.
 
 sub dist_dir {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 q{
 distdir :
 	$(RM_RF) $(DISTVNAME)
@@ -1774,10 +1706,6 @@ quoting on command line.
 
 sub dist_test {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
 q{
 disttest : distdir
 	startdir = F$Environment("Default")
@@ -1800,10 +1728,6 @@ VMS-style command line quoting in a few cases.
 
 sub install {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m,@docfiles);
 
     if ($self->{EXE_FILES}) {
@@ -1849,7 +1773,8 @@ pure_perl_install ::
 	].$self->{NOECHO}.q[$(PERL) -e "print 'write ].$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q[ '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_LIB) $(INSTALLPRIVLIB) '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_ARCHLIB) $(INSTALLARCHLIB) '" >>.MM_tmp
-	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_EXE) $(INSTALLBIN) '" >>.MM_tmp
+	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_BIN) $(INSTALLBIN) '" >>.MM_tmp
+	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_SCRIPT) $(INSTALLSCRIPT) '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN1DIR) $(INSTALLMAN1DIR) '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN3DIR) $(INSTALLMAN3DIR) '" >>.MM_tmp
 	$(MOD_INSTALL) <.MM_tmp
@@ -1862,7 +1787,8 @@ pure_site_install ::
 	].$self->{NOECHO}.q[$(PERL) -e "print 'write ].$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q[ '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_LIB) $(INSTALLSITELIB) '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_ARCHLIB) $(INSTALLSITEARCH) '" >>.MM_tmp
-	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_EXE) $(INSTALLBIN) '" >>.MM_tmp
+	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_BIN) $(INSTALLBIN) '" >>.MM_tmp
+	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_SCRIPT) $(INSTALLSCRIPT) '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN1DIR) $(INSTALLMAN1DIR) '" >>.MM_tmp
 	].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN3DIR) $(INSTALLMAN3DIR) '" >>.MM_tmp
 	$(MOD_INSTALL) <.MM_tmp
@@ -1912,10 +1838,6 @@ we have to rebuild Config.pm, use MM[SK] to do it.
 
 sub perldepend {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m);
 
     push @m, '
@@ -1970,10 +1892,6 @@ Use VMS commands and quoting.
 
 sub makefile {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my(@m,@cmd);
     # We do not know what target was originally specified so we
     # must force a manual rerun to be sure. But as it should only
@@ -2006,15 +1924,13 @@ Use VMS commands for handling subdirectories.
 
 sub test {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($tests) = $attribs{TESTS} || ( -d 't' ? 't/*.t' : '');
     my(@m);
     push @m,"
 TEST_VERBOSE = 0
 TEST_TYPE = test_\$(LINKTYPE)
+TEST_FILE = test.pl
+TESTDB_SW = -d
 
 test :: \$(TEST_TYPE)
 	\$(NOOP)
@@ -2038,11 +1954,9 @@ testdb :: testdb_\$(LINKTYPE)
     push(@m, "    \$(NOOP)\n") if (!$tests && ! -f "test.pl");
     push(@m, "\n");
 
-    if (-f 'test.pl') {
-	push(@m, "testdb_dynamic :: pure_all\n");
-	push(@m, $self->test_via_script('$(FULLPERL) -d', 'test.pl'));
-	push(@m, "\n");
-    }
+    push(@m, "testdb_dynamic :: pure_all\n");
+    push(@m, $self->test_via_script('$(FULLPERL) "$(TESTDB_SW)"', '$(TEST_FILE)'));
+    push(@m, "\n");
 
     # Occasionally we may face this degenerate target:
     push @m, "test_ : test_dynamic\n\n";
@@ -2050,13 +1964,10 @@ testdb :: testdb_\$(LINKTYPE)
     if ($self->needs_linking()) {
 	push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
 	push(@m, $self->test_via_harness('$(MAP_TARGET)', $tests)) if $tests;
-	if (-f 'test.pl') {
-	    push(@m, $self->test_via_script('$(MAP_TARGET)', 'test.pl'));
-	    push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
-	    push(@m, $self->test_via_script('$(MAP_TARGET) -d', 'test.pl'));
-	    push(@m, "\n");
-	}
-	push(@m, "\t$self->{NOECHO}\$(NOOP)\n") if (!$tests && ! -f "test.pl");
+	push(@m, $self->test_via_script('$(MAP_TARGET)', 'test.pl')) if -f 'test.pl';
+	push(@m, "\n");
+	push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
+	push(@m, $self->test_via_script('$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
 	push(@m, "\n");
     }
     else {
@@ -2075,10 +1986,6 @@ Use VMS-style quoting on command line.
 
 sub test_via_harness {
     my($self,$perl,$tests) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     "	$perl".' "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)" \\'."\n\t".
     '-e "use Test::Harness qw(&runtests $verbose); $verbose=$(TEST_VERBOSE); runtests @ARGV;" \\'."\n\t$tests\n";
 }
@@ -2091,10 +1998,6 @@ Use VMS-style quoting on command line.
 
 sub test_via_script {
     my($self,$perl,$script) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     "	$perl".' "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" '.$script.'
 ';
 }
@@ -2110,10 +2013,6 @@ Consequently, it hasn't really been tested, and may well be incomplete.
 
 sub makeaperl {
     my($self, %attribs) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) = 
       @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
     my(@m);
@@ -2158,6 +2057,40 @@ $(MAP_TARGET) :: $(MAKE_APERL_FILE)
     File::Find::find(sub {
 	return unless m/\Q$self->{LIB_EXT}\E$/;
 	return if m/^libperl/;
+
+	if( exists $self->{INCLUDE_EXT} ){
+		my $found = 0;
+		my $incl;
+		my $xx;
+
+		($xx = $File::Find::name) =~ s,.*?/auto/,,;
+		$xx =~ s,/?$_,,;
+		$xx =~ s,/,::,g;
+
+		# Throw away anything not explicitly marked for inclusion.
+		# DynaLoader is implied.
+		foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
+			if( $xx eq $incl ){
+				$found++;
+				last;
+			}
+		}
+		return unless $found;
+	}
+	elsif( exists $self->{EXCLUDE_EXT} ){
+		my $excl;
+		my $xx;
+
+		($xx = $File::Find::name) =~ s,.*?/auto/,,;
+		$xx =~ s,/?$_,,;
+		$xx =~ s,/,::,g;
+
+		# Throw away anything explicitly marked for exclusion
+		foreach $excl (@{$self->{EXCLUDE_EXT}}){
+			return if( $xx eq $excl );
+		}
+	}
+
 	$olbs{$ENV{DEFAULT}} = $_;
     }, grep( -d $_, @{$searchdirs || []}));
 
@@ -2295,10 +2228,6 @@ support is added to that package.
 
 sub ext {
     my($self) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     '','','';
 }
 
@@ -2315,10 +2244,6 @@ part of a filespec.
 sub nicetext {
 
     my($self,$text) = @_;
-    unless (ref $self){
-	ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
-	$self = $ExtUtils::MakeMaker::Parent[-1];
-    }
     $text =~ s/([^\s:])(:+\s)/$1 $2/gs;
     $text;
 }
@@ -2326,3 +2251,4 @@ sub nicetext {
 1;
 
 __END__
+
diff --git a/lib/ExtUtils/MakeMaker.pm b/lib/ExtUtils/MakeMaker.pm
index 63e742bd12..827cb72fae 100644
--- a/lib/ExtUtils/MakeMaker.pm
+++ b/lib/ExtUtils/MakeMaker.pm
@@ -1,25 +1,11 @@
-require 5.002; # MakeMaker 5.17 was the last MakeMaker that was compatible with perl5.001m
-
-package main;
-use vars qw(%att);
-
-package ExtUtils::MakeMaker::TieAtt;
-# this package will go away again, when we don't have modules around
-# anymore that import %att It ties an empty %att and records in which
-# object this %att was tied. FETCH and STORE return/store-to the
-# appropriate value from %$self
-
-# the warndirectuse method warns if somebody calls MM->something. It
-# has nothing to do with the tie'd %att.
-
-$Enough_limit = 5;
+BEGIN {require 5.002;} # MakeMaker 5.17 was the last MakeMaker that was compatible with perl5.001m
 
 package ExtUtils::MakeMaker;
 
-$Version = $VERSION = "5.26";
-$Version_OK = "5.05";	# Makefiles older than $Version_OK will die
+$Version = $VERSION = "5.34";
+$Version_OK = "5.17";	# Makefiles older than $Version_OK will die
 			# (Will be checked from MakeMaker version 4.13 onwards)
-($Revision = substr(q$Revision: 1.187 $, 10)) =~ s/\s+$//;
+($Revision = substr(q$Revision: 1.202 $, 10)) =~ s/\s+$//;
 
 
 
@@ -29,14 +15,15 @@ use Carp ();
 #use FileHandle ();
 
 use vars qw(
-	    $VERSION $Version_OK $Revision
-	    $Verbose %MM_Sections $ISA_TTY
-	    @MM_Sections %Recognized_Att_Keys @Get_from_Config
-	    %Prepend_dot_dot %Config @Parent %NORMAL_INC
-	    $Setup_done %Keep_after_flush
-	    @Overridable
+
+	    @ISA @EXPORT @EXPORT_OK $AUTOLOAD
+	    $ISA_TTY $Is_Mac $Is_OS2 $Is_VMS $Revision $Setup_done
+	    $VERSION $Verbose $Version_OK %Config %Keep_after_flush
+	    %MM_Sections %Prepend_dot_dot %Recognized_Att_Keys
+	    @Get_from_Config @MM_Sections @Overridable @Parent
+
 	   );
-#use strict qw(refs);
+# use strict;
 
 eval {require DynaLoader;};	# Get mod2fname, if defined. Will fail
                                 # with miniperl.
@@ -48,7 +35,7 @@ eval {require DynaLoader;};	# Get mod2fname, if defined. Will fail
 @ISA = qw(Exporter);
 @EXPORT = qw(&WriteMakefile &writeMakefile $Verbose &prompt);
 @EXPORT_OK = qw($VERSION &Version_check &neatvalue &mkbootstrap &mksymlists
-		$Version %att);  ## Import of %att is deprecated, please use OO features!
+		$Version);
 		# $Version in mixed case will go away!
 
 #
@@ -66,7 +53,8 @@ eval {require DynaLoader;};	# Get mod2fname, if defined. Will fail
 #
 {
     package MY;
-    @ISA = qw(MM);
+    @MY::ISA = qw(MM);
+###    sub AUTOLOAD { use Devel::Symdump; print Devel::Symdump->rnew->as_string; Carp::confess "hey why? $AUTOLOAD" }
     package MM;
     sub DESTROY {}
 }
@@ -80,28 +68,21 @@ package ExtUtils::MakeMaker;
 # Now we can can pull in the friends
 #
 $Is_VMS = $^O eq 'VMS';
-$Is_OS2 = $^O eq 'os2';
+$Is_OS2 = $^O =~ m|^os/?2$|i;
+$Is_Mac = $^O eq 'MacOS';
 
 require ExtUtils::MM_Unix;
 
 if ($Is_VMS) {
     require ExtUtils::MM_VMS;
+    require VMS::Filespec; # is a noop as long as we require it within MM_VMS
 }
 if ($Is_OS2) {
     require ExtUtils::MM_OS2;
 }
-
-%NORMAL_INC = %INC;
-@NORMAL_INC{qw|File/Find.pm Cwd.pm ExtUtils/Manifest.pm ExtUtils/Liblist.pm|} = (1) x 4;
-
-
-# This has to go one day...
-$SIG{__WARN__} = sub {
-    $_[0] =~ /^Use of uninitialized value/ && return;
-    $_[0] =~ /used only once/ && return;
-    $_[0] =~ /^Subroutine\s+[\w:]+\s+redefined/ && return;
-    warn @_;
-};
+if ($Is_Mac) {
+    require ExtUtils::MM_Mac;
+}
 
 # The SelfLoader would bring a lot of overhead for MakeMaker, because
 # we know for sure we will use most of the autoloaded functions once
@@ -110,10 +91,12 @@ $SIG{__WARN__} = sub {
 sub AUTOLOAD {
     my $code;
     if (defined fileno(DATA)) {
-	while (<DATA>) {
-	    last if /^__END__/;
-	    $code .= $_;
-	}
+	my $fh = select DATA;
+	my $o = $/;			# For future reads from the file.
+	$/ = "\n__END__\n";
+	$code = <DATA>;
+	$/ = $o;
+	select $fh;
 	close DATA;
 	eval $code;
 	if ($@) {
@@ -143,6 +126,13 @@ Please rerun 'perl Makefile.PL' to regenerate the Makefile.\n"
 	unless $checkversion == $VERSION;
 }
 
+sub warnhandler {
+    $_[0] =~ /^Use of uninitialized value/ && return;
+    $_[0] =~ /used only once/ && return;
+    $_[0] =~ /^Subroutine\s+[\w:]+\s+redefined/ && return;
+    warn @_;
+}
+
 sub ExtUtils::MakeMaker::eval_in_subdirs ;
 sub ExtUtils::MakeMaker::eval_in_x ;
 sub ExtUtils::MakeMaker::full_setup ;
@@ -160,19 +150,15 @@ sub ExtUtils::MakeMaker::neatvalue ;
 sub ExtUtils::MakeMaker::selfdocument ;
 sub ExtUtils::MakeMaker::WriteMakefile ;
 sub ExtUtils::MakeMaker::prompt ;
-sub ExtUtils::MakeMaker::TieAtt::TIEHASH ;
-sub ExtUtils::MakeMaker::TieAtt::FETCH ;
-sub ExtUtils::MakeMaker::TieAtt::STORE ;
-sub ExtUtils::MakeMaker::TieAtt::FIRSTKEY ;
-sub ExtUtils::MakeMaker::TieAtt::NEXTKEY ;
-sub ExtUtils::MakeMaker::TieAtt::DESTROY ;
-sub ExtUtils::MakeMaker::TieAtt::warndirectuse ;
-
-__DATA__
+
+1;
+#__DATA__
 package ExtUtils::MakeMaker;
 
 sub WriteMakefile {
     Carp::croak "WriteMakefile: Need even number of args" if @_ % 2;
+    local $SIG{__WARN__} = \&warnhandler;
+
     unless ($Setup_done++){
 	full_setup();
 	undef &ExtUtils::MakeMaker::full_setup; #safe memory
@@ -181,20 +167,19 @@ sub WriteMakefile {
     MM->new(\%att)->flush;
 }
 
-sub prompt {
+sub prompt ($;$) {
     my($mess,$def)=@_;
     $ISA_TTY = -t STDIN && -t STDOUT ;
     Carp::confess("prompt function called without an argument") unless defined $mess;
-    $def = "" unless defined $def;
-    my $dispdef = "[$def] ";
+    my $dispdef = defined $def ? "[$def] " : " ";
+    $def = defined $def ? $def : "";
     my $ans;
     if ($ISA_TTY) {
 	local $|=1;
 	print "$mess $dispdef";
-	chop($ans = <STDIN>);
+	chomp($ans = <STDIN>);
     }
-    return $ans if defined $ans;
-    return $def;
+    return $ans || $def;
 }
 
 sub eval_in_subdirs {
@@ -224,62 +209,86 @@ sub eval_in_x {
 #    $fh->close;
     close FH;
     eval $eval;
-    warn "WARNING from evaluation of $dir/Makefile.PL: $@" if $@;
+    if ($@) {
+# 	  if ($@ =~ /prerequisites/) {
+# 	      die "MakeMaker WARNING: $@";
+# 	  } else {
+# 	      warn "WARNING from evaluation of $dir/Makefile.PL: $@";
+# 	  }
+	warn "WARNING from evaluation of $dir/Makefile.PL: $@";
+    }
 }
 
 sub full_setup {
     $Verbose ||= 0;
     $^W=1;
 
-# package name for the classes into which the first object will be blessed
+    # package name for the classes into which the first object will be blessed
     $PACKNAME = "PACK000";
 
     @Attrib_help = qw/
 
     C CONFIG CONFIGURE DEFINE DIR DISTNAME DL_FUNCS DL_VARS EXE_FILES
-    NO_VC FIRST_MAKEFILE FULLPERL H INC INSTALLARCHLIB INSTALLBIN
-    INSTALLDIRS INSTALLMAN1DIR INSTALLMAN3DIR INSTALLPRIVLIB
-    INSTALLSITEARCH INSTALLSITELIB INST_ARCHLIB INST_EXE INST_LIB
-    INST_MAN1DIR INST_MAN3DIR LDFROM LIBPERL_A LIBS LINKTYPE MAKEAPERL
-    MAKEFILE MAN1PODS MAN3PODS MAP_TARGET MYEXTLIB NAME NEEDS_LINKING
-    NOECHO NORECURS OBJECT OPTIMIZE PERL PERLMAINCC PERL_ARCHLIB
-    PERL_LIB PERL_SRC PL_FILES PM PMLIBDIRS PREFIX PREREQ SKIP
-    TYPEMAPS VERSION VERSION_FROM XS XSOPT XSPROTOARG XS_VERSION clean
-    depend dist dynamic_lib linkext macro realclean tool_autosplit
+    EXCLUDE_EXT INCLUDE_EXT NO_VC FIRST_MAKEFILE FULLPERL H INC
+    INSTALLARCHLIB INSTALLBIN INSTALLDIRS INSTALLMAN1DIR
+    INSTALLMAN3DIR INSTALLPRIVLIB INSTALLSCRIPT INSTALLSITEARCH
+    INSTALLSITELIB INST_ARCHLIB INST_BIN INST_EXE INST_LIB
+    INST_MAN1DIR INST_MAN3DIR INST_SCRIPT LDFROM LIBPERL_A LIBS
+    LINKTYPE MAKEAPERL MAKEFILE MAN1PODS MAN3PODS MAP_TARGET MYEXTLIB
+    NAME NEEDS_LINKING NOECHO NORECURS OBJECT OPTIMIZE PERL PERLMAINCC
+    PERL_ARCHLIB PERL_LIB PERL_SRC PL_FILES PM PMLIBDIRS PREFIX
+    PREREQ_PM SKIP TYPEMAPS VERSION VERSION_FROM XS XSOPT XSPROTOARG
+    XS_VERSION clean depend dist dynamic_lib linkext macro realclean
+    tool_autosplit
 
     installpm
 
 	/;
 
+    # ^^^ installpm is deprecated, will go about Summer 96
+
+    # @Overridable is close to @MM_Sections but not identical.  The
+    # order is important. Many subroutines declare macros. These
+    # depend on each other. Let's try to collect the macros up front,
+    # then pasthru, then the rules.
+
+    # MM_Sections are the sections we have to call explicitly
+    # in Overridable we have subroutines that are used indirectly
 
-    # @Overridable is close to MM_Sections
 
     @MM_Sections = 
 	qw(
 
-	post_initialize const_config constants tool_autosplit
-	tool_xsubpp tools_other dist macro depend post_constants
-	pasthru c_o xs_c xs_o top_targets linkext dlsyms dynamic
-	dynamic_bs dynamic_lib static static_lib manifypods processPL
-	installbin subdirs clean realclean dist_basics dist_core
-	dist_dir dist_test dist_ci install force perldepend makefile
-	staticmake test postamble
+ post_initialize const_config constants tool_autosplit tool_xsubpp
+ tools_other dist macro depend cflags const_loadlibs const_cccmd
+ post_constants
+
+ pasthru
+
+ c_o xs_c xs_o top_targets linkext dlsyms dynamic dynamic_bs
+ dynamic_lib static static_lib manifypods processPL installbin subdirs
+ clean realclean dist_basics dist_core dist_dir dist_test dist_ci
+ install force perldepend makefile staticmake test
 
 	  ); # loses section ordering
 
     @Overridable = @MM_Sections;
-    push @Overridable, qw[ dir_target
-			   libscan makeaperl
-			   needs_linking subdir_x test_via_harness
-			   test_via_script ];
-    push @MM_Sections, qw[
-			  pm_to_blib selfdocument cflags const_loadlibs
-			  const_cccmd
+    push @Overridable, qw[
+
+ dir_target libscan makeaperl needs_linking subdir_x test_via_harness
+ test_via_script
+
 			 ];
 
+    push @MM_Sections, qw[
 
-    #### Can we drop this?
-    #### @MM_Sections{@MM_Sections} = {} x @MM_Sections;
+ pm_to_blib selfdocument
+
+			 ];
+
+    # Postamble needs to be the last that was always the case
+    push @MM_Sections, "postamble";
+    push @Overridable, "postamble";
 
     # All sections are valid keys.
     @Recognized_Att_Keys{@MM_Sections} = (1) x @MM_Sections;
@@ -308,8 +317,11 @@ sub full_setup {
     #
     %Prepend_dot_dot = 
 	qw(
-	   INST_LIB 1 INST_ARCHLIB 1 INST_EXE 1 MAP_TARGET 1 INST_MAN1DIR 1 INST_MAN3DIR 1
-	   PERL_SRC 1 PERL 1 FULLPERL 1
+
+	   INST_BIN 1 INST_EXE 1 INST_LIB 1 INST_ARCHLIB 1 INST_SCRIPT
+	   1 MAP_TARGET 1 INST_MAN1DIR 1 INST_MAN3DIR 1 PERL_SRC 1
+	   PERL 1 FULLPERL 1
+
 	  );
 
     my @keep = qw/
@@ -353,6 +365,36 @@ sub ExtUtils::MakeMaker::new {
 
     my(%initial_att) = %$self; # record initial attributes
 
+    my($prereq);
+    foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
+	my $eval = "use $prereq $self->{PREREQ_PM}->{$prereq}";
+	eval $eval;
+	if ($@){
+	    warn "Warning: prerequisite $prereq $self->{PREREQ_PM}->{$prereq} not found";
+	} else {
+	    delete $self->{PREREQ_PM}{$prereq};
+	}
+    }
+#    if (@unsatisfied){
+# 	  unless (defined $ExtUtils::MakeMaker::useCPAN) {
+# 	      print qq{MakeMaker WARNING: prerequisites not found (@unsatisfied)
+# Please install these modules first and rerun 'perl Makefile.PL'.\n};
+# 	      if ($ExtUtils::MakeMaker::hasCPAN) {
+# 		  $ExtUtils::MakeMaker::useCPAN = prompt(qq{Should I try to use the CPAN module to fetch them for you?},"yes");
+# 	      } else {
+# 		  print qq{Hint: You may want to install the CPAN module to autofetch the needed modules\n};
+# 		  $ExtUtils::MakeMaker::useCPAN=0;
+# 	      }
+# 	  }
+# 	  if ($ExtUtils::MakeMaker::useCPAN) {
+# 	      require CPAN;
+# 	      CPAN->import(@unsatisfied);
+# 	  } else {
+# 	      die qq{prerequisites not found (@unsatisfied)};
+# 	  }
+#	warn qq{WARNING: prerequisites not found (@unsatisfied)};
+#    }
+
     if (defined $self->{CONFIGURE}) {
 	if (ref $self->{CONFIGURE} eq 'CODE') {
 	    $self = { %$self, %{&{$self->{CONFIGURE}}}};
@@ -457,7 +499,6 @@ END
 	$self->eval_in_subdirs if @{$self->{DIR}};
     }
 
-    tie %::att, ExtUtils::MakeMaker::TieAtt, $self;
     my $section;
     foreach $section ( @MM_Sections ){
 	print "Processing Makefile '$section' section\n" if ($Verbose >= 2);
@@ -551,12 +592,21 @@ sub parse_args{
 	# have to build a list with the shell
 	$self->{DIR} = [grep $_, split ":", $self->{DIR}];
     }
+    # Turn a INCLUDE_EXT argument on the command line into an array
+    if (defined $self->{INCLUDE_EXT} && ref \$self->{INCLUDE_EXT} eq 'SCALAR') {
+	$self->{INCLUDE_EXT} = [grep $_, split '\s+', $self->{INCLUDE_EXT}];
+    }
+    # Turn a EXCLUDE_EXT argument on the command line into an array
+    if (defined $self->{EXCLUDE_EXT} && ref \$self->{EXCLUDE_EXT} eq 'SCALAR') {
+	$self->{EXCLUDE_EXT} = [grep $_, split '\s+', $self->{EXCLUDE_EXT}];
+    }
     my $mmkey;
     foreach $mmkey (sort keys %$self){
 	print STDOUT "	$mmkey => ", neatvalue($self->{$mmkey}), "\n" if $Verbose;
 	print STDOUT "'$mmkey' is not a known MakeMaker parameter name.\n"
 	    unless exists $Recognized_Att_Keys{$mmkey};
     }
+    $| = 1 if $Verbose;
 }
 
 sub check_hints {
@@ -567,7 +617,7 @@ sub check_hints {
 
     # First we look for the best hintsfile we have
     my(@goodhints);
-    my($hint)="$Config{osname}_$Config{osvers}";
+    my($hint)="${^O}_$Config{osvers}";
     $hint =~ s/\./_/g;
     $hint =~ s/_$//;
     return unless $hint;
@@ -630,7 +680,7 @@ sub mv_all_methods {
 	# %MY:: being intact, we have to fill the hole with an
 	# inheriting method:
 
-	eval "package MY; sub $method {local *$method; shift->MY::$method(\@_); }";
+	eval "package MY; sub $method { shift->SUPER::$method(\@_); }";
     }
 
     # We have to clean out %INC also, because the current directory is
@@ -638,13 +688,18 @@ sub mv_all_methods {
     # out of a History.pl file which is "required" so woudn't get
     # loaded again in another extension requiring a History.pl
 
-    my $inc;
-    foreach $inc (keys %INC) {
-	next if $NORMAL_INC{$inc};
-	#warn "***$inc*** deleted";
-	delete $INC{$inc};
-    }
-
+    # With perl5.002_01 the deletion of entries in %INC caused Tk-b11
+    # to core dump in the middle of a require statement. The required
+    # file was Tk/MMutil.pm.  The consequence is, we have to be
+    # extremely careful when we try to give perl a reason to reload a
+    # library with same name.  The workaround prefers to drop nothing
+    # from %INC and teach the writers not to use such libraries.
+
+#    my $inc;
+#    foreach $inc (keys %INC) {
+#	#warn "***$inc*** deleted";
+#	delete $INC{$inc};
+#    }
 }
 
 sub skipcheck {
@@ -764,53 +819,6 @@ sub selfdocument {
     join "\n", @m;
 }
 
-package ExtUtils::MakeMaker::TieAtt;
-
-sub TIEHASH {
-    bless { SECRETHASH => $_[1]};
-}
-
-sub FETCH {
-    print "Warning (non-fatal): Importing of %att is deprecated [$_[1]]
-	use \$self instead\n" unless ++$Enough>$Enough_limit;
-    print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
-    $_[0]->{SECRETHASH}->{$_[1]};
-}
-
-sub STORE {
-    print "Warning (non-fatal): Importing of %att is deprecated [$_[1]][$_[2]]
-	use \$self instead\n" unless ++$Enough>$Enough_limit;
-    print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
-    $_[0]->{SECRETHASH}->{$_[1]} = $_[2];
-}
-
-sub FIRSTKEY {
-    print "Warning (non-fatal): Importing of %att is deprecated [FIRSTKEY]
-	use \$self instead\n" unless ++$Enough>$Enough_limit;
-    print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
-    each %{$_[0]->{SECRETHASH}};
-}
-
-sub NEXTKEY {
-    each %{$_[0]->{SECRETHASH}};
-}
-
-sub DESTROY {
-}
-
-sub warndirectuse {
-    my($caller) = @_;
-    return if $Enough>$Enough_limit;
-    print STDOUT "Warning (non-fatal): Direct use of class methods deprecated; use\n";
-    my($method) = $caller =~ /.*:(\w+)$/;
-    print STDOUT
-'		my $self = shift;
-		$self->MM::', $method, "();
-	instead\n";
-    print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n"
-	if ++$Enough==$Enough_limit;
-}
-
 package ExtUtils::MakeMaker;
 1;
 
@@ -840,90 +848,29 @@ It splits the task of generating the Makefile into several subroutines
 that can be individually overridden.  Each subroutine returns the text
 it wishes to have written to the Makefile.
 
-=head2 Hintsfile support
-
-MakeMaker.pm uses the architecture specific information from
-Config.pm. In addition it evaluates architecture specific hints files
-in a C<hints/> directory. The hints files are expected to be named
-like their counterparts in C<PERL_SRC/hints>, but with an C<.pl> file
-name extension (eg. C<next_3_2.pl>). They are simply C<eval>ed by
-MakeMaker within the WriteMakefile() subroutine, and can be used to
-execute commands as well as to include special variables. The rules
-which hintsfile is chosen are the same as in Configure.
-
-The hintsfile is eval()ed immediately after the arguments given to
-WriteMakefile are stuffed into a hash reference $self but before this
-reference becomes blessed. So if you want to do the equivalent to
-override or create an attribute you would say something like
-
-    $self->{LIBS} = ['-ldbm -lucb -lc'];
-
-=head2 What's new in version 5 of MakeMaker
-
-MakeMaker 5 is pure object oriented. This allows us to write an
-unlimited number of Makefiles with a single perl process. 'perl
-Makefile.PL' with MakeMaker 5 goes through all subdirectories
-immediately and evaluates any Makefile.PL found in the next level
-subdirectories. The benefit of this approach comes in useful for both
-single and multi directories extensions.
-
-Multi directory extensions have an immediately visible speed
-advantage, because there's no startup penalty for any single
-subdirectory Makefile.
-
-Single directory packages benefit from the much improved
-needs_linking() method. As the main Makefile knows everything about
-the subdirectories, a needs_linking() method can now query all
-subdirectories if there is any linking involved down in the tree. The
-speedup for PM-only Makefiles seems to be around 1 second on my
-Indy 100 MHz.
-
-=head2 Incompatibilities between MakeMaker 5.00 and 4.23
-
-There are no incompatibilities in the short term, as all changes are
-accompanied by short-term workarounds that guarantee full backwards
-compatibility.
-
-You are likely to face a few warnings that expose deprecations which
-will result in incompatibilities in the long run:
-
-You should not use %att directly anymore. Instead any subroutine you
-override in the MY package will be called by the object method, so you
-can access all object attributes directly via the object in $_[0].
-
-You should not call the class methos MM->something anymore. Instead
-you should call the superclass. Something like
+MakeMaker is object oriented. Each directory below the current
+directory that contains a Makefile.PL. Is treated as a separate
+object. This makes it possible to write an unlimited number of
+Makefiles with a single invocation of WriteMakefile().
 
-    sub MY::constants {
-        my $self = shift;
-        $self->MM::constants();
-    }
-
-Especially the libscan() and exescan() methods should be altered
-towards OO programming, that means do not expect that $_ to contain
-the path but rather $_[1].
-
-Try to build several extensions simultanously to debug your
-Makefile.PL. You can unpack a bunch of distributed packages within one
-directory and run
+=head2 How To Write A Makefile.PL
 
-    perl -MExtUtils::MakeMaker -e 'WriteMakefile()'
+The short answer is: Don't. Run h2xs(1) before you start thinking
+about writing a module. For so called pm-only modules that consist of
+C<*.pm> files only, h2xs has the very useful C<-X> switch. This will
+generate dummy files of all kinds that are useful for the module
+developer.
 
-That's actually fun to watch :)
+The medium answer is:
 
-Do not use exit() in your Makefile.PL. MakeMaker tries hard to enable
-multi-module builds in one go.
-
-Final suggestion: Try to delete all of your MY:: subroutines and
-watch, if you really still need them. MakeMaker might already do what
-you want without them. If you see no way to avoid your own subroutine
-solution, please let us know about the problem.
+    use ExtUtils::MakeMaker;
+    WriteMakefile( NAME => "Foo::Bar" );
 
+The long answer is below.
 
 =head2 Default Makefile Behaviour
 
-The automatically generated Makefile enables the user of the extension
-to invoke
+The generated Makefile enables the user of the extension to invoke
 
   perl Makefile.PL # optionally "perl Makefile.PL verbose"
   make
@@ -958,11 +905,11 @@ switches set correctly.
 =head2 make install
 
 make alone puts all relevant files into directories that are named by
-the macros INST_LIB, INST_ARCHLIB, INST_EXE, INST_MAN1DIR, and
-INST_MAN3DIR. All these default to something below ./blib if
-you are I<not> building below the perl source directory. If you I<are>
+the macros INST_LIB, INST_ARCHLIB, INST_SCRIPT, INST_MAN1DIR, and
+INST_MAN3DIR. All these default to something below ./blib if you are
+I<not> building below the perl source directory. If you I<are>
 building below the perl source, INST_LIB and INST_ARCHLIB default to
- ../../lib, and INST_EXE is not defined.
+../../lib, and INST_SCRIPT is not defined.
 
 The I<install> target of the generated Makefile copies the files found
 below each of the INST_* directories to their INSTALL*
@@ -974,7 +921,8 @@ INSTALLDIRS according to the following table:
 
     INST_ARCHLIB    INSTALLARCHLIB    INSTALLSITEARCH
     INST_LIB        INSTALLPRIVLIB    INSTALLSITELIB
-    INST_EXE                   INSTALLBIN
+    INST_BIN                  INSTALLBIN
+    INST_SCRIPT              INSTALLSCRIPT
     INST_MAN1DIR             INSTALLMAN1DIR
     INST_MAN3DIR             INSTALLMAN3DIR
 
@@ -987,26 +935,11 @@ You can check the values of these variables on your system with
         sprintf("%20s: %s", $_, $Config{$_}),
         grep /^install/, keys %Config'
 
-If you don't want to keep the defaults, MakeMaker helps you to
-minimize the typing needed: the usual relationship between
-INSTALLPRIVLIB and INSTALLARCHLIB is determined by Configure at perl
-compilation time. MakeMaker supports the user who sets
-INSTALLPRIVLIB. If INSTALLPRIVLIB is set, but INSTALLARCHLIB not, then
-MakeMaker defaults the latter to be the same subdirectory of
-INSTALLPRIVLIB as Configure decided for the counterparts in %Config ,
-otherwise it defaults to INSTALLPRIVLIB. The same relationship holds
-for INSTALLSITELIB and INSTALLSITEARCH.
+And to check the sequence in which the library directories are
+searched by perl, run
 
-MakeMaker gives you much more freedom than needed to configure
-internal variables and get different results. It is worth to mention,
-that make(1) also lets you configure most of the variables that are
-used in the Makefile. But in the majority of situations this will not
-be necessary, and should only be done, if the author of a package
-recommends it (or you know what you're doing).
-
-=cut
+    perl -le 'print join $/, @INC'
 
-#'
 
 =head2 PREFIX attribute
 
@@ -1023,7 +956,7 @@ default, nor by make.
 
 If the user has superuser privileges, and is not working on AFS
 (Andrew File System) or relatives, then the defaults for
-INSTALLPRIVLIB, INSTALLARCHLIB, INSTALLBIN, etc. will be appropriate,
+INSTALLPRIVLIB, INSTALLARCHLIB, INSTALLSCRIPT, etc. will be appropriate,
 and this incantation will be the best:
 
     perl Makefile.PL; make; make test
@@ -1040,7 +973,7 @@ probably have changed since perl itself has been installed. They will
 have to do this by calling
 
     perl Makefile.PL INSTALLSITELIB=/afs/here/today \
-	INSTALLBIN=/afs/there/now INSTALLMAN3DIR=/afs/for/manpages
+	INSTALLSCRIPT=/afs/there/now INSTALLMAN3DIR=/afs/for/manpages
     make
 
 Be careful to repeat this procedure every time you recompile an
@@ -1142,19 +1075,25 @@ of the perl library. The other variables default to the following:
 If perl has not yet been installed then PERL_SRC can be defined on the
 command line as shown in the previous section.
 
-=head2 Useful Default Makefile Macros
 
-FULLEXT = Pathname for extension directory (eg DBD/Oracle).
+=head2 Which architecture dependent directory?
 
-BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
-
-ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
-
-INST_LIBDIR = C<$(INST_LIB)$(ROOTEXT)>
-
-INST_AUTODIR = C<$(INST_LIB)/auto/$(FULLEXT)>
+If you don't want to keep the defaults for the INSTALL* macros,
+MakeMaker helps you to minimize the typing needed: the usual
+relationship between INSTALLPRIVLIB and INSTALLARCHLIB is determined
+by Configure at perl compilation time. MakeMaker supports the user who
+sets INSTALLPRIVLIB. If INSTALLPRIVLIB is set, but INSTALLARCHLIB not,
+then MakeMaker defaults the latter to be the same subdirectory of
+INSTALLPRIVLIB as Configure decided for the counterparts in %Config ,
+otherwise it defaults to INSTALLPRIVLIB. The same relationship holds
+for INSTALLSITELIB and INSTALLSITEARCH.
 
-INST_ARCHAUTODIR = C<$(INST_ARCHLIB)/auto/$(FULLEXT)>
+MakeMaker gives you much more freedom than needed to configure
+internal variables and get different results. It is worth to mention,
+that make(1) also lets you configure most of the variables that are
+used in the Makefile. But in the majority of situations this will not
+be necessary, and should only be done, if the author of a package
+recommends it (or you know what you're doing).
 
 =head2 Using Attributes and Parameters
 
@@ -1238,10 +1177,19 @@ universal symbols.  Used only under AIX (export lists) and VMS
 (linker options) at present.  Defaults to [].  (e.g. [ qw(
 Foo_version Foo_numstreams Foo_tree ) ])
 
+=item EXCLUDE_EXT
+
+Array of extension names to exclude when doing a static build.  This
+is ignored if INCLUDE_EXT is present.  Consult INCLUDE_EXT for more
+details.  (e.g.  [ qw( Socket POSIX ) ] )
+
+This attribute may be most useful when specified as a string on the
+commandline:  perl Makefile.PL EXCLUDE_EXT='Socket Safe'
+
 =item EXE_FILES
 
 Ref to array of executable files. The files will be copied to the
-INST_EXE directory. Make realclean will delete them from there
+INST_SCRIPT directory. Make realclean will delete them from there
 again.
 
 =item NO_VC
@@ -1269,6 +1217,21 @@ Ref to array of *.h file names. Similar to C.
 
 Include file dirs eg: C<"-I/usr/5include -I/path/to/inc">
 
+=item INCLUDE_EXT
+
+Array of extension names to be included when doing a static build.
+MakeMaker will normally build with all of the installed extensions when
+doing a static build, and that is usually the desired behavior.  If
+INCLUDE_EXT is present then MakeMaker will build only with those extensions
+which are explicitly mentioned. (e.g.  [ qw( Socket POSIX ) ])
+
+It is not necessary to mention DynaLoader or the current extension when
+filling in INCLUDE_EXT.  If the INCLUDE_EXT is mentioned but is empty then
+only DynaLoader and the current extension will be included in the build.
+
+This attribute may be most useful when specified as a string on the
+commandline:  perl Makefile.PL INCLUDE_EXT='POSIX Socket Devel::Peek'
+
 =item INSTALLARCHLIB
 
 Used by 'make install', which copies files from INST_ARCHLIB to this
@@ -1276,8 +1239,7 @@ directory if INSTALLDIRS is set to perl.
 
 =item INSTALLBIN
 
-Used by 'make install' which copies files from INST_EXE to this
-directory.
+Directory to install binary files (e.g. tkperl) into.
 
 =item INSTALLDIRS
 
@@ -1301,6 +1263,11 @@ $Config{installman3dir}.
 Used by 'make install', which copies files from INST_LIB to this
 directory if INSTALLDIRS is set to perl.
 
+=item INSTALLSCRIPT
+
+Used by 'make install' which copies files from INST_SCRIPT to this
+directory.
+
 =item INSTALLSITELIB
 
 Used by 'make install', which copies files from INST_LIB to this
@@ -1315,11 +1282,15 @@ directory if INSTALLDIRS is set to site (default).
 
 Same as INST_LIB for architecture dependent files.
 
+=item INST_BIN
+
+Directory to put real binary files during 'make'. These will be copied
+to INSTALLBIN during 'make install'
+
 =item INST_EXE
 
-Directory, where executable scripts should be installed during
-'make'. Defaults to "./blib/bin", just to have a dummy location during
-testing. make install will copy the files in INST_EXE to INSTALLBIN.
+Old name for INST_SCRIPT. Deprecated. Please use INST_SCRIPT if you
+need to use it.
 
 =item INST_LIB
 
@@ -1334,6 +1305,13 @@ Directory to hold the man pages at 'make' time
 
 Directory to hold the man pages at 'make' time
 
+=item INST_SCRIPT
+
+Directory, where executable files should be installed during
+'make'. Defaults to "./blib/bin", just to have a dummy location during
+testing. make install will copy the files in INST_SCRIPT to
+INSTALLSCRIPT.
+
 =item LDFROM
 
 defaults to "$(OBJECT)" and is used in the ld command to specify
@@ -1421,7 +1399,7 @@ this boolean variable yourself.
 
 =item NOECHO
 
-Defaults the C<@>. By setting it to an empty string you can generate a
+Defaults to C<@>. By setting it to an empty string you can generate a
 Makefile that echos all commands. Mainly used in debugging MakeMaker
 itself.
 
@@ -1501,18 +1479,19 @@ branch from that node into lib/, lib/ARCHNAME or whatever Configure
 decided at the build time of your perl (unless you override one of
 them, of course).
 
-=item PREREQ
+=item PREREQ_PM
 
-Placeholder, not yet implemented. Will eventually be a hashref: Names
-of modules that need to be available to run this extension (e.g. Fcntl
-for SDBM_File) are the keys of the hash and the desired version is the
-value. Needs further evaluation, should probably allow to define
-prerequisites among header files, libraries, perl version, etc.
+Hashref: Names of modules that need to be available to run this
+extension (e.g. Fcntl for SDBM_File) are the keys of the hash and the
+desired version is the value. If the required version number is 0, we
+only check if any version is installed already.
 
 =item SKIP
 
 Arryref. E.g. [qw(name1 name2)] skip (do not write) sections of the
-Makefile
+Makefile. Caution! Do not use the SKIP attribute for the neglectible
+speedup. It may seriously damage the resulting Makefile. Only use it,
+if you really need it.
 
 =item TYPEMAPS
 
@@ -1543,7 +1522,7 @@ B<after> the eval() will be assigned to the VERSION attribute of the
 MakeMaker object. The following lines will be parsed o.k.:
 
     $VERSION = '1.00';
-    ( $VERSION ) = '$Revision: 1.187 $ ' =~ /\$Revision:\s+([^\s]+)/;
+    ( $VERSION ) = '$Revision: 1.201 $ ' =~ /\$Revision:\s+([^\s]+)/;
     $FOO::VERSION = '1.10';
 
 but these will fail:
@@ -1587,7 +1566,7 @@ to the value of the VERSION attribute.
 =head2 Additional lowercase attributes
 
 can be used to pass parameters to the methods which implement that
-part of the Makefile. These are not normally required:
+part of the Makefile.
 
 =over 2
 
@@ -1603,7 +1582,7 @@ part of the Makefile. These are not normally required:
 
   {TARFLAGS => 'cvfF', COMPRESS => 'gzip', SUFFIX => 'gz',
   SHAR => 'shar -m', DIST_CP => 'ln', ZIP => '/bin/zip',
-  ZIPFLAGS => '-rl'}
+  ZIPFLAGS => '-rl', DIST_DEFAULT => 'private tardist' }
 
 If you specify COMPRESS, then SUFFIX should also be altered, as it is
 needed to tell make the target file of the compression. Setting
@@ -1665,15 +1644,15 @@ either say:
 or you can edit the default by saying something like:
 
 	sub MY::c_o {
-	    my $self = shift;
-	    local *c_o;
-            $_=$self->MM::c_o;
-	    s/old text/new text/;
-	    $_;
+            my($inherited) = shift->SUPER::c_o(@_);
+	    $inherited =~ s/old text/new text/;
+	    $inherited;
 	}
 
-Both methods above are available for backwards compatibility with
-older Makefile.PLs.
+If you running experiments with embedding perl as a library into other
+applications, you might find MakeMaker not sufficient. You'd better
+have a look at ExtUtils::embed which is a collection of utilities for
+embedding.
 
 If you still need a different solution, try to develop another
 subroutine, that fits your needs and submit the diffs to
@@ -1692,6 +1671,24 @@ Makefile:
     }
 
 
+=head2 Hintsfile support
+
+MakeMaker.pm uses the architecture specific information from
+Config.pm. In addition it evaluates architecture specific hints files
+in a C<hints/> directory. The hints files are expected to be named
+like their counterparts in C<PERL_SRC/hints>, but with an C<.pl> file
+name extension (eg. C<next_3_2.pl>). They are simply C<eval>ed by
+MakeMaker within the WriteMakefile() subroutine, and can be used to
+execute commands as well as to include special variables. The rules
+which hintsfile is chosen are the same as in Configure.
+
+The hintsfile is eval()ed immediately after the arguments given to
+WriteMakefile are stuffed into a hash reference $self but before this
+reference becomes blessed. So if you want to do the equivalent to
+override or create an attribute you would say something like
+
+    $self->{LIBS} = ['-ldbm -lucb -lc'];
+
 =head2 Distribution Support
 
 For authors of extensions MakeMaker provides several Makefile
@@ -1737,7 +1734,9 @@ a make test in that directory.
 =item    make tardist
 
 First does a distdir. Then a command $(PREOP) which defaults to a null
-command. Next it runs C<tar> on that directory into a tarfile and
+command, followed by $(TOUNIX), which defaults to a null command under
+UNIX, and will convert files in distribution directory to UNIX format
+otherwise. Next it runs C<tar> on that directory into a tarfile and
 deletes the directory. Finishes with a command $(POSTOP) which
 defaults to a null command.
 
@@ -1778,6 +1777,7 @@ following parameters are recognized:
     COMPRESS     ('compress')
     POSTOP       ('@ :')
     PREOP        ('@ :')
+    TO_UNIX      (depends on the system)
     RCS_LABEL    ('rcs -q -Nv$(VERSION_SYM):')
     SHAR         ('shar')
     SUFFIX       ('Z')
@@ -1790,6 +1790,10 @@ An example:
 
     WriteMakefile( 'dist' => { COMPRESS=>"gzip", SUFFIX=>"gz" })
 
+=head1 SEE ALSO
+
+ExtUtils::MM_Unix, ExtUtils::Manifest, ExtUtils::testlib,
+ExtUtils::Install, ExtUtils::embed
 
 =head1 AUTHORS
 
@@ -1801,13 +1805,4 @@ Zakharevich F<E<lt>ilya@math.ohio-state.eduE<gt>>. Contact the
 makemaker mailing list C<mailto:makemaker@franz.ww.tu-berlin.de>, if
 you have any questions.
 
-=head1 MODIFICATION HISTORY
-
-For a more complete documentation see the file Changes in the
-MakeMaker distribution package.
-
-=head1 TODO
-
-See the file Todo in the MakeMaker distribution package.
-
 =cut
diff --git a/lib/ExtUtils/Manifest.pm b/lib/ExtUtils/Manifest.pm
index eb55560c94..14d0f6e1be 100644
--- a/lib/ExtUtils/Manifest.pm
+++ b/lib/ExtUtils/Manifest.pm
@@ -15,7 +15,7 @@ $Debug = 0;
 $Verbose = 1;
 $Is_VMS = $^O eq 'VMS';
 
-$VERSION = $VERSION = substr(q$Revision: 1.23 $,10,4);
+$VERSION = $VERSION = substr(q$Revision: 1.24 $,10,4);
 
 $Quiet = 0;
 
@@ -36,7 +36,7 @@ sub mkmanifest {
     my $matches = _maniskip();
     my $found = manifind();
     my($key,$val,$file,%all);
-    my %all = (%$found, %$read);
+    %all = (%$found, %$read);
     $all{$MANIFEST} = ($Is_VMS ? "$MANIFEST\t\t" : '') . 'This list of files'
         if $manimiss; # add new MANIFEST to known file list
     foreach $file (sort keys %all) {
@@ -138,7 +138,7 @@ sub _maniskip {
     my ($mfile) = @_;
     my $matches = sub {0};
     my @skip ;
-    my $mfile = "$MANIFEST.SKIP" unless defined $mfile;
+    $mfile = "$MANIFEST.SKIP" unless defined $mfile;
     local *M;
     return $matches unless -f $mfile;
     open M, $mfile or return $matches;
@@ -290,8 +290,10 @@ comments are seperated by one or more TAB characters in the
 output. All files that match any regular expression in a file
 C<MANIFEST.SKIP> (if such a file exists) are ignored.
 
-Manicheck() checks if all the files within a C<MANIFEST> in the current
-directory really do exist.
+Manicheck() checks if all the files within a C<MANIFEST> in the
+current directory really do exist. It only reports discrepancies and
+exits silently if MANIFEST and the tree below the current directory
+are in sync.
 
 Filecheck() finds files below the current directory that are not
 mentioned in the C<MANIFEST> file. An optional file C<MANIFEST.SKIP>
diff --git a/lib/ExtUtils/Mksymlists.pm b/lib/ExtUtils/Mksymlists.pm
index 87b2b8fd22..5c0173a508 100644
--- a/lib/ExtUtils/Mksymlists.pm
+++ b/lib/ExtUtils/Mksymlists.pm
@@ -4,13 +4,14 @@ use strict qw[ subs refs ];
 
 use Carp;
 use Exporter;
-# mention vars twice to prevent single-use warnings
-@ExtUtils::Mksymlists::ISA = @ExtUtils::Mksymlists::ISA = 'Exporter';
-@ExtUtils::Mksymlists::EXPORT = @ExtUtils::Mksymlists::EXPORT = '&Mksymlists';
-$ExtUtils::Mksymlists::VERSION = $ExtUtils::Mksymlists::VERSION = '1.00';
+use vars qw( @ISA @EXPORT $VERSION );
+@ISA = 'Exporter';
+@EXPORT = '&Mksymlists';
+$VERSION = '1.03';
 
 sub Mksymlists {
     my(%spec) = @_;
+    my($osname) = $^O;
 
     croak("Insufficient information specified to Mksymlists")
         unless ( $spec{NAME} or
@@ -44,10 +45,10 @@ sub Mksymlists {
         $spec{DLBASE} = DynaLoader::mod2fname([ split(/::/,$spec{NAME}) ]);
     }
 
-    if    ($^O eq 'aix') { _write_aix(\%spec); }
-    elsif ($^O eq 'VMS') { _write_vms(\%spec) }
-    elsif ($^O eq 'os2') { _write_os2(\%spec) }
-    else { croak("Don't know how to create linker option file for $^O\n"); }
+    if    ($osname eq 'aix') { _write_aix(\%spec); }
+    elsif ($osname eq 'VMS') { _write_vms(\%spec) }
+    elsif ($osname =~ m|^os/?2$|i) { _write_os2(\%spec) }
+    else { croak("Don't know how to create linker option file for $osname\n"); }
 }
 
 
@@ -95,7 +96,7 @@ while (($name, $exp)= each %{$data->{IMPORTS}}) {
 sub _write_vms {
     my($data) = @_;
 
-    require Config;
+    require Config; # a reminder for once we do $^O
 
     my($isvax) = $Config::Config{'arch'} =~ /VAX/i;
     my($sym);