Update ExtUtils-MakeMaker to CPAN version 7.02
authorChris 'BinGOs' Williams <chris@bingosnet.co.uk>
Sat, 8 Nov 2014 14:11:24 +0000 (14:11 +0000)
committerChris 'BinGOs' Williams <chris@bingosnet.co.uk>
Mon, 10 Nov 2014 13:57:27 +0000 (13:57 +0000)
  [DELTA]

7.02 Sat Nov  8 07:13:40 GMT 2014

    No changes from 7.01_09

7.01_09 Thu Nov  6 21:41:32 GMT 2014
    Test fixes:
    - Marked a test in pm_to_blib.t as TODO until further
      investigation can be scheduled

7.01_08 Tue Nov  4 20:24:29 GMT 2014
    Test fixes:
    - roll back change in 7.01_07 and scrub PERL_INSTALL_QUIET
      environment variable

7.01_07 Tue Nov  4 19:26:46 GMT 2014
    Test fixes:
    - Changed a regex in pm_to_blib.t to be more forgiving

7.01_06 Mon Nov  3 20:31:05 GMT 2014
    Bug fixes:
    - Resolved regression with TEST_FILES

    Win32 fixes:
    - Targetted fix for nmake bug
    - miniperl.t core test fixed for Windows

7.01_05 Mon Nov  3 10:14:11 GMT 2014
    VMS fixes:
    - Handle switches in $(PERL) by prepending MCR
    - Don't quote MAKE on VMS in Test::Utils

7.01_04 Fri Oct 31 09:38:06 GMT 2014
    API change:
    - writeMakefile() has been removed after 20 years of being deprecated

    Bug fixes:
    - Regression in xs.t with older versions of xsubpp has been resolved
    - We now don't produce Borland C export symbols if BCC support dropped

7.01_03 Thu Oct 30 19:12:57 GMT 2014
    Bug fixes:
    - Using NMAKE was broken this has been fixed

7.01_02 Sat Oct 25 17:45:46 BST 2014
    Bug fixes:
    - Resolve a regression with FIXIN and core builds on Win32

7.01_01 Sat Oct 25 13:45:00 BST 2014
    Bug fixes:
    - Resolve issue with Win32 perl builds in core

7.00 Wed Oct 22 20:13:38 BST 2014

    No changes from 6.99_18

6.99_18 Mon Oct 20 10:02:58 BST 2014
    Bug fixes:
    - Resolve regression with taint and get_version() [RT#99580]

    VMS fixes:
    - Avoid .NOTPARALLEL on VMS as it is a syntax error for MMS and MMK
    - Quotes are not stripped from argv[0] on VMS so need stripping
    - Move MCR from PERL to PERLRUN on VMS and other *RUN variables

6.99_17 Sun Oct 12 19:37:04 BST 2014
    Bug fixes:
    - Fix test that got broke under core since 6.99_15

6.99_16 Thu Oct  2 19:29:49 BST 2014
    Dist fixes:
    - Move File::Copy::Recursive from bundled to where it is
      used, so that it will not get installed as a runtime
      prereq

6.99_15 Sun Sep 21 13:21:46 BST 2014
    Enhancements:
    - If core, add ccwarnflags and ccstdflags, if available

    Doc fixes:
    - Fix internal links

6.99_14 Fri Sep 19 14:59:08 BST 2014
    Bug fixes:
    - Fixes to fallback version module for core integration problems

6.99_13 Mon Sep 15 20:02:47 BST 2014
    Enhancements:
    - Bundle Encode::Locale as ExtUtils::MakeMaker::Locale

    Bug fixes:
    - Make included version module have standardised dist versioning

6.99_12 Thu Sep 11 15:27:31 BST 2014
    Enhancements:
    - Now include a fallback version module for bootstrapping

    Bug fixes:
    - Support libfoo.0.dylib style libraries on Darwin

6.99_11 Mon Sep  8 14:20:26 BST 2014
    Bug fixes:
    - Handle chcp failure better on MSWin32
    - Tests should be parallelisable once again

    Doc fixes:
    - Document that GNU make is usable on MSWin32 now

6.99_10 Thu Sep  4 14:28:01 BST 2014
    Bug fixes:
    - Fixes for being integrated with core
    - Fixed the code page reset on MSWin32
    - Fixed test failures on BSD with UTF8 filenames
    - Fixed regression with quoting of $(PERL) when
      command line flags are used

6.99_09 Thu Aug 28 11:01:37 BST 2014
    Enhancements:
    - Support GNU Make on Windows
    - Support paths and filenames that are UTF8 encoded
    - MM->can_run() added for finding programs (ported from
      IPC::Cmd)

    Bug fixes:
    - Handle UTF8 when generating manpages correctly
    - Generated Makefile contents are now consistently sorted

6.99_08 Mon Aug 18 14:17:04 BST 2014
    Bug fixes:
    - Liblist::Kid: can now handle -l:foo.so invocations properly
    - Scripts will no longer have the 'not running under some shell' code
      applied when rewriting shebang lines.
    - version is now used to parse prereqs versions internally
    - Support UTF8 encoded command-line args and Makefile.PL args
    - Generated META.files will now always have linefeed EOLs, even on
      Windows
    - Rewrite the version line eval handling to have less insane edge cases

    Doc fixes:
    - Documentation now includes links to Dist::Zilla, File::ShareDir and
      File::ShareDir::Install
    - Clarified support policy for < v5.8.1 in README

    Misc:
    - Updated bundled CPAN::Meta::Requirements to version 2.126
    - Updated bundled ExtUtils::Manifest to version 1.65

6.99_07 Wed Jul 30 17:36:14 BST 2014
    Bug fixes:
    - Resolve 'wide character in print' warnings

6.99_06 Mon Jul 28 15:02:25 BST 2014
    Enhancements:
    - Improvements and tests for the spaces-in-stuff handling

6.99_05 Tue Jul 22 12:32:03 BST 2014
    Enhancements:
    - Enable working with (including installing to) directories with spaces in names

6.99_04 Sat Jul 12 12:43:08 BST 2014
    Enhancements:
    - No longer report each file being manified. Only summarise.

6.99_03 Fri Jul  4 11:02:21 BST 2014
    Doc Fixes:
    - PATCHING document has been rewritten as CONTRIBUTING and TODO
      document has been removed

    Bug Fixes:
    - Rearranged bundled prereqs so CPAN::Meta::Requirements won't
      get stomped on if it is installed already, but CPAN::Meta isn't

6.99_02 Thu Jun  5 12:15:28 BST 2014
    Bug fixes:
    * MM->parse_version will no longer warn if it could
      not determine the $VERSION due to syntax errors etc.

6.99_01 Tue Jun  3 22:17:30 BST 2014
    Bug fixes:
    * Disregard some warnings during tests when cross-compiling

    Doc fixes:
    * Clarified the use and limitations of META_ADD, META_MERGE

    Test fixes:
    * Sanitise env vars in tests

61 files changed:
MANIFEST
Makefile.SH
Porting/Maintainers.pl
cpan/ExtUtils-MakeMaker/lib/ExtUtils/Command/MM.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/Liblist.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/Liblist/Kid.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_AIX.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_Any.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_BeOS.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_Cygwin.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_DOS.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_Darwin.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_MacOS.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_NW5.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_OS2.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_QNX.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_UWIN.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_Unix.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_VMS.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_VOS.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_Win32.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_Win95.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MY.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Config.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/FAQ.pod
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Locale.pm [new file with mode: 0644]
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Tutorial.pod
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version.pm [new file with mode: 0644]
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/regex.pm [new file with mode: 0644]
cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/vpp.pm [new file with mode: 0644]
cpan/ExtUtils-MakeMaker/lib/ExtUtils/Mkbootstrap.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/Mksymlists.pm
cpan/ExtUtils-MakeMaker/lib/ExtUtils/testlib.pm
cpan/ExtUtils-MakeMaker/t/FIRST_MAKEFILE.t
cpan/ExtUtils-MakeMaker/t/INSTALL_BASE.t
cpan/ExtUtils-MakeMaker/t/MM_Unix.t
cpan/ExtUtils-MakeMaker/t/MakeMaker_Parameters.t
cpan/ExtUtils-MakeMaker/t/PL_FILES.t
cpan/ExtUtils-MakeMaker/t/basic.t
cpan/ExtUtils-MakeMaker/t/cd.t
cpan/ExtUtils-MakeMaker/t/echo.t
cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/Unicode.pm [new file with mode: 0644]
cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/XS.pm
cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Utils.pm
cpan/ExtUtils-MakeMaker/t/meta_convert.t
cpan/ExtUtils-MakeMaker/t/min_perl_version.t
cpan/ExtUtils-MakeMaker/t/miniperl.t
cpan/ExtUtils-MakeMaker/t/oneliner.t
cpan/ExtUtils-MakeMaker/t/parse_version.t
cpan/ExtUtils-MakeMaker/t/pm_to_blib.t
cpan/ExtUtils-MakeMaker/t/postamble.t
cpan/ExtUtils-MakeMaker/t/prereq.t
cpan/ExtUtils-MakeMaker/t/recurs.t
cpan/ExtUtils-MakeMaker/t/several_authors.t
cpan/ExtUtils-MakeMaker/t/unicode.t [new file with mode: 0644]
cpan/ExtUtils-MakeMaker/t/vstrings.t [new file with mode: 0644]
cpan/ExtUtils-MakeMaker/t/writemakefile_args.t
cpan/ExtUtils-MakeMaker/t/xs.t
t/porting/customized.dat

index c1b8e17..dc48d47 100644 (file)
--- a/MANIFEST
+++ b/MANIFEST
@@ -971,8 +971,12 @@ cpan/ExtUtils-MakeMaker/lib/ExtUtils/Liblist/Kid.pm                Does the real work of the a
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/Liblist.pm                        Locates libraries
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Config.pm       MakeMaker wrapper for Config
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/FAQ.pod         MakeMaker FAQ
+cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Locale.pm
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker.pm              Write Makefiles for extensions
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Tutorial.pod    Writing a module with MakeMaker
+cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version.pm
+cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/regex.pm
+cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/vpp.pm
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/Mkbootstrap.pm            Writes a bootstrap file (see MakeMaker)
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/Mksymlists.pm             Writes a linker options file for extensions
 cpan/ExtUtils-MakeMaker/lib/ExtUtils/MM_AIX.pm                 MakeMaker methods for AIX
@@ -1021,6 +1025,7 @@ cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/PL_FILES.pm    MakeMaker test ut
 cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/Problem.pm  MakeMaker test utilities
 cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/Recurs.pm   MakeMaker test utilities
 cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/SAS.pm      MakeMaker test utilities
+cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/Unicode.pm
 cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/XS.pm       MakeMaker test utilities
 cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Utils.pm          MakeMaker test utilities
 cpan/ExtUtils-MakeMaker/t/lib/TieIn.pm                         Testing library for dummy input handles
@@ -1066,7 +1071,9 @@ cpan/ExtUtils-MakeMaker/t/test_boilerplate.t                      MakeMaker test
 cpan/ExtUtils-MakeMaker/t/testdata/reallylongdirectoryname/arch1/Config.pm     test data for MakeMaker
 cpan/ExtUtils-MakeMaker/t/testdata/reallylongdirectoryname/arch2/Config.pm     test data for MakeMaker
 cpan/ExtUtils-MakeMaker/t/testlib.t                            See if ExtUtils::testlib works
+cpan/ExtUtils-MakeMaker/t/unicode.t
 cpan/ExtUtils-MakeMaker/t/VERSION_FROM.t                       See if MakeMaker's VERSION_FROM works
+cpan/ExtUtils-MakeMaker/t/vstrings.t
 cpan/ExtUtils-MakeMaker/t/WriteEmptyMakefile.t                 See if WriteEmptyMakefile works
 cpan/ExtUtils-MakeMaker/t/writemakefile_args.t                 See if WriteMakefile works
 cpan/ExtUtils-MakeMaker/t/xs.t                                 Part of MakeMaker's test suite
index 66061c4..df82d33 100755 (executable)
@@ -1306,8 +1306,9 @@ _cleaner2:
        -rmdir lib/IO/Compress/Adapter lib/IO/Compress lib/IO
        -rmdir lib/I18N/LangTags lib/I18N lib/Hash/Util lib/Hash lib/HTTP
        -rmdir lib/Filter/Util lib/Filter lib/File/Spec lib/ExtUtils/Typemaps
-       -rmdir lib/ExtUtils/ParseXS lib/ExtUtils/MakeMaker
-       -rmdir lib/ExtUtils/Liblist lib/ExtUtils/Constant lib/ExtUtils/Command
+       -rmdir lib/ExtUtils/ParseXS lib/ExtUtils/MakeMaker/version
+       -rmdir lib/ExtUtils/MakeMaker lib/ExtUtils/Liblist
+       -rmdir lib/ExtUtils/Constant lib/ExtUtils/Command
        -rmdir lib/ExtUtils/CBuilder/Platform/Windows
        -rmdir lib/ExtUtils/CBuilder/Platform lib/ExtUtils/CBuilder
        -rmdir lib/Exporter lib/Encode/Unicode lib/Encode/MIME/Header
index a018ae4..5b4fc50 100755 (executable)
@@ -473,7 +473,7 @@ use File::Glob qw(:case);
     },
 
     'ExtUtils::MakeMaker' => {
-        'DISTRIBUTION' => 'BINGOS/ExtUtils-MakeMaker-6.98.tar.gz',
+        'DISTRIBUTION' => 'BINGOS/ExtUtils-MakeMaker-7.02.tar.gz',
         'FILES'        => q[cpan/ExtUtils-MakeMaker],
         'EXCLUDED'     => [
             qr{^t/lib/Test/},
@@ -485,12 +485,6 @@ use File::Glob qw(:case);
             'README.packaging',
         ],
         'CUSTOMIZED'   => [
-            # Already merged upstream in GitHub 0116aaf4e, just awaiting
-            # a new stable CPAN release
-            qw(        t/pm_to_blib.t ),
-            # Already merged upstream in GitHub 46586b12c, just awaiting
-            # a new stable CPAN release
-            qw( lib/ExtUtils/Liblist/Kid.pm ),
         ],
     },
 
index f45d41d..fcabd2e 100644 (file)
@@ -10,7 +10,7 @@ our @ISA = qw(Exporter);
 
 our @EXPORT  = qw(test_harness pod2man perllocal_install uninstall
                   warn_if_old_packlist test_s cp_nonempty);
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 my $Is_VMS = $^O eq 'VMS';
 
@@ -116,8 +116,9 @@ sub pod2man {
                 'section|s=s', 'release|r=s', 'center|c=s',
                 'date|d=s', 'fixed=s', 'fixedbold=s', 'fixeditalic=s',
                 'fixedbolditalic=s', 'official|o', 'quotes|q=s', 'lax|l',
-                'name|n=s', 'perm_rw=i'
+                'name|n=s', 'perm_rw=i', 'utf8|u'
     );
+    delete $options{utf8} unless $Pod::Man::VERSION >= 2.17;
 
     # If there's no files, don't bother going further.
     return 0 unless @ARGV;
@@ -130,6 +131,9 @@ sub pod2man {
     # This isn't a valid Pod::Man option and is only accepted for backwards
     # compatibility.
     delete $options{lax};
+    my $count = scalar @ARGV / 2;
+    my $plural = $count == 1 ? 'document' : 'documents';
+    print "Manifying $count pod $plural\n";
 
     do {{  # so 'next' works
         my ($pod, $man) = splice(@ARGV, 0, 2);
@@ -138,8 +142,6 @@ sub pod2man {
                  (mtime($man) > mtime($pod)) &&
                  (mtime($man) > mtime("Makefile")));
 
-        print "Manifying $man\n";
-
         my $parser = Pod::Man->new(%options);
         $parser->parse_from_file($pod, $man)
           or do { warn("Could not install $man\n");  next };
index 2d21e12..3a18edf 100644 (file)
@@ -2,7 +2,7 @@ package ExtUtils::Liblist;
 
 use strict;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 use File::Spec;
 require ExtUtils::Liblist::Kid;
index 7ef793f..bb4f505 100644 (file)
@@ -11,7 +11,7 @@ use 5.006;
 
 use strict;
 use warnings;
-our $VERSION = '6.98_01';
+our $VERSION = '7.02';
 
 use ExtUtils::MakeMaker::Config;
 use Cwd 'cwd';
@@ -49,7 +49,7 @@ sub _unix_os2_ext {
     # this is a rewrite of Andy Dougherty's extliblist in perl
 
     my ( @searchpath );    # from "-L/path" entries in $potential_libs
-    my ( @libpath ) = split " ", $Config{'libpth'};
+    my ( @libpath ) = split " ", $Config{'libpth'} || '';
     my ( @ldloadlibs, @bsloadlibs, @extralibs, @ld_run_path, %ld_run_path_seen );
     my ( @libs,       %libs_seen );
     my ( $fullname,   @fullname );
@@ -57,6 +57,7 @@ sub _unix_os2_ext {
     my ( $found ) = 0;
 
     foreach my $thislib ( split ' ', $potential_libs ) {
+        my ( $custom_name ) = '';
 
         # Handle possible linker path arguments.
         if ( $thislib =~ s/^(-[LR]|-Wl,-R|-Wl,-rpath,)// ) {    # save path flag type
@@ -92,7 +93,14 @@ sub _unix_os2_ext {
         }
 
         # Handle possible library arguments.
-        unless ( $thislib =~ s/^-l// ) {
+        if ( $thislib =~ s/^-l(:)?// ) {
+            # Handle -l:foo.so, which means that the library will
+            # actually be called foo.so, not libfoo.so.  This
+            # is used in Android by ExtUtils::Depends to allow one XS
+            # module to link to another.
+            $custom_name = $1 || '';
+        }
+        else {
             warn "Unrecognized argument in LIBS ignored: '$thislib'\n";
             next;
         }
@@ -178,6 +186,8 @@ sub _unix_os2_ext {
                 #
                 # , the compilation tools expand the environment variables.)
             }
+            elsif ( $custom_name && -f ( $fullname = "$thispth/$thislib" ) ) {
+            }
             else {
                 warn "$thislib not found in $thispth\n" if $verbose;
                 next;
@@ -191,7 +201,7 @@ sub _unix_os2_ext {
 
             # what do we know about this library...
             my $is_dyna = ( $fullname !~ /\Q$Config_libext\E\z/ );
-            my $in_perl = ( $libs =~ /\B-l\Q${thislib}\E\b/s );
+            my $in_perl = ( $libs =~ /\B-l:?\Q${thislib}\E\b/s );
 
             # include the path to the lib once in the dynamic linker path
             # but only if it is a dynamic lib and not in Perl itself
@@ -211,7 +221,7 @@ sub _unix_os2_ext {
                     && ( $thislib eq 'm' || $thislib eq 'ndbm' ) )
               )
             {
-                push( @extralibs, "-l$thislib" );
+                push( @extralibs, "-l$custom_name$thislib" );
             }
 
             # We might be able to load this archive file dynamically
@@ -233,11 +243,11 @@ sub _unix_os2_ext {
 
                     # For SunOS4, do not add in this shared library if
                     # it is already linked in the main perl executable
-                    push( @ldloadlibs, "-l$thislib" )
+                    push( @ldloadlibs, "-l$custom_name$thislib" )
                       unless ( $in_perl and $^O eq 'sunos' );
                 }
                 else {
-                    push( @ldloadlibs, "-l$thislib" );
+                    push( @ldloadlibs, "-l$custom_name$thislib" );
                 }
             }
             last;    # found one here so don't bother looking further
@@ -332,8 +342,8 @@ sub _win32_ext {
     return ( '', '', '', '', ( $give_libs ? \@libs : () ) ) unless @extralibs;
 
     # make sure paths with spaces are properly quoted
-    @extralibs = map { /\s/ ? qq["$_"] : $_ } @extralibs;
-    @libs      = map { /\s/ ? qq["$_"] : $_ } @libs;
+    @extralibs = map { qq["$_"] } @extralibs;
+    @libs      = map { qq["$_"] } @libs;
 
     my $lib = join( ' ', @extralibs );
 
index a34015f..4deb3f2 100644 (file)
@@ -3,7 +3,7 @@ package ExtUtils::MM;
 use strict;
 use ExtUtils::MakeMaker::Config;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::Liblist;
 require ExtUtils::MakeMaker;
index 7c600a6..fd3b948 100644 (file)
@@ -1,7 +1,7 @@
 package ExtUtils::MM_AIX;
 
 use strict;
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Unix;
 our @ISA = qw(ExtUtils::MM_Unix);
index 2066311..9b86c2c 100644 (file)
@@ -1,7 +1,7 @@
 package ExtUtils::MM_Any;
 
 use strict;
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 use Carp;
 use File::Spec;
@@ -125,6 +125,142 @@ sub can_load_xs {
 }
 
 
+=head3 can_run
+
+  use ExtUtils::MM;
+  my $runnable = MM->can_run($Config{make});
+
+If called in a scalar context it will return the full path to the binary
+you asked for if it was found, or C<undef> if it was not.
+
+If called in a list context, it will return a list of the full paths to instances
+of the binary where found in C<PATH>, or an empty list if it was not found.
+
+Copied from L<IPC::Cmd|IPC::Cmd/"$path = can_run( PROGRAM );">, but modified into
+a method (and removed C<$INSTANCES> capability).
+
+=cut
+
+sub can_run {
+    my ($self, $command) = @_;
+
+    # a lot of VMS executables have a symbol defined
+    # check those first
+    if ( $^O eq 'VMS' ) {
+        require VMS::DCLsym;
+        my $syms = VMS::DCLsym->new;
+        return $command if scalar $syms->getsym( uc $command );
+    }
+
+    my @possibles;
+
+    if( File::Spec->file_name_is_absolute($command) ) {
+        return $self->maybe_command($command);
+
+    } else {
+        for my $dir (
+            File::Spec->path,
+            File::Spec->curdir
+        ) {
+            next if ! $dir || ! -d $dir;
+            my $abs = File::Spec->catfile($self->os_flavor_is('Win32') ? Win32::GetShortPathName( $dir ) : $dir, $command);
+            push @possibles, $abs if $abs = $self->maybe_command($abs);
+        }
+    }
+    return @possibles if wantarray;
+    return shift @possibles;
+}
+
+
+=head3 can_redirect_error
+
+  $useredirect = MM->can_redirect_error;
+
+True if on an OS where qx operator (or backticks) can redirect C<STDERR>
+onto C<STDOUT>.
+
+=cut
+
+sub can_redirect_error {
+  my $self = shift;
+  $self->os_flavor_is('Unix')
+      or ($self->os_flavor_is('Win32') and !$self->os_flavor_is('Win9x'))
+      or $self->os_flavor_is('OS/2')
+}
+
+
+=head3 is_make_type
+
+    my $is_dmake = $self->is_make_type('dmake');
+
+Returns true if C<<$self->make>> is the given type; possibilities are:
+
+  gmake    GNU make
+  dmake
+  nmake
+  bsdmake  BSD pmake-derived
+
+=cut
+
+sub is_make_type {
+    my($self, $type) = @_;
+    (undef, undef, my $make_basename) = $self->splitpath($self->make);
+    return 1 if $make_basename =~ /\b$type\b/; # executable's filename
+    # now have to run with "-v" and guess
+    my $redirect = $self->can_redirect_error ? '2>&1' : '';
+    my $make = $self->make || $self->{MAKE};
+    my $minus_v = `"$make" -v $redirect`;
+    return 1 if $type eq 'gmake' and $minus_v =~ /GNU make/i;
+    return 1 if $type eq 'bsdmake'
+      and $minus_v =~ /^usage: make \[-BeikNnqrstWwX\]/im;
+    0; # it wasn't whatever you asked
+}
+
+
+=head3 can_dep_space
+
+    my $can_dep_space = $self->can_dep_space;
+
+Returns true if C<make> can handle (probably by quoting)
+dependencies that contain a space. Currently known true for GNU make,
+false for BSD pmake derivative.
+
+=cut
+
+my $cached_dep_space;
+sub can_dep_space {
+    my $self = shift;
+    return $cached_dep_space if defined $cached_dep_space;
+    return $cached_dep_space = 1 if $self->is_make_type('gmake');
+    return $cached_dep_space = 0 if $self->is_make_type('dmake'); # only on W32
+    return $cached_dep_space = 0 if $self->is_make_type('bsdmake');
+    return $cached_dep_space = 0; # assume no
+}
+
+
+=head3 quote_dep
+
+  $text = $mm->quote_dep($text);
+
+Method that protects Makefile single-value constants (mainly filenames),
+so that make will still treat them as single values even if they
+inconveniently have spaces in. If the make program being used cannot
+achieve such protection and the given text would need it, throws an
+exception.
+
+=cut
+
+sub quote_dep {
+    my ($self, $arg) = @_;
+    die <<EOF if $arg =~ / / and not $self->can_dep_space;
+Tried to use make dependency with space for make that can't:
+  '$arg'
+EOF
+    $arg =~ s/( )/\\$1/g; # how GNU make does it
+    return $arg;
+}
+
+
 =head3 split_command
 
     my @cmds = $MM->split_command($cmd, @args);
@@ -781,9 +917,10 @@ END
     my @man_cmds;
     foreach my $section (qw(1 3)) {
         my $pods = $self->{"MAN${section}PODS"};
-        push @man_cmds, $self->split_command(<<CMD, map {($_,$pods->{$_})} sort keys %$pods);
-       \$(NOECHO) \$(POD2MAN) --section=$section --perm_rw=\$(PERM_RW)
+        my $p2m = sprintf <<CMD, $] > 5.008 ? " -u" : "";
+       \$(NOECHO) \$(POD2MAN) --section=$section --perm_rw=\$(PERM_RW)%s
 CMD
+        push @man_cmds, $self->split_command($p2m, map {($_,$pods->{$_})} sort keys %$pods);
     }
 
     $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds;
@@ -1037,8 +1174,7 @@ sub _add_requirements_to_meta_v1_4 {
     # Check the original args so we can tell between the user setting it
     # to an empty hash and it just being initialized.
     if( $self->{ARGS}{CONFIGURE_REQUIRES} ) {
-        $meta{configure_requires}
-            = _normalize_prereqs($self->{CONFIGURE_REQUIRES});
+        $meta{configure_requires} = $self->{CONFIGURE_REQUIRES};
     } else {
         $meta{configure_requires} = {
             'ExtUtils::MakeMaker'       => 0,
@@ -1046,7 +1182,7 @@ sub _add_requirements_to_meta_v1_4 {
     }
 
     if( $self->{ARGS}{BUILD_REQUIRES} ) {
-        $meta{build_requires} = _normalize_prereqs($self->{BUILD_REQUIRES});
+        $meta{build_requires} = $self->{BUILD_REQUIRES};
     } else {
         $meta{build_requires} = {
             'ExtUtils::MakeMaker'       => 0,
@@ -1056,11 +1192,11 @@ sub _add_requirements_to_meta_v1_4 {
     if( $self->{ARGS}{TEST_REQUIRES} ) {
         $meta{build_requires} = {
           %{ $meta{build_requires} },
-          %{ _normalize_prereqs($self->{TEST_REQUIRES}) },
+          %{ $self->{TEST_REQUIRES} },
         };
     }
 
-    $meta{requires} = _normalize_prereqs($self->{PREREQ_PM})
+    $meta{requires} = $self->{PREREQ_PM}
         if defined $self->{PREREQ_PM};
     $meta{requires}{perl} = _normalize_version($self->{MIN_PERL_VERSION})
         if $self->{MIN_PERL_VERSION};
@@ -1074,8 +1210,7 @@ sub _add_requirements_to_meta_v2 {
     # Check the original args so we can tell between the user setting it
     # to an empty hash and it just being initialized.
     if( $self->{ARGS}{CONFIGURE_REQUIRES} ) {
-        $meta{prereqs}{configure}{requires}
-            = _normalize_prereqs($self->{CONFIGURE_REQUIRES});
+        $meta{prereqs}{configure}{requires} = $self->{CONFIGURE_REQUIRES};
     } else {
         $meta{prereqs}{configure}{requires} = {
             'ExtUtils::MakeMaker'       => 0,
@@ -1083,7 +1218,7 @@ sub _add_requirements_to_meta_v2 {
     }
 
     if( $self->{ARGS}{BUILD_REQUIRES} ) {
-        $meta{prereqs}{build}{requires} = _normalize_prereqs($self->{BUILD_REQUIRES});
+        $meta{prereqs}{build}{requires} = $self->{BUILD_REQUIRES};
     } else {
         $meta{prereqs}{build}{requires} = {
             'ExtUtils::MakeMaker'       => 0,
@@ -1091,10 +1226,10 @@ sub _add_requirements_to_meta_v2 {
     }
 
     if( $self->{ARGS}{TEST_REQUIRES} ) {
-        $meta{prereqs}{test}{requires} = _normalize_prereqs($self->{TEST_REQUIRES});
+        $meta{prereqs}{test}{requires} = $self->{TEST_REQUIRES};
     }
 
-    $meta{prereqs}{runtime}{requires} = _normalize_prereqs($self->{PREREQ_PM})
+    $meta{prereqs}{runtime}{requires} = $self->{PREREQ_PM}
         if $self->{ARGS}{PREREQ_PM};
     $meta{prereqs}{runtime}{requires}{perl} = _normalize_version($self->{MIN_PERL_VERSION})
         if $self->{MIN_PERL_VERSION};
@@ -1102,15 +1237,6 @@ sub _add_requirements_to_meta_v2 {
     return %meta;
 }
 
-sub _normalize_prereqs {
-  my ($hash) = @_;
-  my %prereqs;
-  while ( my ($k,$v) = each %$hash ) {
-    $prereqs{$k} = _normalize_version($v);
-  }
-  return \%prereqs;
-}
-
 # Adapted from Module::Build::Base
 sub _normalize_version {
   my ($version) = @_;
@@ -1993,7 +2119,7 @@ sub init_VERSION {
     if (defined $self->{VERSION}) {
         if ( $self->{VERSION} !~ /^\s*v?[\d_\.]+\s*$/ ) {
           require version;
-          my $normal = eval { version->parse( $self->{VERSION} ) };
+          my $normal = eval { version->new( $self->{VERSION} ) };
           $self->{VERSION} = $normal if defined $normal;
         }
         $self->{VERSION} =~ s/^\s+//;
@@ -2060,7 +2186,7 @@ Defines at least these macros.
 sub init_tools {
     my $self = shift;
 
-    $self->{ECHO}     ||= $self->oneliner('print qq{@ARGV}', ['-l']);
+    $self->{ECHO}     ||= $self->oneliner('binmode STDOUT, qq{:raw}; print qq{@ARGV}', ['-l']);
     $self->{ECHO_N}   ||= $self->oneliner('print qq{@ARGV}');
 
     $self->{TOUCH}    ||= $self->oneliner('touch', ["-MExtUtils::Command"]);
@@ -2722,7 +2848,7 @@ Used by perldepend() in MM_Unix and MM_VMS via _perl_header_files_fragment()
 sub _perl_header_files {
     my $self = shift;
 
-    my $header_dir = $self->{PERL_SRC} || $self->catdir($Config{archlibexp}, 'CORE');
+    my $header_dir = $self->{PERL_SRC} || $ENV{PERL_SRC} || $self->catdir($Config{archlibexp}, 'CORE');
     opendir my $dh, $header_dir
         or die "Failed to opendir '$header_dir' to find header files: $!";
 
@@ -2759,7 +2885,7 @@ sub _perl_header_files_fragment {
     return join("\\\n",
                 "PERL_HDRS = ",
                 map {
-                    sprintf( "        \$(PERL_INC)%s%s            ", $separator, $_ )
+                    sprintf( "        \$(PERL_INCDEP)%s%s            ", $separator, $_ )
                 } $self->_perl_header_files()
            ) . "\n\n"
            . "\$(OBJECT) : \$(PERL_HDRS)\n";
index 060ce36..101c452 100644 (file)
@@ -26,7 +26,7 @@ require ExtUtils::MM_Any;
 require ExtUtils::MM_Unix;
 
 our @ISA = qw( ExtUtils::MM_Any ExtUtils::MM_Unix );
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 
 =item os_flavor
@@ -50,6 +50,7 @@ sub init_linker {
 
     $self->{PERL_ARCHIVE} ||=
       File::Spec->catdir('$(PERL_INC)',$Config{libperl});
+    $self->{PERL_ARCHIVEDEP} ||= '';
     $self->{PERL_ARCHIVE_AFTER} ||= '';
     $self->{EXPORT_LIST}  ||= '';
 }
index d8f3e3a..03cb12c 100644 (file)
@@ -9,7 +9,7 @@ require ExtUtils::MM_Unix;
 require ExtUtils::MM_Win32;
 our @ISA = qw( ExtUtils::MM_Unix );
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 
 =head1 NAME
@@ -94,6 +94,7 @@ sub init_linker {
           '$(PERL_INC)' .'/'. ("$Config{libperl}" or "libperl.a");
     }
 
+    $self->{PERL_ARCHIVEDEP} ||= '';
     $self->{PERL_ARCHIVE_AFTER} ||= '';
     $self->{EXPORT_LIST}  ||= '';
 }
index 4f52a98..a58c1c3 100644 (file)
@@ -2,7 +2,7 @@ package ExtUtils::MM_DOS;
 
 use strict;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Any;
 require ExtUtils::MM_Unix;
index 861a544..49634db 100644 (file)
@@ -7,7 +7,7 @@ BEGIN {
     our @ISA = qw( ExtUtils::MM_Unix );
 }
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 
 =head1 NAME
index cd3a12a..5f76952 100644 (file)
@@ -2,7 +2,7 @@ package ExtUtils::MM_MacOS;
 
 use strict;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 sub new {
     die <<'UNSUPPORTED';
index f6b0b5b..331576d 100644 (file)
@@ -22,7 +22,7 @@ use strict;
 use ExtUtils::MakeMaker::Config;
 use File::Basename;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Win32;
 our @ISA = qw(ExtUtils::MM_Win32);
index 52bc4d1..a9d8011 100644 (file)
@@ -5,7 +5,7 @@ use strict;
 use ExtUtils::MakeMaker qw(neatvalue);
 use File::Spec;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Any;
 require ExtUtils::MM_Unix;
@@ -129,6 +129,7 @@ sub init_linker {
 
     $self->{PERL_ARCHIVE} = "\$(PERL_INC)/libperl\$(LIB_EXT)";
 
+    $self->{PERL_ARCHIVEDEP} ||= '';
     $self->{PERL_ARCHIVE_AFTER} = $OS2::is_aout
       ? ''
       : '$(PERL_INC)/libperl_override$(LIB_EXT)';
index 7b74bf4..c115771 100644 (file)
@@ -1,7 +1,7 @@
 package ExtUtils::MM_QNX;
 
 use strict;
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Unix;
 our @ISA = qw(ExtUtils::MM_Unix);
index 5b97300..97683fc 100644 (file)
@@ -1,7 +1,7 @@
 package ExtUtils::MM_UWIN;
 
 use strict;
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Unix;
 our @ISA = qw(ExtUtils::MM_Unix);
index 4140432..f0d223f 100644 (file)
@@ -15,7 +15,7 @@ use ExtUtils::MakeMaker qw($Verbose neatvalue);
 
 # If we make $VERSION an our variable parse_version() breaks
 use vars qw($VERSION);
-$VERSION = '6.98';
+$VERSION = '7.02';
 $VERSION = eval $VERSION;  ## no critic [BuiltinFunctions::ProhibitStringyEval]
 
 require ExtUtils::MM_Any;
@@ -190,6 +190,19 @@ sub cflags {
 
     @cflags{qw(cc ccflags optimize shellflags)}
        = @Config{qw(cc ccflags optimize shellflags)};
+
+    # Perl 5.21.4 adds the (gcc) warning (-Wall ...) and std (-std=c89)
+    # flags to the %Config, and the modules in the core can be built
+    # with those.
+    my @ccextraflags = qw(ccwarnflags ccstdflags);
+    if ($ENV{PERL_CORE}) {
+      for my $x (@ccextraflags) {
+        if (exists $Config{$x}) {
+          $cflags{$x} = $Config{$x};
+        }
+      }
+    }
+
     my($optdebug) = "";
 
     $cflags{shellflags} ||= '';
@@ -258,6 +271,10 @@ sub cflags {
        $self->{CCFLAGS} .= ' -DPERL_POLLUTE ';
     }
 
+    for my $x (@ccextraflags) {
+      $self->{CCFLAGS} .= $cflags{$x} if exists $cflags{$x};
+    }
+
     my $pollute = '';
     if ($Config{usemymalloc} and not $Config{bincompat5005}
        and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/
@@ -387,10 +404,10 @@ sub constants {
                         } $self->installvars),
                    qw(
               PERL_LIB
-              PERL_ARCHLIB
+              PERL_ARCHLIB PERL_ARCHLIBDEP
               LIBPERL_A MYEXTLIB
               FIRST_MAKEFILE MAKEFILE_OLD MAKE_APERL_FILE
-              PERLMAINCC PERL_SRC PERL_INC
+              PERLMAINCC PERL_SRC PERL_INC PERL_INCDEP
               PERL            FULLPERL          ABSPERL
               PERLRUN         FULLPERLRUN       ABSPERLRUN
               PERLRUNINST     FULLPERLRUNINST   ABSPERLRUNINST
@@ -404,6 +421,8 @@ sub constants {
         # pathnames can have sharp signs in them; escape them so
         # make doesn't think it is a comment-start character.
         $self->{$macro} =~ s/#/\\#/g;
+       $self->{$macro} = $self->quote_dep($self->{$macro})
+         if $ExtUtils::MakeMaker::macro_dep{$macro};
        push @m, "$macro = $self->{$macro}\n";
     }
 
@@ -443,7 +462,7 @@ MAN3PODS = ".$self->wraplist(sort keys %{$self->{MAN3PODS}})."
 
     push @m, q{
 # Where is the Config information that we are using/depend on
-CONFIGDEP = $(PERL_ARCHLIB)$(DFSEP)Config.pm $(PERL_INC)$(DFSEP)config.h
+CONFIGDEP = $(PERL_ARCHLIBDEP)$(DFSEP)Config.pm $(PERL_INCDEP)$(DFSEP)config.h
 } if -e File::Spec->catfile( $self->{PERL_INC}, 'config.h' );
 
 
@@ -460,11 +479,11 @@ INST_DYNAMIC     = $self->{INST_DYNAMIC}
 INST_BOOT        = $self->{INST_BOOT}
 };
 
-
     push @m, qq{
 # Extra linker info
 EXPORT_LIST        = $self->{EXPORT_LIST}
 PERL_ARCHIVE       = $self->{PERL_ARCHIVE}
+PERL_ARCHIVEDEP    = $self->{PERL_ARCHIVEDEP}
 PERL_ARCHIVE_AFTER = $self->{PERL_ARCHIVE_AFTER}
 };
 
@@ -878,8 +897,8 @@ $(BOOTSTRAP) : $(FIRST_MAKEFILE) $(BOOTDEP) $(INST_ARCHAUTODIR)$(DFSEP).exists
        $(NOECHO) $(PERLRUN) \
                "-MExtUtils::Mkbootstrap" \
                -e "Mkbootstrap('$(BASEEXT)','$(BSLOADLIBS)');"
-       $(NOECHO) $(TOUCH) %s
-       $(CHMOD) $(PERM_RW) %s
+       $(NOECHO) $(TOUCH) "%s"
+       $(CHMOD) $(PERM_RW) "%s"
 MAKE_FRAG
 }
 
@@ -911,7 +930,7 @@ OTHERLDFLAGS = '.$ld_opt.$otherldflags.'
 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
 INST_DYNAMIC_FIX = '.$ld_fix.'
 
-$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
+$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPORT_LIST) $(PERL_ARCHIVEDEP) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
 ');
     if ($armaybe ne ':'){
        $ldfrom = 'tmp$(LIB_EXT)';
@@ -940,13 +959,13 @@ $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPO
        # platforms.  We peek at lddlflags to see if we need -Wl,-R
        # or -R to add paths to the run-time library search path.
         if ($Config{'lddlflags'} =~ /-Wl,-R/) {
-            $libs .= ' -L$(PERL_INC) -Wl,-R$(INSTALLARCHLIB)/CORE -Wl,-R$(PERL_ARCHLIB)/CORE -lperl';
+            $libs .= ' "-L$(PERL_INC)" "-Wl,-R$(INSTALLARCHLIB)/CORE" "-Wl,-R$(PERL_ARCHLIB)/CORE" -lperl';
         } elsif ($Config{'lddlflags'} =~ /-R/) {
-            $libs .= ' -L$(PERL_INC) -R$(INSTALLARCHLIB)/CORE -R$(PERL_ARCHLIB)/CORE -lperl';
+            $libs .= ' "-L$(PERL_INC)" "-R$(INSTALLARCHLIB)/CORE" "-R$(PERL_ARCHLIB)/CORE" -lperl';
         } elsif ( $Is{Android} ) {
             # The Android linker will not recognize symbols from
             # libperl unless the module explicitly depends on it.
-            $libs .= ' -L$(PERL_INC) -lperl';
+            $libs .= ' "-L$(PERL_INC)" -lperl';
         }
     }
 
@@ -1043,7 +1062,7 @@ WARNING
             next unless $self->maybe_command($abs);
             print "Executing $abs\n" if ($trace >= 2);
 
-            my $version_check = qq{$abs -le "require $ver; print qq{VER_OK}"};
+            my $version_check = qq{"$abs" -le "require $ver; print qq{VER_OK}"};
 
             # To avoid using the unportable 2>&1 to suppress STDERR,
             # we close it before running the command.
@@ -1191,10 +1210,6 @@ sub _fixin_replace_shebang {
             $shb .= ' ' . $arg if defined $arg;
             $shb .= "\n";
         }
-        $shb .= qq{
-eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
-    if 0; # not running under some shell
-} unless $Is{Win32};    # this won't work on win32, so don't
     }
     else {
         warn "Can't find $cmd in PATH, $file unchanged"
@@ -1712,6 +1727,8 @@ EOP
        $self->{PERL_LIB} = File::Spec->rel2abs($self->{PERL_LIB});
        $self->{PERL_ARCHLIB} = File::Spec->rel2abs($self->{PERL_ARCHLIB});
     }
+    $self->{PERL_INCDEP} = $self->{PERL_INC};
+    $self->{PERL_ARCHLIBDEP} = $self->{PERL_ARCHLIB};
 
     # We get SITELIBEXP and SITEARCHEXP directly via
     # Get_from_Config. When we are running standard modules, these
@@ -1805,6 +1822,7 @@ Unix has no need of special linker flags.
 sub init_linker {
     my($self) = shift;
     $self->{PERL_ARCHIVE} ||= '';
+    $self->{PERL_ARCHIVEDEP} ||= '';
     $self->{PERL_ARCHIVE_AFTER} ||= '';
     $self->{EXPORT_LIST}  ||= '';
 }
@@ -1909,8 +1927,20 @@ sub init_PERL {
 
     $self->{PERL} ||=
         $self->find_perl(5.0, \@perls, \@defpath, $Verbose );
-    # don't check if perl is executable, maybe they have decided to
-    # supply switches with perl
+
+    my $perl = $self->{PERL};
+    $perl =~ s/^"//;
+    my $has_mcr = $perl =~ s/^MCR\s*//;
+    my $perlflags = '';
+    my $stripped_perl;
+    while ($perl) {
+       ($stripped_perl = $perl) =~ s/"$//;
+       last if -x $stripped_perl;
+       last unless $perl =~ s/(\s+\S+)$//;
+       $perlflags = $1.$perlflags;
+    }
+    $self->{PERL} = $stripped_perl;
+    $self->{PERL} = 'MCR '.$self->{PERL} if $has_mcr || $Is{VMS};
 
     # When built for debugging, VMS doesn't create perl.exe but ndbgperl.exe.
     my $perl_name = 'perl';
@@ -1920,13 +1950,18 @@ sub init_PERL {
     # XXX This logic is flawed.  If "miniperl" is anywhere in the path
     # it will get confused.  It should be fixed to work only on the filename.
     # Define 'FULLPERL' to be a non-miniperl (used in test: target)
-    ($self->{FULLPERL} = $self->{PERL}) =~ s/\Q$miniperl\E$/$perl_name$Config{exe_ext}/i
-       unless $self->{FULLPERL};
+    unless ($self->{FULLPERL}) {
+      ($self->{FULLPERL} = $self->{PERL}) =~ s/\Q$miniperl\E$/$perl_name$Config{exe_ext}/i;
+      $self->{FULLPERL} = qq{"$self->{FULLPERL}"}.$perlflags;
+    }
+    # Can't have an image name with quotes, and findperl will have
+    # already escaped spaces.
+    $self->{FULLPERL} =~ tr/"//d if $Is{VMS};
 
     # Little hack to get around VMS's find_perl putting "MCR" in front
     # sometimes.
     $self->{ABSPERL} = $self->{PERL};
-    my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
+    $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
     if( $self->file_name_is_absolute($self->{ABSPERL}) ) {
         $self->{ABSPERL} = '$(PERL)';
     }
@@ -1939,6 +1974,11 @@ sub init_PERL {
 
         $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
     }
+    $self->{PERL} = qq{"$self->{PERL}"}.$perlflags;
+
+    # Can't have an image name with quotes, and findperl will have
+    # already escaped spaces.
+    $self->{PERL} =~ tr/"//d if $Is{VMS};
 
     # Are we building the core?
     $self->{PERL_CORE} = $ENV{PERL_CORE} unless exists $self->{PERL_CORE};
@@ -1948,14 +1988,15 @@ sub init_PERL {
     foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
         my $run  = $perl.'RUN';
 
-        $self->{$run}  = "\$($perl)";
+        $self->{$run}  = qq{\$($perl)};
 
         # Make sure perl can find itself before it's installed.
         $self->{$run} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"}
           if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE};
 
         $self->{$perl.'RUNINST'} =
-          sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
+          sprintf q{$(%sRUN)%s "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"},
+           $perl, $perlflags;
     }
 
     return 1;
@@ -2079,54 +2120,54 @@ pure_perl_install :: all
 };
 
     push @m,
-q{             read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
-               write }.$self->catfile('$(DESTINSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
+q{             read "}.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{" \
+               write "}.$self->catfile('$(DESTINSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{" \
 } unless $self->{NO_PACKLIST};
 
     push @m,
-q{             $(INST_LIB) $(DESTINSTALLPRIVLIB) \
-               $(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \
-               $(INST_BIN) $(DESTINSTALLBIN) \
-               $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
-               $(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \
-               $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR)
+q{             "$(INST_LIB)" "$(DESTINSTALLPRIVLIB)" \
+               "$(INST_ARCHLIB)" "$(DESTINSTALLARCHLIB)" \
+               "$(INST_BIN)" "$(DESTINSTALLBIN)" \
+               "$(INST_SCRIPT)" "$(DESTINSTALLSCRIPT)" \
+               "$(INST_MAN1DIR)" "$(DESTINSTALLMAN1DIR)" \
+               "$(INST_MAN3DIR)" "$(DESTINSTALLMAN3DIR)"
        $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
-               }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
+               "}.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{"
 
 
 pure_site_install :: all
        $(NOECHO) $(MOD_INSTALL) \
 };
     push @m,
-q{             read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
-               write }.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
+q{             read "}.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{" \
+               write "}.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{" \
 } unless $self->{NO_PACKLIST};
 
     push @m,
-q{             $(INST_LIB) $(DESTINSTALLSITELIB) \
-               $(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \
-               $(INST_BIN) $(DESTINSTALLSITEBIN) \
-               $(INST_SCRIPT) $(DESTINSTALLSITESCRIPT) \
-               $(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \
-               $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR)
+q{             "$(INST_LIB)" "$(DESTINSTALLSITELIB)" \
+               "$(INST_ARCHLIB)" "$(DESTINSTALLSITEARCH)" \
+               "$(INST_BIN)" "$(DESTINSTALLSITEBIN)" \
+               "$(INST_SCRIPT)" "$(DESTINSTALLSITESCRIPT)" \
+               "$(INST_MAN1DIR)" "$(DESTINSTALLSITEMAN1DIR)" \
+               "$(INST_MAN3DIR)" "$(DESTINSTALLSITEMAN3DIR)"
        $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
-               }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
+               "}.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{"
 
 pure_vendor_install :: all
        $(NOECHO) $(MOD_INSTALL) \
 };
     push @m,
-q{             read }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
-               write }.$self->catfile('$(DESTINSTALLVENDORARCH)','auto','$(FULLEXT)','.packlist').q{ \
+q{             read "}.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{" \
+               write "}.$self->catfile('$(DESTINSTALLVENDORARCH)','auto','$(FULLEXT)','.packlist').q{" \
 } unless $self->{NO_PACKLIST};
 
     push @m,
-q{             $(INST_LIB) $(DESTINSTALLVENDORLIB) \
-               $(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \
-               $(INST_BIN) $(DESTINSTALLVENDORBIN) \
-               $(INST_SCRIPT) $(DESTINSTALLVENDORSCRIPT) \
-               $(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \
-               $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR)
+q{             "$(INST_LIB)" "$(DESTINSTALLVENDORLIB)" \
+               "$(INST_ARCHLIB)" "$(DESTINSTALLVENDORARCH)" \
+               "$(INST_BIN)" "$(DESTINSTALLVENDORBIN)" \
+               "$(INST_SCRIPT)" "$(DESTINSTALLVENDORSCRIPT)" \
+               "$(INST_MAN1DIR)" "$(DESTINSTALLVENDORMAN1DIR)" \
+               "$(INST_MAN3DIR)" "$(DESTINSTALLVENDORMAN3DIR)"
 
 };
 
@@ -2144,37 +2185,37 @@ doc_vendor_install :: all
 
     push @m, q{
 doc_perl_install :: all
-       $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
-       -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
+       $(NOECHO) $(ECHO) Appending installation info to "$(DESTINSTALLARCHLIB)/perllocal.pod"
+       -$(NOECHO) $(MKPATH) "$(DESTINSTALLARCHLIB)"
        -$(NOECHO) $(DOC_INSTALL) \
                "Module" "$(NAME)" \
-               "installed into" "$(INSTALLPRIVLIB)" \
+               "installed into" $(INSTALLPRIVLIB) \
                LINKTYPE "$(LINKTYPE)" \
                VERSION "$(VERSION)" \
                EXE_FILES "$(EXE_FILES)" \
-               >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
+               >> "}.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{"
 
 doc_site_install :: all
-       $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
-       -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
+       $(NOECHO) $(ECHO) Appending installation info to "$(DESTINSTALLARCHLIB)/perllocal.pod"
+       -$(NOECHO) $(MKPATH) "$(DESTINSTALLARCHLIB)"
        -$(NOECHO) $(DOC_INSTALL) \
                "Module" "$(NAME)" \
-               "installed into" "$(INSTALLSITELIB)" \
+               "installed into" $(INSTALLSITELIB) \
                LINKTYPE "$(LINKTYPE)" \
                VERSION "$(VERSION)" \
                EXE_FILES "$(EXE_FILES)" \
-               >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
+               >> "}.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{"
 
 doc_vendor_install :: all
-       $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
-       -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
+       $(NOECHO) $(ECHO) Appending installation info to "$(DESTINSTALLARCHLIB)/perllocal.pod"
+       -$(NOECHO) $(MKPATH) "$(DESTINSTALLARCHLIB)"
        -$(NOECHO) $(DOC_INSTALL) \
                "Module" "$(NAME)" \
-               "installed into" "$(INSTALLVENDORLIB)" \
+               "installed into" $(INSTALLVENDORLIB) \
                LINKTYPE "$(LINKTYPE)" \
                VERSION "$(VERSION)" \
                EXE_FILES "$(EXE_FILES)" \
-               >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
+               >> "}.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{"
 
 } unless $self->{NO_PERLLOCAL};
 
@@ -2183,13 +2224,13 @@ uninstall :: uninstall_from_$(INSTALLDIRS)dirs
        $(NOECHO) $(NOOP)
 
 uninstall_from_perldirs ::
-       $(NOECHO) $(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
+       $(NOECHO) $(UNINSTALL) "}.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{"
 
 uninstall_from_sitedirs ::
-       $(NOECHO) $(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
+       $(NOECHO) $(UNINSTALL) "}.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{"
 
 uninstall_from_vendordirs ::
-       $(NOECHO) $(UNINSTALL) }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{
+       $(NOECHO) $(UNINSTALL) "}.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{"
 };
 
     join("",@m);
@@ -2343,7 +2384,7 @@ $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE) pm_to_blib
        $(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
        $(NOECHO) $(PERLRUNINST) \
-               Makefile.PL DIR=}, $dir, q{ \
+               Makefile.PL DIR="}, $dir, q{" \
                MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
                MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
 
@@ -2521,20 +2562,20 @@ $tmp/perlmain.c: $makefilename}, q{
                -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
 
 };
-    push @m, "\t", q{$(NOECHO) $(PERL) $(INSTALLSCRIPT)/fixpmain
+    push @m, "\t", q{$(NOECHO) $(PERL) "$(INSTALLSCRIPT)/fixpmain"
 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
 
 
     push @m, q{
 doc_inst_perl :
-       $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
-       -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
+       $(NOECHO) $(ECHO) Appending installation info to "$(DESTINSTALLARCHLIB)/perllocal.pod"
+       -$(NOECHO) $(MKPATH) "$(DESTINSTALLARCHLIB)"
        -$(NOECHO) $(DOC_INSTALL) \
                "Perl binary" "$(MAP_TARGET)" \
                MAP_STATIC "$(MAP_STATIC)" \
                MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
                MAP_LIBPERL "$(MAP_LIBPERL)" \
-               >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
+               >> "}.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{"
 
 };
 
@@ -2542,7 +2583,7 @@ doc_inst_perl :
 inst_perl : pure_inst_perl doc_inst_perl
 
 pure_inst_perl : $(MAP_TARGET)
-       }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{
+       }.$self->{CP}.q{ $(MAP_TARGET) "}.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{"
 
 clean :: map_clean
 
@@ -2651,17 +2692,24 @@ sub parse_abstract {
     local $/ = "\n";
     open(my $fh, '<', $parsefile) or die "Could not open '$parsefile': $!";
     my $inpod = 0;
+    my $pod_encoding;
     my $package = $self->{DISTNAME};
     $package =~ s/-/::/g;
     while (<$fh>) {
         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
         next if !$inpod;
         chop;
+
+        if ( /^=encoding\s*(.*)$/i ) {
+            $pod_encoding = $1;
+        }
+
         if ( /^($package(?:\.pm)? \s+ -+ \s+)(.*)/x ) {
           $result = $2;
           next;
         }
         next unless $result;
+
         if ( $result && ( /^\s*$/ || /^\=/ ) ) {
           last;
         }
@@ -2669,6 +2717,11 @@ sub parse_abstract {
     }
     close $fh;
 
+    if ( $pod_encoding and !( $] < 5.008 or !$Config{useperlio} ) ) {
+        require Encode;
+        $result = Encode::decode($pod_encoding, $result);
+    }
+
     return $result;
 }
 
@@ -2721,43 +2774,32 @@ sub parse_version {
 
     if ( defined $result && $result !~ /^v?[\d_\.]+$/ ) {
       require version;
-      my $normal = eval { version->parse( $result ) };
+      my $normal = eval { version->new( $result ) };
       $result = $normal if defined $normal;
     }
     $result = "undef" unless defined $result;
     return $result;
 }
 
-sub get_version
-{
-       my ($self, $parsefile, $sigil, $name) = @_;
-       my $eval = qq{
-               package ExtUtils::MakeMaker::_version;
-               no strict;
-               BEGIN { eval {
-                       # Ensure any version() routine which might have leaked
-                       # into this package has been deleted.  Interferes with
-                       # version->import()
-                       undef *version;
-                       require version;
-                       "version"->import;
-               } }
-
-               local $sigil$name;
-               \$$name=undef;
-               do {
-                       $_
-               };
-               \$$name;
-       };
-  $eval = $1 if $eval =~ m{^(.+)}s;
-       local $^W = 0;
-       my $result = eval($eval);  ## no critic
-       warn "Could not eval '$eval' in $parsefile: $@" if $@;
-       $result;
+sub get_version {
+    my ($self, $parsefile, $sigil, $name) = @_;
+    my $line = $_; # from the while() loop in parse_version
+    {
+        package ExtUtils::MakeMaker::_version;
+        undef *version; # in case of unexpected version() sub
+        eval {
+            require version;
+            version::->import;
+        };
+        no strict;
+        local *{$name};
+        local $^W = 0;
+        $line = $1 if $line =~ m{^(.+)}s;
+        eval($line); ## no critic
+        return ${$name};
+    }
 }
 
-
 =item pasthru (o)
 
 Defines the string that is passed to recursive make calls in
@@ -2821,7 +2863,7 @@ sub perldepend {
 # 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
+$(PERL_INCDEP)/config.h: $(PERL_SRC)/config.sh
        -$(NOECHO) $(ECHO) "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; $(FALSE)
 
 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
@@ -2837,7 +2879,7 @@ MAKE_FRAG
         push @m, $self->_perl_header_files_fragment("/"); # Directory separator between $(PERL_INC)/header.h
     }
 
-    push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
+    push @m, join(" ", sort values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
 
     return join "\n", @m;
 }
@@ -2960,11 +3002,11 @@ PPD_PERLVERS
     foreach my $prereq (sort keys %prereqs) {
         my $name = $prereq;
         $name .= '::' unless $name =~ /::/;
-        my $version = $prereqs{$prereq}+0;  # force numification
+        my $version = $prereqs{$prereq};
 
         my %attrs = ( NAME => $name );
         $attrs{VERSION} = $version if $version;
-        my $attrs = join " ", map { qq[$_="$attrs{$_}"] } keys %attrs;
+        my $attrs = join " ", map { qq[$_="$attrs{$_}"] } sort keys %attrs;
         $ppd_xml .= qq(        <REQUIRE $attrs />\n);
     }
 
@@ -3198,6 +3240,17 @@ sub oneliner {
 
 =item quote_literal
 
+Quotes macro literal value suitable for being used on a command line so
+that when expanded by make, will be received by command as given to
+this method:
+
+  my $quoted = $mm->quote_literal(q{it isn't});
+  # returns:
+  #   'it isn'\''t'
+  print MAKEFILE "target:\n\techo $quoted\n";
+  # when run "make target", will output:
+  #   it isn't
+
 =cut
 
 sub quote_literal {
@@ -3287,7 +3340,7 @@ END
     # If this extension has its own library (eg SDBM_File)
     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
     push(@m, <<'MAKE_FRAG') if $self->{MYEXTLIB};
-       $(CP) $(MYEXTLIB) $@
+       $(CP) $(MYEXTLIB) "$@"
 MAKE_FRAG
 
     my $ar;
@@ -3301,12 +3354,12 @@ MAKE_FRAG
     push @m, sprintf <<'MAKE_FRAG', $ar;
        $(%s) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
        $(CHMOD) $(PERM_RWX) $@
-       $(NOECHO) $(ECHO) "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
+       $(NOECHO) $(ECHO) "$(EXTRALIBS)" > "$(INST_ARCHAUTODIR)/extralibs.ld"
 MAKE_FRAG
 
     # Old mechanism - still available:
     push @m, <<'MAKE_FRAG' if $self->{PERL_SRC} && $self->{EXTRALIBS};
-       $(NOECHO) $(ECHO) "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
+       $(NOECHO) $(ECHO) "$(EXTRALIBS)" >> "$(PERL_SRC)/ext.libs"
 MAKE_FRAG
 
     join('', @m);
@@ -3420,6 +3473,8 @@ sub test {
     elsif (!$tests && -d 't') {
         $tests = $self->find_tests;
     }
+    # have to do this because nmake is broken
+    $tests =~ s!/!\\!g if $self->is_make_type('nmake');
     # note: 'test.pl' name is also hardcoded in init_dirscan()
     my(@m);
     push(@m,"
@@ -3545,7 +3600,8 @@ sub tool_xsubpp {
         }
     }
     push(@tmdeps, "typemap") if -f "typemap";
-    my(@tmargs) = map("-typemap $_", @tmdeps);
+    my @tmargs = map(qq{-typemap "$_"}, @tmdeps);
+    $_ = $self->quote_dep($_) for @tmdeps;
     if( exists $self->{XSOPT} ){
         unshift( @tmargs, $self->{XSOPT} );
     }
@@ -3561,17 +3617,19 @@ sub tool_xsubpp {
 
 
     $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
+    my $xsdirdep = $self->quote_dep($xsdir);
+    # -dep for use when dependency not command
 
     return qq{
 XSUBPPDIR = $xsdir
-XSUBPP = \$(XSUBPPDIR)\$(DFSEP)xsubpp
+XSUBPP = "\$(XSUBPPDIR)\$(DFSEP)xsubpp"
 XSUBPPRUN = \$(PERLRUN) \$(XSUBPP)
 XSPROTOARG = $self->{XSPROTOARG}
-XSUBPPDEPS = @tmdeps \$(XSUBPP)
+XSUBPPDEPS = @tmdeps $xsdirdep\$(DFSEP)xsubpp
 XSUBPPARGS = @tmargs
 XSUBPP_EXTRA_ARGS =
 };
-};
+}
 
 
 =item all_target
index 331cbcd..13900b2 100644 (file)
@@ -15,7 +15,7 @@ BEGIN {
 
 use File::Basename;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Any;
 require ExtUtils::MM_Unix;
@@ -1893,6 +1893,7 @@ sub init_linker {
           $ENV{$shr} ? $ENV{$shr} : "Sys\$Share:$shr.$Config{'dlext'}";
     }
 
+    $self->{PERL_ARCHIVEDEP} ||= '';
     $self->{PERL_ARCHIVE_AFTER} ||= '';
 }
 
index 648ba54..0d0dab5 100644 (file)
@@ -1,7 +1,7 @@
 package ExtUtils::MM_VOS;
 
 use strict;
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Unix;
 our @ISA = qw(ExtUtils::MM_Unix);
index e056d2e..1f6d833 100644 (file)
@@ -27,7 +27,7 @@ use ExtUtils::MakeMaker qw( neatvalue );
 require ExtUtils::MM_Any;
 require ExtUtils::MM_Unix;
 our @ISA = qw( ExtUtils::MM_Any ExtUtils::MM_Unix );
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 $ENV{EMXSHELL} = 'sh'; # to run `commands`
 
@@ -128,7 +128,7 @@ sub maybe_command {
 
 =item B<init_DIRFILESEP>
 
-Using \ for Windows.
+Using \ for Windows, except for "gmake" where it is /.
 
 =cut
 
@@ -137,7 +137,8 @@ sub init_DIRFILESEP {
 
     # The ^ makes sure its not interpreted as an escape in nmake
     $self->{DIRFILESEP} = $self->is_make_type('nmake') ? '^\\' :
-                          $self->is_make_type('dmake') ? '\\\\'
+                          $self->is_make_type('dmake') ? '\\\\' :
+                          $self->is_make_type('gmake') ? '/'
                                                        : '\\';
 }
 
@@ -154,7 +155,7 @@ sub init_tools {
     $self->{DEV_NULL} ||= '> NUL';
 
     $self->{FIXIN}    ||= $self->{PERL_CORE} ?
-      "\$(PERLRUN) $self->{PERL_SRC}/win32/bin/pl2bat.pl" :
+      "\$(PERLRUN) $self->{PERL_SRC}\\win32\\bin\\pl2bat.pl" :
       'pl2bat.bat';
 
     $self->SUPER::init_tools;
@@ -346,27 +347,27 @@ sub dynamic_lib {
 OTHERLDFLAGS = '.$otherldflags.'
 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
 
-$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
+$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPORT_LIST) $(PERL_ARCHIVEDEP) $(INST_DYNAMIC_DEP)
 ');
     if ($GCC) {
       push(@m,
        q{      }.$DLLTOOL.q{ --def $(EXPORT_LIST) --output-exp dll.exp
-       $(LD) -o $@ -Wl,--base-file -Wl,dll.base $(LDDLFLAGS) }.$ldfrom.q{ $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) dll.exp
+       $(LD) -o $@ -Wl,--base-file -Wl,dll.base $(LDDLFLAGS) }.$ldfrom.q{ $(OTHERLDFLAGS) $(MYEXTLIB) "$(PERL_ARCHIVE)" $(LDLOADLIBS) dll.exp
        }.$DLLTOOL.q{ --def $(EXPORT_LIST) --base-file dll.base --output-exp dll.exp
-       $(LD) -o $@ $(LDDLFLAGS) }.$ldfrom.q{ $(OTHERLDFLAGS) $(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) dll.exp });
+       $(LD) -o $@ $(LDDLFLAGS) }.$ldfrom.q{ $(OTHERLDFLAGS) $(MYEXTLIB) "$(PERL_ARCHIVE)" $(LDLOADLIBS) dll.exp });
     } elsif ($BORLAND) {
       push(@m,
        q{      $(LD) $(LDDLFLAGS) $(OTHERLDFLAGS) }.$ldfrom.q{,$@,,}
        .($self->is_make_type('dmake')
-                ? q{$(PERL_ARCHIVE:s,/,\,) $(LDLOADLIBS:s,/,\,) }
+                ? q{"$(PERL_ARCHIVE:s,/,\,)" $(LDLOADLIBS:s,/,\,) }
                 .q{$(MYEXTLIB:s,/,\,),$(EXPORT_LIST:s,/,\,)}
-               : q{$(subst /,\,$(PERL_ARCHIVE)) $(subst /,\,$(LDLOADLIBS)) }
+               : q{"$(subst /,\,$(PERL_ARCHIVE))" $(subst /,\,$(LDLOADLIBS)) }
                 .q{$(subst /,\,$(MYEXTLIB)),$(subst /,\,$(EXPORT_LIST))})
        .q{,$(RESFILES)});
     } else {   # VC
       push(@m,
        q{      $(LD) -out:$@ $(LDDLFLAGS) }.$ldfrom.q{ $(OTHERLDFLAGS) }
-      .q{$(MYEXTLIB) $(PERL_ARCHIVE) $(LDLOADLIBS) -def:$(EXPORT_LIST)});
+      .q{$(MYEXTLIB) "$(PERL_ARCHIVE)" $(LDLOADLIBS) -def:$(EXPORT_LIST)});
 
       # Embed the manifest file if it exists
       push(@m, q{
@@ -401,6 +402,7 @@ sub init_linker {
     my $self = shift;
 
     $self->{PERL_ARCHIVE}       = "\$(PERL_INC)\\$Config{libperl}";
+    $self->{PERL_ARCHIVEDEP}    = "\$(PERL_INCDEP)\\$Config{libperl}";
     $self->{PERL_ARCHIVE_AFTER} = '';
     $self->{EXPORT_LIST}        = '$(BASEEXT).def';
 }
@@ -421,6 +423,29 @@ sub perl_script {
     return;
 }
 
+sub can_dep_space {
+    my $self = shift;
+    1; # with Win32::GetShortPathName
+}
+
+=item quote_dep
+
+=cut
+
+sub quote_dep {
+    my ($self, $arg) = @_;
+    if ($arg =~ / / and not $self->is_make_type('gmake')) {
+        require Win32;
+        $arg = Win32::GetShortPathName($arg);
+        die <<EOF if not defined $arg or $arg =~ / /;
+Tried to use make dependency with space for non-GNU make:
+  '$arg'
+Fallback to short pathname failed.
+EOF
+        return $arg;
+    }
+    return $self->SUPER::quote_dep($arg);
+}
 
 =item xs_o
 
@@ -622,16 +647,7 @@ PERLTYPE = $self->{PERLTYPE}
 
 }
 
-sub is_make_type {
-    my($self, $type) = @_;
-    return !! ($self->make =~ /\b$type(?:\.exe)?$/);
-}
-
 1;
 __END__
 
 =back
-
-=cut
-
-
index 9c79580..8f0ceb9 100644 (file)
@@ -2,7 +2,7 @@ package ExtUtils::MM_Win95;
 
 use strict;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require ExtUtils::MM_Win32;
 our @ISA = qw(ExtUtils::MM_Win32);
index 37f0e9e..f946e83 100644 (file)
@@ -3,7 +3,7 @@ package ExtUtils::MY;
 use strict;
 require ExtUtils::MM;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 our @ISA = qw(ExtUtils::MM);
 
 {
index d2fabf6..028925b 100644 (file)
@@ -7,8 +7,12 @@ BEGIN {require 5.006;}
 
 require Exporter;
 use ExtUtils::MakeMaker::Config;
+use ExtUtils::MakeMaker::version; # ensure we always have or fake version.pm
 use Carp;
 use File::Path;
+my $CAN_DECODE = eval { require ExtUtils::MakeMaker::Locale; }; # 2 birds, 1 stone
+eval { ExtUtils::MakeMaker::Locale::reinit('UTF-8') }
+  if $CAN_DECODE and $ExtUtils::MakeMaker::Locale::ENCODING_LOCALE eq 'US-ASCII';
 
 our $Verbose = 0;       # exported
 our @Parent;            # needs to be localized
@@ -17,8 +21,10 @@ our @MM_Sections;
 our @Overridable;
 my @Prepend_parent;
 my %Recognized_Att_Keys;
+our %macro_fsentity; # whether a macro is a filesystem name
+our %macro_dep; # whether a macro is a dependency
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 $VERSION = eval $VERSION;  ## no critic [BuiltinFunctions::ProhibitStringyEval]
 
 # Emulate something resembling CVS $Revision$
@@ -28,7 +34,7 @@ $Revision = int $Revision * 10000;
 our $Filename = __FILE__;   # referenced outside MakeMaker
 
 our @ISA = qw(Exporter);
-our @EXPORT    = qw(&WriteMakefile &writeMakefile $Verbose &prompt);
+our @EXPORT    = qw(&WriteMakefile $Verbose &prompt);
 our @EXPORT_OK = qw($VERSION &neatvalue &mkbootstrap &mksymlists
                     &WriteEmptyMakefile);
 
@@ -36,6 +42,7 @@ our @EXPORT_OK = qw($VERSION &neatvalue &mkbootstrap &mksymlists
 # purged.
 my $Is_VMS     = $^O eq 'VMS';
 my $Is_Win32   = $^O eq 'MSWin32';
+my $UNDER_CORE = $ENV{PERL_CORE};
 
 full_setup();
 
@@ -250,14 +257,12 @@ my $PACKNAME = 'PACK000';
 sub full_setup {
     $Verbose ||= 0;
 
-    my @attrib_help = qw/
+    my @dep_macros = qw/
+    PERL_INCDEP        PERL_ARCHLIBDEP     PERL_ARCHIVEDEP
+    /;
 
-    AUTHOR ABSTRACT ABSTRACT_FROM BINARY_LOCATION
-    C CAPI CCFLAGS CONFIG CONFIGURE DEFINE DIR DISTNAME DISTVNAME
-    DL_FUNCS DL_VARS
-    EXCLUDE_EXT EXE_FILES FIRST_MAKEFILE
-    FULLPERL FULLPERLRUN FULLPERLRUNINST
-    FUNCLIST H IMPORTS
+    my @fs_macros = qw/
+    FULLPERL XSUBPPDIR
 
     INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB INST_MAN1DIR INST_MAN3DIR
     INSTALLDIRS
@@ -273,22 +278,41 @@ sub full_setup {
     PERL_LIB        PERL_ARCHLIB
     SITELIBEXP      SITEARCHEXP
 
-    INC INCLUDE_EXT LDFROM LIB LIBPERL_A LIBS LICENSE
-    LINKTYPE MAKE MAKEAPERL MAKEFILE MAKEFILE_OLD MAN1PODS MAN3PODS MAP_TARGET
+    MAKE LIBPERL_A LIB PERL_SRC PERL_INC
+    PPM_INSTALL_EXEC PPM_UNINSTALL_EXEC
+    PPM_INSTALL_SCRIPT PPM_UNINSTALL_SCRIPT
+    /;
+
+    my @attrib_help = qw/
+
+    AUTHOR ABSTRACT ABSTRACT_FROM BINARY_LOCATION
+    C CAPI CCFLAGS CONFIG CONFIGURE DEFINE DIR DISTNAME DISTVNAME
+    DL_FUNCS DL_VARS
+    EXCLUDE_EXT EXE_FILES FIRST_MAKEFILE
+    FULLPERLRUN FULLPERLRUNINST
+    FUNCLIST H IMPORTS
+
+    INC INCLUDE_EXT LDFROM LIBS LICENSE
+    LINKTYPE MAKEAPERL MAKEFILE MAKEFILE_OLD MAN1PODS MAN3PODS MAP_TARGET
     META_ADD META_MERGE MIN_PERL_VERSION BUILD_REQUIRES CONFIGURE_REQUIRES
     MYEXTLIB NAME NEEDS_LINKING NOECHO NO_META NO_MYMETA NO_PACKLIST NO_PERLLOCAL
     NORECURS NO_VC OBJECT OPTIMIZE PERL_MALLOC_OK PERL PERLMAINCC PERLRUN
     PERLRUNINST PERL_CORE
-    PERL_SRC PERM_DIR PERM_RW PERM_RWX MAGICXS
-    PL_FILES PM PM_FILTER PMLIBDIRS PMLIBPARENTDIRS POLLUTE PPM_INSTALL_EXEC PPM_UNINSTALL_EXEC
-    PPM_INSTALL_SCRIPT PPM_UNINSTALL_SCRIPT PREREQ_FATAL PREREQ_PM PREREQ_PRINT PRINT_PREREQ
+    PERM_DIR PERM_RW PERM_RWX MAGICXS
+    PL_FILES PM PM_FILTER PMLIBDIRS PMLIBPARENTDIRS POLLUTE
+    PREREQ_FATAL PREREQ_PM PREREQ_PRINT PRINT_PREREQ
     SIGN SKIP TEST_REQUIRES TYPEMAPS UNINST VERSION VERSION_FROM XS XSOPT XSPROTOARG
     XS_VERSION clean depend dist dynamic_lib linkext macro realclean
     tool_autosplit
 
+    MAN1EXT MAN3EXT
+
     MACPERL_SRC MACPERL_LIB MACLIBS_68K MACLIBS_PPC MACLIBS_SC MACLIBS_MRC
     MACLIBS_ALL_68K MACLIBS_ALL_PPC MACLIBS_SHARED
         /;
+    push @attrib_help, @fs_macros;
+    @macro_fsentity{@fs_macros, @dep_macros} = (1) x (@fs_macros+@dep_macros);
+    @macro_dep{@dep_macros} = (1) x @dep_macros;
 
     # IMPORTS is used under OS/2 and Win32
 
@@ -381,26 +405,6 @@ sub full_setup {
     );
 }
 
-sub writeMakefile {
-    die <<END;
-
-The extension you are trying to build apparently is rather old and
-most probably outdated. We detect that from the fact, that a
-subroutine "writeMakefile" is called, and this subroutine is not
-supported anymore since about October 1994.
-
-Please contact the author or look into CPAN (details about CPAN can be
-found in the FAQ and at http:/www.perl.com) for a more recent version
-of the extension. If you're really desperate, you can try to change
-the subroutine name from writeMakefile to WriteMakefile and rerun
-'perl Makefile.PL', but you're most probably left alone, when you do
-so.
-
-The MakeMaker team
-
-END
-}
-
 sub new {
     my($class,$self) = @_;
     my($key);
@@ -449,7 +453,7 @@ sub new {
             # simulate "use warnings FATAL => 'all'" for vintage perls
             die @_;
         };
-        version->parse( $self->{MIN_PERL_VERSION} )
+        version->new( $self->{MIN_PERL_VERSION} )
       };
       $self->{MIN_PERL_VERSION} = $normal if defined $normal && !$@;
     }
@@ -502,7 +506,7 @@ END
           if ( defined $required_version && $required_version =~ /^v?[\d_\.]+$/
                || $required_version !~ /^v?[\d_\.]+$/ ) {
             require version;
-            my $normal = eval { version->parse( $required_version ) };
+            my $normal = eval { version->new( $required_version ) };
             $required_version = $normal if defined $normal;
           }
           $installed_file = $prereq;
@@ -585,10 +589,7 @@ END
 
             $self->{$key} = $self->{PARENT}{$key};
 
-            unless ($Is_VMS && $key =~ /PERL$/) {
-                $self->{$key} = $self->catdir("..",$self->{$key})
-                  unless $self->file_name_is_absolute($self->{$key});
-            } else {
+            if ($Is_VMS && $key =~ /PERL$/) {
                 # PERL or FULLPERL will be a command verb or even a
                 # command with an argument instead of a full file
                 # specification under VMS.  So, don't turn the command
@@ -598,6 +599,14 @@ END
                 $cmd[1] = $self->catfile('[-]',$cmd[1])
                   unless (@cmd < 2) || $self->file_name_is_absolute($cmd[1]);
                 $self->{$key} = join(' ', @cmd);
+            } else {
+                my $value = $self->{$key};
+                # not going to test in FS so only stripping start
+                $value =~ s/^"// if $key =~ /PERL$/;
+                $value = $self->catdir("..", $value)
+                  unless $self->file_name_is_absolute($value);
+                $value = qq{"$value} if $key =~ /PERL$/;
+                $self->{$key} = $value;
             }
         }
         if ($self->{PARENT}) {
@@ -821,7 +830,7 @@ END
 
     foreach my $key (sort keys %$att){
         next if $key eq 'ARGS';
-        my ($v) = neatvalue($att->{$key});
+        my $v;
         if ($key eq 'PREREQ_PM') {
             # CPAN.pm takes prereqs from this field in 'Makefile'
             # and does not know about BUILD_REQUIRES
@@ -938,6 +947,7 @@ sub check_manifest {
 
 sub parse_args{
     my($self, @args) = @_;
+    @args = map { Encode::decode(locale => $_) } @args if $CAN_DECODE;
     foreach (@args) {
         unless (m/(.*?)=(.*)/) {
             ++$Verbose if m/^verb/;
@@ -1162,8 +1172,13 @@ sub flush {
     unlink($finalname, "MakeMaker.tmp", $Is_VMS ? 'Descrip.MMS' : ());
     open(my $fh,">", "MakeMaker.tmp")
         or die "Unable to open MakeMaker.tmp: $!";
+    binmode $fh, ':encoding(locale)' if $CAN_DECODE;
 
     for my $chunk (@{$self->{RESULT}}) {
+        my $to_write = "$chunk\n";
+        if (!$CAN_DECODE && $] > 5.008) {
+            utf8::encode $to_write;
+        }
         print $fh "$chunk\n"
             or die "Can't write to MakeMaker.tmp: $!";
     }
@@ -1242,28 +1257,62 @@ sub neatvalue {
         push @m, "]";
         return join "", @m;
     }
-    return "$v" unless $t eq 'HASH';
+    return $v unless $t eq 'HASH';
     my(@m, $key, $val);
-    while (($key,$val) = each %$v){
+    for my $key (sort keys %$v) {
         last unless defined $key; # cautious programming in case (undef,undef) is true
-        push(@m,"$key=>".neatvalue($val)) ;
+        push @m,"$key=>".neatvalue($v->{$key});
     }
     return "{ ".join(', ',@m)." }";
 }
 
+sub _find_magic_vstring {
+    my $value = shift;
+    return $value if $UNDER_CORE;
+    my $tvalue = '';
+    require B;
+    my $sv = B::svref_2object(\$value);
+    my $magic = ref($sv) eq 'B::PVMG' ? $sv->MAGIC : undef;
+    while ( $magic ) {
+        if ( $magic->TYPE eq 'V' ) {
+            $tvalue = $magic->PTR;
+            $tvalue =~ s/^v?(.+)$/v$1/;
+            last;
+        }
+        else {
+            $magic = $magic->MOREMAGIC;
+        }
+    }
+    return $tvalue;
+}
+
+
 # Look for weird version numbers, warn about them and set them to 0
 # before CPAN::Meta chokes.
 sub clean_versions {
     my($self, $key) = @_;
-
     my $reqs = $self->{$key};
     for my $module (keys %$reqs) {
-        my $version = $reqs->{$module};
-
-        if( !defined $version or $version !~ /^v?[\d_\.]+$/ ) {
-            carp "Unparsable version '$version' for prerequisite $module";
+        my $v = $reqs->{$module};
+        my $printable = _find_magic_vstring($v);
+        $v = $printable if length $printable;
+        my $version = eval {
+            local $SIG{__WARN__} = sub {
+              # simulate "use warnings FATAL => 'all'" for vintage perls
+              die @_;
+            };
+            version->new($v)->stringify;
+        };
+        if( $@ || $reqs->{$module} eq '' ) {
+            if ( $] < 5.008 && $v !~ /^v?[\d_\.]+$/ ) {
+               $v = sprintf "v%vd", $v unless $v eq '';
+            }
+            carp "Unparsable version '$v' for prerequisite $module";
             $reqs->{$module} = 0;
         }
+        else {
+            $reqs->{$module} = $version;
+        }
     }
 }
 
@@ -1318,15 +1367,19 @@ won't have to face the possibly bewildering errors resulting from
 using the wrong one.
 
 On POSIX systems, that program will likely be GNU Make; on Microsoft
-Windows, it will be either Microsoft NMake or DMake. Note that this
-module does not support generating Makefiles for GNU Make on Windows.
+Windows, it will be either Microsoft NMake, DMake or GNU Make.
 See the section on the L</"MAKE"> parameter for details.
 
-MakeMaker is object oriented. Each directory below the current
+ExtUtils::MakeMaker (EUMM) 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().
 
+All inputs to WriteMakefile are Unicode characters, not just octets. EUMM
+seeks to handle all of these correctly. It is currently still not possible
+to portably use Unicode characters in module names, because this requires
+Perl to handle Unicode filenames, which is not yet the case on Windows.
+
 =head2 How To Write A Makefile.PL
 
 See L<ExtUtils::MakeMaker::Tutorial>.
@@ -1375,6 +1428,11 @@ It is possible to use globbing with this mechanism.
 
   make test TEST_FILES='t/foobar.t t/dagobah*.t'
 
+Windows users who are using C<nmake> should note that due to a bug in C<nmake>,
+when specifying C<TEST_FILES> you must use back-slashes instead of forward-slashes.
+
+  nmake test TEST_FILES='t\foobar.t t\dagobah*.t'
+
 =head2 make testdb
 
 A useful variation of the above is the target C<testdb>. It runs the
@@ -2195,6 +2253,20 @@ own.  META_MERGE will merge its value with the default.
 Unless you want to override the defaults, prefer META_MERGE so as to
 get the advantage of any future defaults.
 
+Where prereqs are concerned, if META_MERGE is used, prerequisites are merged
+with their counterpart C<WriteMakefile()> argument
+(PREREQ_PM is merged into {prereqs}{runtime}{requires},
+BUILD_REQUIRES into C<{prereqs}{build}{requires}>,
+CONFIGURE_REQUIRES into C<{prereqs}{configure}{requires}>,
+and TEST_REQUIRES into C<{prereqs}{test}{requires})>.
+When prereqs are specified with META_ADD, the only prerequisites added to the
+file come from the metadata, not C<WriteMakefile()> arguments.
+
+Note that these configuration options are only used for generating F<META.yml>
+and F<META.json> -- they are NOT used for F<MYMETA.yml> and F<MYMETA.json>.
+Therefore data in these fields should NOT be used for dynamic (user-side)
+configuration.
+
 By default CPAN Meta specification C<1.4> is used. In order to use
 CPAN Meta specification C<2.0>, indicate with C<meta-spec> the version
 you want to use.
@@ -2232,9 +2304,9 @@ name of the library (see SDBM_File)
 
 The package representing the distribution. For example, C<Test::More>
 or C<ExtUtils::MakeMaker>. It will be used to derive information about
-the distribution such as the L<DISTNAME>, installation locations
+the distribution such as the L</DISTNAME>, installation locations
 within the Perl library and where XS files will be looked for by
-default (see L<XS>).
+default (see L</XS>).
 
 C<NAME> I<must> be a valid Perl package name and it I<must> have an
 associated C<.pm> file. For example, C<Foo::Bar> is a valid C<NAME>
@@ -3092,6 +3164,12 @@ If no $default is provided an empty string will be used instead.
 
 =back
 
+=head2 Supported versions of Perl
+
+Please note that while this module works on Perl 5.6, it is no longer
+being routinely tested on 5.6 - the earliest Perl version being routinely
+tested, and expressly supported, is 5.8.1. However, patches to repair
+any breakage on 5.6 are still being accepted.
 
 =head1 ENVIRONMENT
 
@@ -3130,6 +3208,13 @@ help you setup your distribution.
 
 L<CPAN::Meta> and L<CPAN::Meta::Spec> explain CPAN Meta files in detail.
 
+L<File::ShareDir::Install> makes it easy to install static, sometimes
+also referred to as 'shared' files. L<File::ShareDir> helps accessing
+the shared files after installation.
+
+L<Dist::Zilla> makes it easy for the module author to create MakeMaker-based
+distributions with lots of bells and whistles.
+
 =head1 AUTHORS
 
 Andy Dougherty C<doughera@lafayette.edu>, Andreas KE<ouml>nig
index 5c703f0..35179c4 100644 (file)
@@ -2,7 +2,7 @@ package ExtUtils::MakeMaker::Config;
 
 use strict;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 use Config ();
 
index e5acb6a..a758a63 100644 (file)
@@ -1,6 +1,6 @@
 package ExtUtils::MakeMaker::FAQ;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 1;
 __END__
diff --git a/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Locale.pm b/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/Locale.pm
new file mode 100644 (file)
index 0000000..9e79a7e
--- /dev/null
@@ -0,0 +1,348 @@
+package ExtUtils::MakeMaker::Locale;
+
+use strict;
+our $VERSION = "7.02";
+
+use base 'Exporter';
+our @EXPORT_OK = qw(
+    decode_argv env
+    $ENCODING_LOCALE $ENCODING_LOCALE_FS
+    $ENCODING_CONSOLE_IN $ENCODING_CONSOLE_OUT
+);
+
+use Encode ();
+use Encode::Alias ();
+
+our $ENCODING_LOCALE;
+our $ENCODING_LOCALE_FS;
+our $ENCODING_CONSOLE_IN;
+our $ENCODING_CONSOLE_OUT;
+
+sub DEBUG () { 0 }
+
+sub _init {
+    if ($^O eq "MSWin32") {
+       unless ($ENCODING_LOCALE) {
+           # Try to obtain what the Windows ANSI code page is
+           eval {
+               unless (defined &GetACP) {
+                   require Win32::API;
+                   Win32::API->Import('kernel32', 'int GetACP()');
+               };
+               if (defined &GetACP) {
+                   my $cp = GetACP();
+                   $ENCODING_LOCALE = "cp$cp" if $cp;
+               }
+           };
+       }
+
+       unless ($ENCODING_CONSOLE_IN) {
+           # If we have the Win32::Console module installed we can ask
+           # it for the code set to use
+           eval {
+               require Win32::Console;
+               my $cp = Win32::Console::InputCP();
+               $ENCODING_CONSOLE_IN = "cp$cp" if $cp;
+               $cp = Win32::Console::OutputCP();
+               $ENCODING_CONSOLE_OUT = "cp$cp" if $cp;
+           };
+           # Invoking the 'chcp' program might also work
+           if (!$ENCODING_CONSOLE_IN && (qx(chcp) || '') =~ /^Active code page: (\d+)/) {
+               $ENCODING_CONSOLE_IN = "cp$1";
+           }
+       }
+    }
+
+    unless ($ENCODING_LOCALE) {
+       eval {
+           require I18N::Langinfo;
+           $ENCODING_LOCALE = I18N::Langinfo::langinfo(I18N::Langinfo::CODESET());
+
+           # Workaround of Encode < v2.25.  The "646" encoding  alias was
+           # introduced in Encode-2.25, but we don't want to require that version
+           # quite yet.  Should avoid the CPAN testers failure reported from
+           # openbsd-4.7/perl-5.10.0 combo.
+           $ENCODING_LOCALE = "ascii" if $ENCODING_LOCALE eq "646";
+
+           # https://rt.cpan.org/Ticket/Display.html?id=66373
+           $ENCODING_LOCALE = "hp-roman8" if $^O eq "hpux" && $ENCODING_LOCALE eq "roman8";
+       };
+       $ENCODING_LOCALE ||= $ENCODING_CONSOLE_IN;
+    }
+
+    if ($^O eq "darwin") {
+       $ENCODING_LOCALE_FS ||= "UTF-8";
+    }
+
+    # final fallback
+    $ENCODING_LOCALE ||= $^O eq "MSWin32" ? "cp1252" : "UTF-8";
+    $ENCODING_LOCALE_FS ||= $ENCODING_LOCALE;
+    $ENCODING_CONSOLE_IN ||= $ENCODING_LOCALE;
+    $ENCODING_CONSOLE_OUT ||= $ENCODING_CONSOLE_IN;
+
+    unless (Encode::find_encoding($ENCODING_LOCALE)) {
+       my $foundit;
+       if (lc($ENCODING_LOCALE) eq "gb18030") {
+           eval {
+               require Encode::HanExtra;
+           };
+           if ($@) {
+               die "Need Encode::HanExtra to be installed to support locale codeset ($ENCODING_LOCALE), stopped";
+           }
+           $foundit++ if Encode::find_encoding($ENCODING_LOCALE);
+       }
+       die "The locale codeset ($ENCODING_LOCALE) isn't one that perl can decode, stopped"
+           unless $foundit;
+
+    }
+
+    # use Data::Dump; ddx $ENCODING_LOCALE, $ENCODING_LOCALE_FS, $ENCODING_CONSOLE_IN, $ENCODING_CONSOLE_OUT;
+}
+
+_init();
+Encode::Alias::define_alias(sub {
+    no strict 'refs';
+    no warnings 'once';
+    return ${"ENCODING_" . uc(shift)};
+}, "locale");
+
+sub _flush_aliases {
+    no strict 'refs';
+    for my $a (keys %Encode::Alias::Alias) {
+       if (defined ${"ENCODING_" . uc($a)}) {
+           delete $Encode::Alias::Alias{$a};
+           warn "Flushed alias cache for $a" if DEBUG;
+       }
+    }
+}
+
+sub reinit {
+    $ENCODING_LOCALE = shift;
+    $ENCODING_LOCALE_FS = shift;
+    $ENCODING_CONSOLE_IN = $ENCODING_LOCALE;
+    $ENCODING_CONSOLE_OUT = $ENCODING_LOCALE;
+    _init();
+    _flush_aliases();
+}
+
+sub decode_argv {
+    die if defined wantarray;
+    for (@ARGV) {
+       $_ = Encode::decode(locale => $_, @_);
+    }
+}
+
+sub env {
+    my $k = Encode::encode(locale => shift);
+    my $old = $ENV{$k};
+    if (@_) {
+       my $v = shift;
+       if (defined $v) {
+           $ENV{$k} = Encode::encode(locale => $v);
+       }
+       else {
+           delete $ENV{$k};
+       }
+    }
+    return Encode::decode(locale => $old) if defined wantarray;
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+ExtUtils::MakeMaker::Locale - bundled Encode::Locale
+
+=head1 SYNOPSIS
+
+  use Encode::Locale;
+  use Encode;
+
+  $string = decode(locale => $bytes);
+  $bytes = encode(locale => $string);
+
+  if (-t) {
+      binmode(STDIN, ":encoding(console_in)");
+      binmode(STDOUT, ":encoding(console_out)");
+      binmode(STDERR, ":encoding(console_out)");
+  }
+
+  # Processing file names passed in as arguments
+  my $uni_filename = decode(locale => $ARGV[0]);
+  open(my $fh, "<", encode(locale_fs => $uni_filename))
+     || die "Can't open '$uni_filename': $!";
+  binmode($fh, ":encoding(locale)");
+  ...
+
+=head1 DESCRIPTION
+
+In many applications it's wise to let Perl use Unicode for the strings it
+processes.  Most of the interfaces Perl has to the outside world are still byte
+based.  Programs therefore need to decode byte strings that enter the program
+from the outside and encode them again on the way out.
+
+The POSIX locale system is used to specify both the language conventions
+requested by the user and the preferred character set to consume and
+output.  The C<Encode::Locale> module looks up the charset and encoding (called
+a CODESET in the locale jargon) and arranges for the L<Encode> module to know
+this encoding under the name "locale".  It means bytes obtained from the
+environment can be converted to Unicode strings by calling C<<
+Encode::encode(locale => $bytes) >> and converted back again with C<<
+Encode::decode(locale => $string) >>.
+
+Where file systems interfaces pass file names in and out of the program we also
+need care.  The trend is for operating systems to use a fixed file encoding
+that don't actually depend on the locale; and this module determines the most
+appropriate encoding for file names. The L<Encode> module will know this
+encoding under the name "locale_fs".  For traditional Unix systems this will
+be an alias to the same encoding as "locale".
+
+For programs running in a terminal window (called a "Console" on some systems)
+the "locale" encoding is usually a good choice for what to expect as input and
+output.  Some systems allows us to query the encoding set for the terminal and
+C<Encode::Locale> will do that if available and make these encodings known
+under the C<Encode> aliases "console_in" and "console_out".  For systems where
+we can't determine the terminal encoding these will be aliased as the same
+encoding as "locale".  The advice is to use "console_in" for input known to
+come from the terminal and "console_out" for output known to go from the
+terminal.
+
+In addition to arranging for various Encode aliases the following functions and
+variables are provided:
+
+=over
+
+=item decode_argv( )
+
+=item decode_argv( Encode::FB_CROAK )
+
+This will decode the command line arguments to perl (the C<@ARGV> array) in-place.
+
+The function will by default replace characters that can't be decoded by
+"\x{FFFD}", the Unicode replacement character.
+
+Any argument provided is passed as CHECK to underlying Encode::decode() call.
+Pass the value C<Encode::FB_CROAK> to have the decoding croak if not all the
+command line arguments can be decoded.  See L<Encode/"Handling Malformed Data">
+for details on other options for CHECK.
+
+=item env( $uni_key )
+
+=item env( $uni_key => $uni_value )
+
+Interface to get/set environment variables.  Returns the current value as a
+Unicode string. The $uni_key and $uni_value arguments are expected to be
+Unicode strings as well.  Passing C<undef> as $uni_value deletes the
+environment variable named $uni_key.
+
+The returned value will have the characters that can't be decoded replaced by
+"\x{FFFD}", the Unicode replacement character.
+
+There is no interface to request alternative CHECK behavior as for
+decode_argv().  If you need that you need to call encode/decode yourself.
+For example:
+
+    my $key = Encode::encode(locale => $uni_key, Encode::FB_CROAK);
+    my $uni_value = Encode::decode(locale => $ENV{$key}, Encode::FB_CROAK);
+
+=item reinit( )
+
+=item reinit( $encoding )
+
+Reinitialize the encodings from the locale.  You want to call this function if
+you changed anything in the environment that might influence the locale.
+
+This function will croak if the determined encoding isn't recognized by
+the Encode module.
+
+With argument force $ENCODING_... variables to set to the given value.
+
+=item $ENCODING_LOCALE
+
+The encoding name determined to be suitable for the current locale.
+L<Encode> know this encoding as "locale".
+
+=item $ENCODING_LOCALE_FS
+
+The encoding name determined to be suiteable for file system interfaces
+involving file names.
+L<Encode> know this encoding as "locale_fs".
+
+=item $ENCODING_CONSOLE_IN
+
+=item $ENCODING_CONSOLE_OUT
+
+The encodings to be used for reading and writing output to the a console.
+L<Encode> know these encodings as "console_in" and "console_out".
+
+=back
+
+=head1 NOTES
+
+This table summarizes the mapping of the encodings set up
+by the C<Encode::Locale> module:
+
+  Encode      |         |              |
+  Alias       | Windows | Mac OS X     | POSIX
+  ------------+---------+--------------+------------
+  locale      | ANSI    | nl_langinfo  | nl_langinfo
+  locale_fs   | ANSI    | UTF-8        | nl_langinfo
+  console_in  | OEM     | nl_langinfo  | nl_langinfo
+  console_out | OEM     | nl_langinfo  | nl_langinfo
+
+=head2 Windows
+
+Windows has basically 2 sets of APIs.  A wide API (based on passing UTF-16
+strings) and a byte based API based a character set called ANSI.  The
+regular Perl interfaces to the OS currently only uses the ANSI APIs.
+Unfortunately ANSI is not a single character set.
+
+The encoding that corresponds to ANSI varies between different editions of
+Windows.  For many western editions of Windows ANSI corresponds to CP-1252
+which is a character set similar to ISO-8859-1.  Conceptually the ANSI
+character set is a similar concept to the POSIX locale CODESET so this module
+figures out what the ANSI code page is and make this available as
+$ENCODING_LOCALE and the "locale" Encoding alias.
+
+Windows systems also operate with another byte based character set.
+It's called the OEM code page.  This is the encoding that the Console
+takes as input and output.  It's common for the OEM code page to
+differ from the ANSI code page.
+
+=head2 Mac OS X
+
+On Mac OS X the file system encoding is always UTF-8 while the locale
+can otherwise be set up as normal for POSIX systems.
+
+File names on Mac OS X will at the OS-level be converted to
+NFD-form.  A file created by passing a NFC-filename will come
+in NFD-form from readdir().  See L<Unicode::Normalize> for details
+of NFD/NFC.
+
+Actually, Apple does not follow the Unicode NFD standard since not all
+character ranges are decomposed.  The claim is that this avoids problems with
+round trip conversions from old Mac text encodings.  See L<Encode::UTF8Mac> for
+details.
+
+=head2 POSIX (Linux and other Unixes)
+
+File systems might vary in what encoding is to be used for
+filenames.  Since this module has no way to actually figure out
+what the is correct it goes with the best guess which is to
+assume filenames are encoding according to the current locale.
+Users are advised to always specify UTF-8 as the locale charset.
+
+=head1 SEE ALSO
+
+L<I18N::Langinfo>, L<Encode>
+
+=head1 AUTHOR
+
+Copyright 2010 Gisle Aas <gisle@aas.no>.
+
+This library is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=cut
index 5d43d40..84e1b2f 100644 (file)
@@ -1,6 +1,6 @@
 package ExtUtils::MakeMaker::Tutorial;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 
 =head1 NAME
diff --git a/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version.pm b/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version.pm
new file mode 100644 (file)
index 0000000..7857095
--- /dev/null
@@ -0,0 +1,55 @@
+#--------------------------------------------------------------------------#
+# This is a modified copy of version.pm 0.9909, bundled exclusively for
+# use by ExtUtils::Makemaker and its dependencies to bootstrap when
+# version.pm is not available.  It should not be used by ordinary modules.
+#
+# When loaded, it will try to load version.pm.  If that fails, it will load
+# ExtUtils::MakeMaker::version::vpp and alias various *version functions
+# to functions in that module.  It will also override UNIVERSAL::VERSION.
+#--------------------------------------------------------------------------#
+
+package ExtUtils::MakeMaker::version;
+
+use 5.006002;
+use strict;
+
+use vars qw(@ISA $VERSION $CLASS $STRICT $LAX *declare *qv);
+
+$VERSION = '7.02';
+$CLASS = 'version';
+
+{
+    local $SIG{'__DIE__'};
+    eval "use version";
+    if ( $@ ) { # don't have any version.pm installed
+        eval "use ExtUtils::MakeMaker::version::vpp";
+        die "$@" if ( $@ );
+        local $^W;
+        delete $INC{'version.pm'};
+        $INC{'version.pm'} = $INC{'ExtUtils/MakeMaker/version.pm'};
+        push @version::ISA, "ExtUtils::MakeMaker::version::vpp";
+        $version::VERSION = $VERSION;
+        *version::qv = \&ExtUtils::MakeMaker::version::vpp::qv;
+        *version::declare = \&ExtUtils::MakeMaker::version::vpp::declare;
+        *version::_VERSION = \&ExtUtils::MakeMaker::version::vpp::_VERSION;
+        *version::vcmp = \&ExtUtils::MakeMaker::version::vpp::vcmp;
+        *version::new = \&ExtUtils::MakeMaker::version::vpp::new;
+        if ($] >= 5.009000) {
+            no strict 'refs';
+            *version::stringify = \&ExtUtils::MakeMaker::version::vpp::stringify;
+            *{'version::(""'} = \&ExtUtils::MakeMaker::version::vpp::stringify;
+            *{'version::(<=>'} = \&ExtUtils::MakeMaker::version::vpp::vcmp;
+            *version::parse = \&ExtUtils::MakeMaker::version::vpp::parse;
+        }
+        require ExtUtils::MakeMaker::version::regex;
+        *version::is_lax = \&ExtUtils::MakeMaker::version::regex::is_lax;
+        *version::is_strict = \&ExtUtils::MakeMaker::version::regex::is_strict;
+        *LAX = \$ExtUtils::MakeMaker::version::regex::LAX;
+        *STRICT = \$ExtUtils::MakeMaker::version::regex::STRICT;
+    }
+    elsif ( ! version->can('is_qv') ) {
+        *version::is_qv = sub { exists $_[0]->{qv} };
+    }
+}
+
+1;
diff --git a/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/regex.pm b/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/regex.pm
new file mode 100644 (file)
index 0000000..6756894
--- /dev/null
@@ -0,0 +1,123 @@
+#--------------------------------------------------------------------------#
+# This is a modified copy of version.pm 0.9909, bundled exclusively for
+# use by ExtUtils::Makemaker and its dependencies to bootstrap when
+# version.pm is not available.  It should not be used by ordinary modules.
+#--------------------------------------------------------------------------#
+
+package ExtUtils::MakeMaker::version::regex;
+
+use strict;
+
+use vars qw($VERSION $CLASS $STRICT $LAX);
+
+$VERSION = '7.02';
+
+#--------------------------------------------------------------------------#
+# Version regexp components
+#--------------------------------------------------------------------------#
+
+# Fraction part of a decimal version number.  This is a common part of
+# both strict and lax decimal versions
+
+my $FRACTION_PART = qr/\.[0-9]+/;
+
+# First part of either decimal or dotted-decimal strict version number.
+# Unsigned integer with no leading zeroes (except for zero itself) to
+# avoid confusion with octal.
+
+my $STRICT_INTEGER_PART = qr/0|[1-9][0-9]*/;
+
+# First part of either decimal or dotted-decimal lax version number.
+# Unsigned integer, but allowing leading zeros.  Always interpreted
+# as decimal.  However, some forms of the resulting syntax give odd
+# results if used as ordinary Perl expressions, due to how perl treats
+# octals.  E.g.
+#   version->new("010" ) == 10
+#   version->new( 010  ) == 8
+#   version->new( 010.2) == 82  # "8" . "2"
+
+my $LAX_INTEGER_PART = qr/[0-9]+/;
+
+# Second and subsequent part of a strict dotted-decimal version number.
+# Leading zeroes are permitted, and the number is always decimal.
+# Limited to three digits to avoid overflow when converting to decimal
+# form and also avoid problematic style with excessive leading zeroes.
+
+my $STRICT_DOTTED_DECIMAL_PART = qr/\.[0-9]{1,3}/;
+
+# Second and subsequent part of a lax dotted-decimal version number.
+# Leading zeroes are permitted, and the number is always decimal.  No
+# limit on the numerical value or number of digits, so there is the
+# possibility of overflow when converting to decimal form.
+
+my $LAX_DOTTED_DECIMAL_PART = qr/\.[0-9]+/;
+
+# Alpha suffix part of lax version number syntax.  Acts like a
+# dotted-decimal part.
+
+my $LAX_ALPHA_PART = qr/_[0-9]+/;
+
+#--------------------------------------------------------------------------#
+# Strict version regexp definitions
+#--------------------------------------------------------------------------#
+
+# Strict decimal version number.
+
+my $STRICT_DECIMAL_VERSION =
+    qr/ $STRICT_INTEGER_PART $FRACTION_PART? /x;
+
+# Strict dotted-decimal version number.  Must have both leading "v" and
+# at least three parts, to avoid confusion with decimal syntax.
+
+my $STRICT_DOTTED_DECIMAL_VERSION =
+    qr/ v $STRICT_INTEGER_PART $STRICT_DOTTED_DECIMAL_PART{2,} /x;
+
+# Complete strict version number syntax -- should generally be used
+# anchored: qr/ \A $STRICT \z /x
+
+$STRICT =
+    qr/ $STRICT_DECIMAL_VERSION | $STRICT_DOTTED_DECIMAL_VERSION /x;
+
+#--------------------------------------------------------------------------#
+# Lax version regexp definitions
+#--------------------------------------------------------------------------#
+
+# Lax decimal version number.  Just like the strict one except for
+# allowing an alpha suffix or allowing a leading or trailing
+# decimal-point
+
+my $LAX_DECIMAL_VERSION =
+    qr/ $LAX_INTEGER_PART (?: \. | $FRACTION_PART $LAX_ALPHA_PART? )?
+       |
+       $FRACTION_PART $LAX_ALPHA_PART?
+    /x;
+
+# Lax dotted-decimal version number.  Distinguished by having either
+# leading "v" or at least three non-alpha parts.  Alpha part is only
+# permitted if there are at least two non-alpha parts. Strangely
+# enough, without the leading "v", Perl takes .1.2 to mean v0.1.2,
+# so when there is no "v", the leading part is optional
+
+my $LAX_DOTTED_DECIMAL_VERSION =
+    qr/
+       v $LAX_INTEGER_PART (?: $LAX_DOTTED_DECIMAL_PART+ $LAX_ALPHA_PART? )?
+       |
+       $LAX_INTEGER_PART? $LAX_DOTTED_DECIMAL_PART{2,} $LAX_ALPHA_PART?
+    /x;
+
+# Complete lax version number syntax -- should generally be used
+# anchored: qr/ \A $LAX \z /x
+#
+# The string 'undef' is a special case to make for easier handling
+# of return values from ExtUtils::MM->parse_version
+
+$LAX =
+    qr/ undef | $LAX_DECIMAL_VERSION | $LAX_DOTTED_DECIMAL_VERSION /x;
+
+#--------------------------------------------------------------------------#
+
+# Preloaded methods go here.
+sub is_strict  { defined $_[0] && $_[0] =~ qr/ \A $STRICT \z /x }
+sub is_lax     { defined $_[0] && $_[0] =~ qr/ \A $LAX \z /x }
+
+1;
diff --git a/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/vpp.pm b/cpan/ExtUtils-MakeMaker/lib/ExtUtils/MakeMaker/version/vpp.pm
new file mode 100644 (file)
index 0000000..8c3c8d3
--- /dev/null
@@ -0,0 +1,1028 @@
+#--------------------------------------------------------------------------#
+# This is a modified copy of version.pm 0.9909, bundled exclusively for
+# use by ExtUtils::Makemaker and its dependencies to bootstrap when
+# version.pm is not available.  It should not be used by ordinary modules.
+#--------------------------------------------------------------------------#
+
+package ExtUtils::MakeMaker::charstar;
+# a little helper class to emulate C char* semantics in Perl
+# so that prescan_version can use the same code as in C
+
+use overload (
+    '""'       => \&thischar,
+    '0+'       => \&thischar,
+    '++'       => \&increment,
+    '--'       => \&decrement,
+    '+'                => \&plus,
+    '-'                => \&minus,
+    '*'                => \&multiply,
+    'cmp'      => \&cmp,
+    '<=>'      => \&spaceship,
+    'bool'     => \&thischar,
+    '='                => \&clone,
+);
+
+sub new {
+    my ($self, $string) = @_;
+    my $class = ref($self) || $self;
+
+    my $obj = {
+       string  => [split(//,$string)],
+       current => 0,
+    };
+    return bless $obj, $class;
+}
+
+sub thischar {
+    my ($self) = @_;
+    my $last = $#{$self->{string}};
+    my $curr = $self->{current};
+    if ($curr >= 0 && $curr <= $last) {
+       return $self->{string}->[$curr];
+    }
+    else {
+       return '';
+    }
+}
+
+sub increment {
+    my ($self) = @_;
+    $self->{current}++;
+}
+
+sub decrement {
+    my ($self) = @_;
+    $self->{current}--;
+}
+
+sub plus {
+    my ($self, $offset) = @_;
+    my $rself = $self->clone;
+    $rself->{current} += $offset;
+    return $rself;
+}
+
+sub minus {
+    my ($self, $offset) = @_;
+    my $rself = $self->clone;
+    $rself->{current} -= $offset;
+    return $rself;
+}
+
+sub multiply {
+    my ($left, $right, $swapped) = @_;
+    my $char = $left->thischar();
+    return $char * $right;
+}
+
+sub spaceship {
+    my ($left, $right, $swapped) = @_;
+    unless (ref($right)) { # not an object already
+       $right = $left->new($right);
+    }
+    return $left->{current} <=> $right->{current};
+}
+
+sub cmp {
+    my ($left, $right, $swapped) = @_;
+    unless (ref($right)) { # not an object already
+       if (length($right) == 1) { # comparing single character only
+           return $left->thischar cmp $right;
+       }
+       $right = $left->new($right);
+    }
+    return $left->currstr cmp $right->currstr;
+}
+
+sub bool {
+    my ($self) = @_;
+    my $char = $self->thischar;
+    return ($char ne '');
+}
+
+sub clone {
+    my ($left, $right, $swapped) = @_;
+    $right = {
+       string  => [@{$left->{string}}],
+       current => $left->{current},
+    };
+    return bless $right, ref($left);
+}
+
+sub currstr {
+    my ($self, $s) = @_;
+    my $curr = $self->{current};
+    my $last = $#{$self->{string}};
+    if (defined($s) && $s->{current} < $last) {
+       $last = $s->{current};
+    }
+
+    my $string = join('', @{$self->{string}}[$curr..$last]);
+    return $string;
+}
+
+package ExtUtils::MakeMaker::version::vpp;
+
+use 5.006002;
+use strict;
+
+use Config;
+use vars qw($VERSION $CLASS @ISA $LAX $STRICT);
+$VERSION = '7.02';
+$CLASS = 'ExtUtils::MakeMaker::version::vpp';
+
+require ExtUtils::MakeMaker::version::regex;
+*ExtUtils::MakeMaker::version::vpp::is_strict = \&ExtUtils::MakeMaker::version::regex::is_strict;
+*ExtUtils::MakeMaker::version::vpp::is_lax = \&ExtUtils::MakeMaker::version::regex::is_lax;
+*LAX = \$ExtUtils::MakeMaker::version::regex::LAX;
+*STRICT = \$ExtUtils::MakeMaker::version::regex::STRICT;
+
+use overload (
+    '""'       => \&stringify,
+    '0+'       => \&numify,
+    'cmp'      => \&vcmp,
+    '<=>'      => \&vcmp,
+    'bool'     => \&vbool,
+    '+'        => \&vnoop,
+    '-'        => \&vnoop,
+    '*'        => \&vnoop,
+    '/'        => \&vnoop,
+    '+='        => \&vnoop,
+    '-='        => \&vnoop,
+    '*='        => \&vnoop,
+    '/='        => \&vnoop,
+    'abs'      => \&vnoop,
+);
+
+eval "use warnings";
+if ($@) {
+    eval '
+       package
+       warnings;
+       sub enabled {return $^W;}
+       1;
+    ';
+}
+
+sub import {
+    no strict 'refs';
+    my ($class) = shift;
+
+    # Set up any derived class
+    unless ($class eq $CLASS) {
+       local $^W;
+       *{$class.'::declare'} =  \&{$CLASS.'::declare'};
+       *{$class.'::qv'} = \&{$CLASS.'::qv'};
+    }
+
+    my %args;
+    if (@_) { # any remaining terms are arguments
+       map { $args{$_} = 1 } @_
+    }
+    else { # no parameters at all on use line
+       %args =
+       (
+           qv => 1,
+           'UNIVERSAL::VERSION' => 1,
+       );
+    }
+
+    my $callpkg = caller();
+
+    if (exists($args{declare})) {
+       *{$callpkg.'::declare'} =
+           sub {return $class->declare(shift) }
+         unless defined(&{$callpkg.'::declare'});
+    }
+
+    if (exists($args{qv})) {
+       *{$callpkg.'::qv'} =
+           sub {return $class->qv(shift) }
+         unless defined(&{$callpkg.'::qv'});
+    }
+
+    if (exists($args{'UNIVERSAL::VERSION'})) {
+       local $^W;
+       *UNIVERSAL::VERSION
+               = \&{$CLASS.'::_VERSION'};
+    }
+
+    if (exists($args{'VERSION'})) {
+       *{$callpkg.'::VERSION'} = \&{$CLASS.'::_VERSION'};
+    }
+
+    if (exists($args{'is_strict'})) {
+       *{$callpkg.'::is_strict'} = \&{$CLASS.'::is_strict'}
+         unless defined(&{$callpkg.'::is_strict'});
+    }
+
+    if (exists($args{'is_lax'})) {
+       *{$callpkg.'::is_lax'} = \&{$CLASS.'::is_lax'}
+         unless defined(&{$callpkg.'::is_lax'});
+    }
+}
+
+my $VERSION_MAX = 0x7FFFFFFF;
+
+# implement prescan_version as closely to the C version as possible
+use constant TRUE  => 1;
+use constant FALSE => 0;
+
+sub isDIGIT {
+    my ($char) = shift->thischar();
+    return ($char =~ /\d/);
+}
+
+sub isALPHA {
+    my ($char) = shift->thischar();
+    return ($char =~ /[a-zA-Z]/);
+}
+
+sub isSPACE {
+    my ($char) = shift->thischar();
+    return ($char =~ /\s/);
+}
+
+sub BADVERSION {
+    my ($s, $errstr, $error) = @_;
+    if ($errstr) {
+       $$errstr = $error;
+    }
+    return $s;
+}
+
+sub prescan_version {
+    my ($s, $strict, $errstr, $sqv, $ssaw_decimal, $swidth, $salpha) = @_;
+    my $qv          = defined $sqv          ? $$sqv          : FALSE;
+    my $saw_decimal = defined $ssaw_decimal ? $$ssaw_decimal : 0;
+    my $width       = defined $swidth       ? $$swidth       : 3;
+    my $alpha       = defined $salpha       ? $$salpha       : FALSE;
+
+    my $d = $s;
+
+    if ($qv && isDIGIT($d)) {
+       goto dotted_decimal_version;
+    }
+
+    if ($d eq 'v') { # explicit v-string
+       $d++;
+       if (isDIGIT($d)) {
+           $qv = TRUE;
+       }
+       else { # degenerate v-string
+           # requires v1.2.3
+           return BADVERSION($s,$errstr,"Invalid version format (dotted-decimal versions require at least three parts)");
+       }
+
+dotted_decimal_version:
+       if ($strict && $d eq '0' && isDIGIT($d+1)) {
+           # no leading zeros allowed
+           return BADVERSION($s,$errstr,"Invalid version format (no leading zeros)");
+       }
+
+       while (isDIGIT($d)) {   # integer part
+           $d++;
+       }
+
+       if ($d eq '.')
+       {
+           $saw_decimal++;
+           $d++;               # decimal point
+       }
+       else
+       {
+           if ($strict) {
+               # require v1.2.3
+               return BADVERSION($s,$errstr,"Invalid version format (dotted-decimal versions require at least three parts)");
+           }
+           else {
+               goto version_prescan_finish;
+           }
+       }
+
+       {
+           my $i = 0;
+           my $j = 0;
+           while (isDIGIT($d)) {       # just keep reading
+               $i++;
+               while (isDIGIT($d)) {
+                   $d++; $j++;
+                   # maximum 3 digits between decimal
+                   if ($strict && $j > 3) {
+                       return BADVERSION($s,$errstr,"Invalid version format (maximum 3 digits between decimals)");
+                   }
+               }
+               if ($d eq '_') {
+                   if ($strict) {
+                       return BADVERSION($s,$errstr,"Invalid version format (no underscores)");
+                   }
+                   if ( $alpha ) {
+                       return BADVERSION($s,$errstr,"Invalid version format (multiple underscores)");
+                   }
+                   $d++;
+                   $alpha = TRUE;
+               }
+               elsif ($d eq '.') {
+                   if ($alpha) {
+                       return BADVERSION($s,$errstr,"Invalid version format (underscores before decimal)");
+                   }
+                   $saw_decimal++;
+                   $d++;
+               }
+               elsif (!isDIGIT($d)) {
+                   last;
+               }
+               $j = 0;
+           }
+
+           if ($strict && $i < 2) {
+               # requires v1.2.3
+               return BADVERSION($s,$errstr,"Invalid version format (dotted-decimal versions require at least three parts)");
+           }
+       }
+    }                                  # end if dotted-decimal
+    else
+    {                                  # decimal versions
+       my $j = 0;
+       # special $strict case for leading '.' or '0'
+       if ($strict) {
+           if ($d eq '.') {
+               return BADVERSION($s,$errstr,"Invalid version format (0 before decimal required)");
+           }
+           if ($d eq '0' && isDIGIT($d+1)) {
+               return BADVERSION($s,$errstr,"Invalid version format (no leading zeros)");
+           }
+       }
+
+       # and we never support negative version numbers
+       if ($d eq '-') {
+           return BADVERSION($s,$errstr,"Invalid version format (negative version number)");
+       }
+
+       # consume all of the integer part
+       while (isDIGIT($d)) {
+           $d++;
+       }
+
+       # look for a fractional part
+       if ($d eq '.') {
+           # we found it, so consume it
+           $saw_decimal++;
+           $d++;
+       }
+       elsif (!$d || $d eq ';' || isSPACE($d) || $d eq '}') {
+           if ( $d == $s ) {
+               # found nothing
+               return BADVERSION($s,$errstr,"Invalid version format (version required)");
+           }
+           # found just an integer
+           goto version_prescan_finish;
+       }
+       elsif ( $d == $s ) {
+           # didn't find either integer or period
+           return BADVERSION($s,$errstr,"Invalid version format (non-numeric data)");
+       }
+       elsif ($d eq '_') {
+           # underscore can't come after integer part
+           if ($strict) {
+               return BADVERSION($s,$errstr,"Invalid version format (no underscores)");
+           }
+           elsif (isDIGIT($d+1)) {
+               return BADVERSION($s,$errstr,"Invalid version format (alpha without decimal)");
+           }
+           else {
+               return BADVERSION($s,$errstr,"Invalid version format (misplaced underscore)");
+           }
+       }
+       elsif ($d) {
+           # anything else after integer part is just invalid data
+           return BADVERSION($s,$errstr,"Invalid version format (non-numeric data)");
+       }
+
+       # scan the fractional part after the decimal point
+       if ($d && !isDIGIT($d) && ($strict || ! ($d eq ';' || isSPACE($d) || $d eq '}') )) {
+               # $strict or lax-but-not-the-end
+               return BADVERSION($s,$errstr,"Invalid version format (fractional part required)");
+       }
+
+       while (isDIGIT($d)) {
+           $d++; $j++;
+           if ($d eq '.' && isDIGIT($d-1)) {
+               if ($alpha) {
+                   return BADVERSION($s,$errstr,"Invalid version format (underscores before decimal)");
+               }
+               if ($strict) {
+                   return BADVERSION($s,$errstr,"Invalid version format (dotted-decimal versions must begin with 'v')");
+               }
+               $d = $s; # start all over again
+               $qv = TRUE;
+               goto dotted_decimal_version;
+           }
+           if ($d eq '_') {
+               if ($strict) {
+                   return BADVERSION($s,$errstr,"Invalid version format (no underscores)");
+               }
+               if ( $alpha ) {
+                   return BADVERSION($s,$errstr,"Invalid version format (multiple underscores)");
+               }
+               if ( ! isDIGIT($d+1) ) {
+                   return BADVERSION($s,$errstr,"Invalid version format (misplaced underscore)");
+               }
+               $width = $j;
+               $d++;
+               $alpha = TRUE;
+           }
+       }
+    }
+
+version_prescan_finish:
+    while (isSPACE($d)) {
+       $d++;
+    }
+
+    if ($d && !isDIGIT($d) && (! ($d eq ';' || $d eq '}') )) {
+       # trailing non-numeric data
+       return BADVERSION($s,$errstr,"Invalid version format (non-numeric data)");
+    }
+
+    if (defined $sqv) {
+       $$sqv = $qv;
+    }
+    if (defined $swidth) {
+       $$swidth = $width;
+    }
+    if (defined $ssaw_decimal) {
+       $$ssaw_decimal = $saw_decimal;
+    }
+    if (defined $salpha) {
+       $$salpha = $alpha;
+    }
+    return $d;
+}
+
+sub scan_version {
+    my ($s, $rv, $qv) = @_;
+    my $start;
+    my $pos;
+    my $last;
+    my $errstr;
+    my $saw_decimal = 0;
+    my $width = 3;
+    my $alpha = FALSE;
+    my $vinf = FALSE;
+    my @av;
+
+    $s = new ExtUtils::MakeMaker::charstar $s;
+
+    while (isSPACE($s)) { # leading whitespace is OK
+       $s++;
+    }
+
+    $last = prescan_version($s, FALSE, \$errstr, \$qv, \$saw_decimal,
+       \$width, \$alpha);
+
+    if ($errstr) {
+       # 'undef' is a special case and not an error
+       if ( $s ne 'undef') {
+           require Carp;
+           Carp::croak($errstr);
+       }
+    }
+
+    $start = $s;
+    if ($s eq 'v') {
+       $s++;
+    }
+    $pos = $s;
+
+    if ( $qv ) {
+       $$rv->{qv} = $qv;
+    }
+    if ( $alpha ) {
+       $$rv->{alpha} = $alpha;
+    }
+    if ( !$qv && $width < 3 ) {
+       $$rv->{width} = $width;
+    }
+
+    while (isDIGIT($pos)) {
+       $pos++;
+    }
+    if (!isALPHA($pos)) {
+       my $rev;
+
+       for (;;) {
+           $rev = 0;
+           {
+               # this is atoi() that delimits on underscores
+               my $end = $pos;
+               my $mult = 1;
+               my $orev;
+
+               #  the following if() will only be true after the decimal
+               #  point of a version originally created with a bare
+               #  floating point number, i.e. not quoted in any way
+               #
+               if ( !$qv && $s > $start && $saw_decimal == 1 ) {
+                   $mult *= 100;
+                   while ( $s < $end ) {
+                       $orev = $rev;
+                       $rev += $s * $mult;
+                       $mult /= 10;
+                       if (   (abs($orev) > abs($rev))
+                           || (abs($rev) > $VERSION_MAX )) {
+                           warn("Integer overflow in version %d",
+                                          $VERSION_MAX);
+                           $s = $end - 1;
+                           $rev = $VERSION_MAX;
+                           $vinf = 1;
+                       }
+                       $s++;
+                       if ( $s eq '_' ) {
+                           $s++;
+                       }
+                   }
+               }
+               else {
+                   while (--$end >= $s) {
+                       $orev = $rev;
+                       $rev += $end * $mult;
+                       $mult *= 10;
+                       if (   (abs($orev) > abs($rev))
+                           || (abs($rev) > $VERSION_MAX )) {
+                           warn("Integer overflow in version");
+                           $end = $s - 1;
+                           $rev = $VERSION_MAX;
+                           $vinf = 1;
+                       }
+                   }
+               }
+           }
+
+           # Append revision
+           push @av, $rev;
+           if ( $vinf ) {
+               $s = $last;
+               last;
+           }
+           elsif ( $pos eq '.' ) {
+               $s = ++$pos;
+           }
+           elsif ( $pos eq '_' && isDIGIT($pos+1) ) {
+               $s = ++$pos;
+           }
+           elsif ( $pos eq ',' && isDIGIT($pos+1) ) {
+               $s = ++$pos;
+           }
+           elsif ( isDIGIT($pos) ) {
+               $s = $pos;
+           }
+           else {
+               $s = $pos;
+               last;
+           }
+           if ( $qv ) {
+               while ( isDIGIT($pos) ) {
+                   $pos++;
+               }
+           }
+           else {
+               my $digits = 0;
+               while ( ( isDIGIT($pos) || $pos eq '_' ) && $digits < 3 ) {
+                   if ( $pos ne '_' ) {
+                       $digits++;
+                   }
+                   $pos++;
+               }
+           }
+       }
+    }
+    if ( $qv ) { # quoted versions always get at least three terms
+       my $len = $#av;
+       #  This for loop appears to trigger a compiler bug on OS X, as it
+       #  loops infinitely. Yes, len is negative. No, it makes no sense.
+       #  Compiler in question is:
+       #  gcc version 3.3 20030304 (Apple Computer, Inc. build 1640)
+       #  for ( len = 2 - len; len > 0; len-- )
+       #  av_push(MUTABLE_AV(sv), newSViv(0));
+       #
+       $len = 2 - $len;
+       while ($len-- > 0) {
+           push @av, 0;
+       }
+    }
+
+    # need to save off the current version string for later
+    if ( $vinf ) {
+       $$rv->{original} = "v.Inf";
+       $$rv->{vinf} = 1;
+    }
+    elsif ( $s > $start ) {
+       $$rv->{original} = $start->currstr($s);
+       if ( $qv && $saw_decimal == 1 && $start ne 'v' ) {
+           # need to insert a v to be consistent
+           $$rv->{original} = 'v' . $$rv->{original};
+       }
+    }
+    else {
+       $$rv->{original} = '0';
+       push(@av, 0);
+    }
+
+    # And finally, store the AV in the hash
+    $$rv->{version} = \@av;
+
+    # fix RT#19517 - special case 'undef' as string
+    if ($s eq 'undef') {
+       $s += 5;
+    }
+
+    return $s;
+}
+
+sub new {
+    my $class = shift;
+    unless (defined $class or $#_ > 1) {
+       require Carp;
+       Carp::croak('Usage: version::new(class, version)');
+    }
+
+    my $self = bless ({}, ref ($class) || $class);
+    my $qv = FALSE;
+
+    if ( $#_ == 1 ) { # must be CVS-style
+       $qv = TRUE;
+    }
+    my $value = pop; # always going to be the last element
+
+    if ( ref($value) && eval('$value->isa("version")') ) {
+       # Can copy the elements directly
+       $self->{version} = [ @{$value->{version} } ];
+       $self->{qv} = 1 if $value->{qv};
+       $self->{alpha} = 1 if $value->{alpha};
+       $self->{original} = ''.$value->{original};
+       return $self;
+    }
+
+    if ( not defined $value or $value =~ /^undef$/ ) {
+       # RT #19517 - special case for undef comparison
+       # or someone forgot to pass a value
+       push @{$self->{version}}, 0;
+       $self->{original} = "0";
+       return ($self);
+    }
+
+
+    if (ref($value) =~ m/ARRAY|HASH/) {
+       require Carp;
+       Carp::croak("Invalid version format (non-numeric data)");
+    }
+
+    $value = _un_vstring($value);
+
+    if ($Config{d_setlocale} && eval { require POSIX } ) {
+      require locale;
+       my $currlocale = POSIX::setlocale(&POSIX::LC_ALL);
+
+       # if the current locale uses commas for decimal points, we
+       # just replace commas with decimal places, rather than changing
+       # locales
+       if ( POSIX::localeconv()->{decimal_point} eq ',' ) {
+           $value =~ tr/,/./;
+       }
+    }
+
+    # exponential notation
+    if ( $value =~ /\d+.?\d*e[-+]?\d+/ ) {
+       $value = sprintf("%.9f",$value);
+       $value =~ s/(0+)$//; # trim trailing zeros
+    }
+
+    my $s = scan_version($value, \$self, $qv);
+
+    if ($s) { # must be something left over
+       warn("Version string '%s' contains invalid data; "
+                  ."ignoring: '%s'", $value, $s);
+    }
+
+    return ($self);
+}
+
+*parse = \&new;
+
+sub numify {
+    my ($self) = @_;
+    unless (_verify($self)) {
+       require Carp;
+       Carp::croak("Invalid version object");
+    }
+    my $width = $self->{width} || 3;
+    my $alpha = $self->{alpha} || "";
+    my $len = $#{$self->{version}};
+    my $digit = $self->{version}[0];
+    my $string = sprintf("%d.", $digit );
+
+    for ( my $i = 1 ; $i < $len ; $i++ ) {
+       $digit = $self->{version}[$i];
+       if ( $width < 3 ) {
+           my $denom = 10**(3-$width);
+           my $quot = int($digit/$denom);
+           my $rem = $digit - ($quot * $denom);
+           $string .= sprintf("%0".$width."d_%d", $quot, $rem);
+       }
+       else {
+           $string .= sprintf("%03d", $digit);
+       }
+    }
+
+    if ( $len > 0 ) {
+       $digit = $self->{version}[$len];
+       if ( $alpha && $width == 3 ) {
+           $string .= "_";
+       }
+       $string .= sprintf("%0".$width."d", $digit);
+    }
+    else # $len = 0
+    {
+       $string .= sprintf("000");
+    }
+
+    return $string;
+}
+
+sub normal {
+    my ($self) = @_;
+    unless (_verify($self)) {
+       require Carp;
+       Carp::croak("Invalid version object");
+    }
+    my $alpha = $self->{alpha} || "";
+    my $len = $#{$self->{version}};
+    my $digit = $self->{version}[0];
+    my $string = sprintf("v%d", $digit );
+
+    for ( my $i = 1 ; $i < $len ; $i++ ) {
+       $digit = $self->{version}[$i];
+       $string .= sprintf(".%d", $digit);
+    }
+
+    if ( $len > 0 ) {
+       $digit = $self->{version}[$len];
+       if ( $alpha ) {
+           $string .= sprintf("_%0d", $digit);
+       }
+       else {
+           $string .= sprintf(".%0d", $digit);
+       }
+    }
+
+    if ( $len <= 2 ) {
+       for ( $len = 2 - $len; $len != 0; $len-- ) {
+           $string .= sprintf(".%0d", 0);
+       }
+    }
+
+    return $string;
+}
+
+sub stringify {
+    my ($self) = @_;
+    unless (_verify($self)) {
+       require Carp;
+       Carp::croak("Invalid version object");
+    }
+    return exists $self->{original}
+       ? $self->{original}
+       : exists $self->{qv}
+           ? $self->normal
+           : $self->numify;
+}
+
+sub vcmp {
+    require UNIVERSAL;
+    my ($left,$right,$swap) = @_;
+    my $class = ref($left);
+    unless ( UNIVERSAL::isa($right, $class) ) {
+       $right = $class->new($right);
+    }
+
+    if ( $swap ) {
+       ($left, $right) = ($right, $left);
+    }
+    unless (_verify($left)) {
+       require Carp;
+       Carp::croak("Invalid version object");
+    }
+    unless (_verify($right)) {
+       require Carp;
+       Carp::croak("Invalid version format");
+    }
+    my $l = $#{$left->{version}};
+    my $r = $#{$right->{version}};
+    my $m = $l < $r ? $l : $r;
+    my $lalpha = $left->is_alpha;
+    my $ralpha = $right->is_alpha;
+    my $retval = 0;
+    my $i = 0;
+    while ( $i <= $m && $retval == 0 ) {
+       $retval = $left->{version}[$i] <=> $right->{version}[$i];
+       $i++;
+    }
+
+    # tiebreaker for alpha with identical terms
+    if ( $retval == 0
+       && $l == $r
+       && $left->{version}[$m] == $right->{version}[$m]
+       && ( $lalpha || $ralpha ) ) {
+
+       if ( $lalpha && !$ralpha ) {
+           $retval = -1;
+       }
+       elsif ( $ralpha && !$lalpha) {
+           $retval = +1;
+       }
+    }
+
+    # possible match except for trailing 0's
+    if ( $retval == 0 && $l != $r ) {
+       if ( $l < $r ) {
+           while ( $i <= $r && $retval == 0 ) {
+               if ( $right->{version}[$i] != 0 ) {
+                   $retval = -1; # not a match after all
+               }
+               $i++;
+           }
+       }
+       else {
+           while ( $i <= $l && $retval == 0 ) {
+               if ( $left->{version}[$i] != 0 ) {
+                   $retval = +1; # not a match after all
+               }
+               $i++;
+           }
+       }
+    }
+
+    return $retval;
+}
+
+sub vbool {
+    my ($self) = @_;
+    return vcmp($self,$self->new("0"),1);
+}
+
+sub vnoop {
+    require Carp;
+    Carp::croak("operation not supported with version object");
+}
+
+sub is_alpha {
+    my ($self) = @_;
+    return (exists $self->{alpha});
+}
+
+sub qv {
+    my $value = shift;
+    my $class = $CLASS;
+    if (@_) {
+       $class = ref($value) || $value;
+       $value = shift;
+    }
+
+    $value = _un_vstring($value);
+    $value = 'v'.$value unless $value =~ /(^v|\d+\.\d+\.\d)/;
+    my $obj = $CLASS->new($value);
+    return bless $obj, $class;
+}
+
+*declare = \&qv;
+
+sub is_qv {
+    my ($self) = @_;
+    return (exists $self->{qv});
+}
+
+
+sub _verify {
+    my ($self) = @_;
+    if ( ref($self)
+       && eval { exists $self->{version} }
+       && ref($self->{version}) eq 'ARRAY'
+       ) {
+       return 1;
+    }
+    else {
+       return 0;
+    }
+}
+
+sub _is_non_alphanumeric {
+    my $s = shift;
+    $s = new ExtUtils::MakeMaker::charstar $s;
+    while ($s) {
+       return 0 if isSPACE($s); # early out
+       return 1 unless (isALPHA($s) || isDIGIT($s) || $s =~ /[.-]/);
+       $s++;
+    }
+    return 0;
+}
+
+sub _un_vstring {
+    my $value = shift;
+    # may be a v-string
+    if ( length($value) >= 3 && $value !~ /[._]/
+       && _is_non_alphanumeric($value)) {
+       my $tvalue;
+       if ( $] ge 5.008_001 ) {
+           $tvalue = _find_magic_vstring($value);
+           $value = $tvalue if length $tvalue;
+       }
+       elsif ( $] ge 5.006_000 ) {
+           $tvalue = sprintf("v%vd",$value);
+           if ( $tvalue =~ /^v\d+(\.\d+){2,}$/ ) {
+               # must be a v-string
+               $value = $tvalue;
+           }
+       }
+    }
+    return $value;
+}
+
+sub _find_magic_vstring {
+    my $value = shift;
+    my $tvalue = '';
+    require B;
+    my $sv = B::svref_2object(\$value);
+    my $magic = ref($sv) eq 'B::PVMG' ? $sv->MAGIC : undef;
+    while ( $magic ) {
+       if ( $magic->TYPE eq 'V' ) {
+           $tvalue = $magic->PTR;
+           $tvalue =~ s/^v?(.+)$/v$1/;
+           last;
+       }
+       else {
+           $magic = $magic->MOREMAGIC;
+       }
+    }
+    return $tvalue;
+}
+
+sub _VERSION {
+    my ($obj, $req) = @_;
+    my $class = ref($obj) || $obj;
+
+    no strict 'refs';
+    if ( exists $INC{"$class.pm"} and not %{"$class\::"} and $] >= 5.008) {
+        # file but no package
+       require Carp;
+       Carp::croak( "$class defines neither package nor VERSION"
+           ."--version check failed");
+    }
+
+    my $version = eval "\$$class\::VERSION";
+    if ( defined $version ) {
+       local $^W if $] <= 5.008;
+       $version = ExtUtils::MakeMaker::version::vpp->new($version);
+    }
+
+    if ( defined $req ) {
+       unless ( defined $version ) {
+           require Carp;
+           my $msg =  $] < 5.006
+           ? "$class version $req required--this is only version "
+           : "$class does not define \$$class\::VERSION"
+             ."--version check failed";
+
+           if ( $ENV{VERSION_DEBUG} ) {
+               Carp::confess($msg);
+           }
+           else {
+               Carp::croak($msg);
+           }
+       }
+
+       $req = ExtUtils::MakeMaker::version::vpp->new($req);
+
+       if ( $req > $version ) {
+           require Carp;
+           if ( $req->is_qv ) {
+               Carp::croak(
+                   sprintf ("%s version %s required--".
+                       "this is only version %s", $class,
+                       $req->normal, $version->normal)
+               );
+           }
+           else {
+               Carp::croak(
+                   sprintf ("%s version %s required--".
+                       "this is only version %s", $class,
+                       $req->stringify, $version->stringify)
+               );
+           }
+       }
+    }
+
+    return defined $version ? $version->stringify : undef;
+}
+
+1; #this line is important and will help the module return a true value
index bb85e85..6537d9f 100644 (file)
@@ -3,7 +3,7 @@ package ExtUtils::Mkbootstrap;
 # There's just too much Dynaloader incest here to turn on strict vars.
 use strict 'refs';
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 require Exporter;
 our @ISA = ('Exporter');
index 176faf1..c6c9295 100644 (file)
@@ -10,7 +10,7 @@ use Config;
 
 our @ISA = qw(Exporter);
 our @EXPORT = qw(&Mksymlists);
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 sub Mksymlists {
     my(%spec) = @_;
@@ -141,19 +141,24 @@ sub _write_win32 {
     print $def "EXPORTS\n  ";
     my @syms;
     # Export public symbols both with and without underscores to
-    # ensure compatibility between DLLs from different compilers
+    # ensure compatibility between DLLs from Borland C and Visual C
     # NOTE: DynaLoader itself only uses the names without underscores,
     # so this is only to cover the case when the extension DLL may be
     # linked to directly from C. GSAR 97-07-10
-    if ($Config::Config{'cc'} =~ /^bcc/i) {
-        for (@{$data->{DL_VARS}}, @{$data->{FUNCLIST}}) {
-            push @syms, "_$_", "$_ = _$_";
+
+    #bcc dropped in 5.16, so dont create useless extra symbols for export table
+    unless($] >= 5.016) {
+        if ($Config::Config{'cc'} =~ /^bcc/i) {
+            push @syms, "_$_", "$_ = _$_"
+                for (@{$data->{DL_VARS}}, @{$data->{FUNCLIST}});
         }
-    }
-    else {
-        for (@{$data->{DL_VARS}}, @{$data->{FUNCLIST}}) {
-            push @syms, "$_", "_$_ = $_";
+        else {
+            push @syms, "$_", "_$_ = $_"
+                for (@{$data->{DL_VARS}}, @{$data->{FUNCLIST}});
         }
+    } else {
+        push @syms, "$_"
+            for (@{$data->{DL_VARS}}, @{$data->{FUNCLIST}});
     }
     print $def join("\n  ",@syms, "\n") if @syms;
     _print_imports($def, $data);
index d8cd4bc..02dc473 100644 (file)
@@ -3,7 +3,7 @@ package ExtUtils::testlib;
 use strict;
 use warnings;
 
-our $VERSION = '6.98';
+our $VERSION = '7.02';
 
 use Cwd;
 use File::Spec;
index 9b5269a..7218dd3 100644 (file)
@@ -21,7 +21,7 @@ perl_lib();
 
 ok( setup_recurs(), 'setup' );
 END {
-    ok( chdir File::Spec->updir );
+    ok( chdir File::Spec->updir, 'chdir updir' );
     ok( teardown_recurs(), 'teardown' );
 }
 
index a5e469c..fc31611 100644 (file)
@@ -1,6 +1,6 @@
 #!/usr/bin/perl -w
 
-# Tests INSTALL_BASE
+# Tests INSTALL_BASE to a directory without AND with a space in the name
 
 BEGIN {
     unshift @INC, 't/lib';
@@ -9,72 +9,81 @@ BEGIN {
 use strict;
 use File::Path;
 use Config;
+my @INSTDIRS = ('../dummy-install', '../dummy  install');
+my $CLEANUP = 1;
+$CLEANUP &&= 1; # so always 1 or numerically 0
 
-use Test::More
-    $ENV{PERL_CORE} && $Config{'usecrosscompile'}
-    ? (skip_all => "no toolchain installed when cross-compiling")
-    : (tests => 20);
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::BFD;
+use Test::More;
+use Config;
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : (tests => 3 + $CLEANUP + @INSTDIRS * (15 + $CLEANUP));
 
 my $Is_VMS = $^O eq 'VMS';
 
 my $perl = which_perl();
 
 use File::Temp qw[tempdir];
-my $tmpdir = tempdir( DIR => 't', CLEANUP => 1 );
+my $tmpdir = tempdir( DIR => 't', CLEANUP => $CLEANUP );
 chdir $tmpdir;
 
 perl_lib;
 
 ok( setup_recurs(), 'setup' );
 END {
-    ok( chdir File::Spec->updir );
-    ok( teardown_recurs(), 'teardown' );
+    ok( chdir File::Spec->updir, 'chdir updir' );
+    ok( teardown_recurs(), 'teardown' ) if $CLEANUP;
+    map { rmtree $_ } @INSTDIRS if $CLEANUP;
 }
 
 ok( chdir('Big-Dummy'), "chdir'd to Big-Dummy") || diag("chdir failed; $!");
 
-my @mpl_out = run(qq{$perl Makefile.PL "INSTALL_BASE=../dummy-install"});
-END { rmtree '../dummy-install'; }
+for my $instdir (@INSTDIRS) {
+  my @mpl_out = run(qq{$perl Makefile.PL "INSTALL_BASE=$instdir"});
 
-cmp_ok( $?, '==', 0, 'Makefile.PL exited with zero' ) ||
-  diag(@mpl_out);
+  cmp_ok( $?, '==', 0, 'Makefile.PL exited with zero' ) ||
+    diag(@mpl_out);
 
-my $makefile = makefile_name();
-ok( grep(/^Writing $makefile for Big::Dummy/,
-         @mpl_out) == 1,
-                                           'Makefile.PL output looks right');
+  my $makefile = makefile_name();
+  ok( grep(/^Writing $makefile for Big::Dummy/,
+          @mpl_out) == 1,
+                                            'Makefile.PL output looks right');
 
-my $make = make_run();
-run("$make");   # this is necessary due to a dmake bug.
-my $install_out = run("$make install");
-is( $?, 0, '  make install exited normally' ) || diag $install_out;
-like( $install_out, qr/^Installing /m );
+  my $make = make_run();
+  run("$make");   # this is necessary due to a dmake bug.
+  my $install_out = run("$make install");
+  is( $?, 0, '  make install exited normally' ) || diag $install_out;
+  like( $install_out, qr/^Installing /m, '"Installing" in output' );
 
-ok( -r '../dummy-install',      '  install dir created' );
+  ok( -r $instdir,      '  install dir created' );
 
-my @installed_files =
-  ('../dummy-install/lib/perl5/Big/Dummy.pm',
-   '../dummy-install/lib/perl5/Big/Liar.pm',
-   '../dummy-install/bin/program',
-   "../dummy-install/lib/perl5/$Config{archname}/perllocal.pod",
-   "../dummy-install/lib/perl5/$Config{archname}/auto/Big/Dummy/.packlist"
-  );
+  my @installed_files =
+    ("$instdir/lib/perl5/Big/Dummy.pm",
+     "$instdir/lib/perl5/Big/Liar.pm",
+     "$instdir/bin/program",
+     "$instdir/lib/perl5/$Config{archname}/perllocal.pod",
+     "$instdir/lib/perl5/$Config{archname}/auto/Big/Dummy/.packlist"
+    );
 
-foreach my $file (@installed_files) {
-    ok( -e $file, "  $file installed" );
-    ok( -r $file, "  $file readable" );
-}
+  foreach my $file (@installed_files) {
+      ok( -e $file, "  $file installed" );
+      ok( -r $file, "  $file readable" );
+  }
 
 
-# nmake outputs its damned logo
-# Send STDERR off to oblivion.
-open(SAVERR, ">&STDERR") or die $!;
-open(STDERR, ">".File::Spec->devnull) or die $!;
+  # nmake outputs its damned logo
+  # Send STDERR off to oblivion.
+  open(SAVERR, ">&STDERR") or die $!;
+  open(STDERR, ">".File::Spec->devnull) or die $!;
 
-my $realclean_out = run("$make realclean");
-is( $?, 0, 'realclean' ) || diag($realclean_out);
+  if ($CLEANUP) {
+      my $realclean_out = run("$make realclean");
+      is( $?, 0, 'realclean' ) || diag($realclean_out);
+  }
 
-open(STDERR, ">&SAVERR") or die $!;
-close SAVERR;
+  open(STDERR, ">&SAVERR") or die $!;
+  close SAVERR;
+}
index 60f53c4..ed07691 100644 (file)
@@ -220,6 +220,6 @@ foreach (qw/ EXPORT_LIST PERL_ARCHIVE PERL_ARCHIVE_AFTER /)
     $t->cflags();
 
     # Brief bug where CCFLAGS was being blown away
-    is( $t->{CCFLAGS}, '-DMY_THING',    'cflags retains CCFLAGS' );
+    like( $t->{CCFLAGS}, qr/\-DMY_THING/,    'cflags retains CCFLAGS' );
 }
 
index dd113a9..8e921bd 100644 (file)
@@ -15,54 +15,52 @@ use Test::More;
 
 my $mm = bless {}, "MM";
 
-sub extract_params {
-    my $text = join "\n", @_;
-
-    $text =~ s{^\s* \# \s+ MakeMaker\ Parameters: \s*\n}{}x;
-    $text =~ s{^#}{}gms;
-    $text =~ s{\n}{,\n}g;
-
-    no strict 'subs';
-    return { eval "$text" };
+sub process_cmp {
+  my ($args, $expected, $label) = @_;
+  my $got = join '',
+    map "$_\n", $mm->_MakeMaker_Parameters_section($args || ());
+  $got =~ s/^#\s*MakeMaker Parameters:\n+//;
+  is $got, $expected, $label;
 }
 
-sub test_round_trip {
-    my $args = shift;
-    my $want = @_ ? shift : $args;
-
-    my $have = extract_params($mm->_MakeMaker_Parameters_section($args));
-
-    local $Test::Builder::Level = $Test::Builder::Level + 1;
-    is_deeply $have, $want or diag explain $have, "\n", $want;
-}
-
-is join("", $mm->_MakeMaker_Parameters_section()), <<'EXPECT', "nothing";
-#   MakeMaker Parameters:
+process_cmp undef, '', 'nothing';
+process_cmp { NAME => "Foo" }, <<'EXPECT', "name only";
+#     NAME => q[Foo]
+EXPECT
+process_cmp
+  { NAME => "Foo", PREREQ_PM => { "Foo::Bar" => 0 } }, <<'EXPECT', "PREREQ v0";
+#     NAME => q[Foo]
+#     PREREQ_PM => { Foo::Bar=>q[0] }
+EXPECT
+process_cmp
+  { NAME => "Foo", PREREQ_PM => { "Foo::Bar" => 1.23 } },
+  <<'EXPECT', "PREREQ v-non-0";
+#     NAME => q[Foo]
+#     PREREQ_PM => { Foo::Bar=>q[1.23] }
 EXPECT
 
-test_round_trip({ NAME => "Foo" });
-test_round_trip({ NAME => "Foo", PREREQ_PM => { "Foo::Bar" => 0 } });
-test_round_trip({ NAME => "Foo", PREREQ_PM => { "Foo::Bar" => 1.23 } });
-
-# Test the special case for BUILD_REQUIRES
-{
-    my $have = {
-        NAME                => "Foo",
-        PREREQ_PM           => { "Foo::Bar" => 1.23 },
-        BUILD_REQUIRES      => { "Baz"      => 0.12 },
-    };
-
-    my $want = {
-        NAME                => "Foo",
-        PREREQ_PM           => {
-            "Foo::Bar"  => 1.23,
-            "Baz"       => 0.12,
-        },
-        BUILD_REQUIRES      => { "Baz"      => 0.12 },
-    };
+process_cmp
+  {
+    NAME                => "Foo",
+    PREREQ_PM           => { "Foo::Bar" => 1.23 },
+    BUILD_REQUIRES      => { "Baz"      => 0.12 },
+  },
+  <<'EXPECT', "BUILD_REQUIRES";
+#     BUILD_REQUIRES => { Baz=>q[0.12] }
+#     NAME => q[Foo]
+#     PREREQ_PM => { Baz=>q[0.12], Foo::Bar=>q[1.23] }
+EXPECT
 
-    test_round_trip( $have, $want );
-}
+process_cmp
+  {
+    NAME                => "Foo",
+    PREREQ_PM           => { "Foo::Bar" => 1.23, Long => 1.45, Short => 0 },
+    BUILD_REQUIRES      => { "Baz"      => 0.12 },
+  },
+  <<'EXPECT', "ensure sorting";
+#     BUILD_REQUIRES => { Baz=>q[0.12] }
+#     NAME => q[Foo]
+#     PREREQ_PM => { Baz=>q[0.12], Foo::Bar=>q[1.23], Long=>q[1.45], Short=>q[0] }
+EXPECT
 
 done_testing();
-
index 192a836..f96186f 100644 (file)
@@ -5,16 +5,17 @@ BEGIN {
 }
 
 use strict;
-use Config;
-use Test::More
-    $ENV{PERL_CORE} && $Config{'usecrosscompile'}
-    ? (skip_all => "no toolchain installed when cross-compiling")
-    : (tests => 9);
 
 use File::Spec;
 use File::Temp qw[tempdir];
 use MakeMaker::Test::Setup::PL_FILES;
 use MakeMaker::Test::Utils;
+use Config;
+use Test::More;
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : (tests => 9);
 
 my $perl = which_perl();
 my $make = make_run();
index b74da44..a0a6f91 100644 (file)
@@ -3,6 +3,11 @@
 # This test puts MakeMaker through the paces of a basic perl module
 # build, test and installation of the Big::Fat::Dummy module.
 
+# Module::Install relies on being able to patch the generated Makefile
+# to add flags to $(PERL)
+# This test includes adding ' -Iinc' to $(PERL), and checking 'make install'
+# after that works. Done here as back-compat is considered basic.
+
 BEGIN {
     unshift @INC, 't/lib';
 }
@@ -10,13 +15,16 @@ BEGIN {
 use strict;
 use Config;
 use ExtUtils::MakeMaker;
+use utf8;
 
-use Test::More
-    $ENV{PERL_CORE} && $Config{'usecrosscompile'}
-    ? (skip_all => "no toolchain installed when cross-compiling")
-    : (tests => 171);
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::BFD;
+use Config;
+use Test::More;
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : (tests => 171);
 use File::Find;
 use File::Spec;
 use File::Path;
@@ -24,6 +32,12 @@ use File::Temp qw[tempdir];
 
 my $perl = which_perl();
 my $Is_VMS = $^O eq 'VMS';
+my $OLD_CP; # crude but...
+if ($^O eq "MSWin32") {
+    $OLD_CP = $1 if qx(chcp) =~ /(\d+)$/ and $? == 0;
+    qx(chcp 1252) if defined $OLD_CP;
+}
+END { qx(chcp $OLD_CP) if $^O eq "MSWin32" and defined $OLD_CP }
 
 my $tmpdir = tempdir( DIR => 't', CLEANUP => 1 );
 chdir $tmpdir;
@@ -43,8 +57,10 @@ END {
 ok( chdir('Big-Dummy'), "chdir'd to Big-Dummy" ) ||
   diag("chdir failed: $!");
 
-my @mpl_out = run(qq{$perl Makefile.PL "PREFIX=../dummy-install"});
-END { rmtree '../dummy-install'; }
+sub extrachar { $] > 5.008 && !$ENV{PERL_CORE} ? utf8::decode(my $c='š') : 's' }
+my $DUMMYINST = '../dummy-in'.extrachar().'tall';
+my @mpl_out = run(qq{$perl Makefile.PL "PREFIX=$DUMMYINST"});
+END { rmtree $DUMMYINST; }
 
 cmp_ok( $?, '==', 0, 'Makefile.PL exited with zero' ) ||
   diag(@mpl_out);
@@ -62,18 +78,18 @@ ok( -e $makefile,       'Makefile exists' );
 
 # -M is flakey on VMS
 my $mtime = (stat($makefile))[9];
-cmp_ok( $Touch_Time, '<=', $mtime,  '  its been touched' );
+cmp_ok( $Touch_Time, '<=', $mtime,  '  been touched' );
 
 END { unlink makefile_name(), makefile_backup() }
 
 my $make = make_run();
 
 {
-    # Supress 'make manifest' noise
+    # Suppress 'make manifest' noise
     local $ENV{PERL_MM_MANIFEST_VERBOSE} = 0;
     my $manifest_out = run("$make manifest");
     ok( -e 'MANIFEST',      'make manifest created a MANIFEST' );
-    ok( -s 'MANIFEST',      '  its not empty' );
+    ok( -s 'MANIFEST',      '  not empty' );
 }
 
 END { unlink 'MANIFEST'; }
@@ -122,28 +138,42 @@ like( $test_out, qr/All tests successful/,  '  successful' );
 is( $?, 0,                                  '  exited normally' ) ||
     diag $test_out;
 
+# now simulate what Module::Install does, and edit $(PERL) to add flags
+open my $fh, '<', $makefile;
+my $mtext = join '', <$fh>;
+close $fh;
+$mtext =~ s/^(\s*PERL\s*=.*)$/$1 -Iinc/m;
+open $fh, '>', $makefile;
+print $fh $mtext;
+close $fh;
 
 my $install_out = run("$make install");
 is( $?, 0, 'install' ) || diag $install_out;
 like( $install_out, qr/^Installing /m );
 
-ok( -r '../dummy-install',     '  install dir created' );
-my %files = ();
-find( sub {
-    # do it case-insensitive for non-case preserving OSs
-    my $file = lc $_;
-
-    # VMS likes to put dots on the end of things that don't have them.
-    $file =~ s/\.$// if $Is_VMS;
-
-    $files{$file} = $File::Find::name;
-}, '../dummy-install' );
-ok( $files{'dummy.pm'},     '  Dummy.pm installed' );
-ok( $files{'liar.pm'},      '  Liar.pm installed'  );
-ok( $files{'program'},      '  program installed'  );
-ok( $files{'.packlist'},    '  packlist created'   );
-ok( $files{'perllocal.pod'},'  perllocal.pod created' );
+sub check_dummy_inst {
+    my $loc = shift;
+    my %files = ();
+    find( sub {
+       # do it case-insensitive for non-case preserving OSs
+       my $file = lc $_;
+       # VMS likes to put dots on the end of things that don't have them.
+       $file =~ s/\.$// if $Is_VMS;
+       $files{$file} = $File::Find::name;
+    }, $loc );
+    ok( $files{'dummy.pm'},     '  Dummy.pm installed' );
+    ok( $files{'liar.pm'},      '  Liar.pm installed'  );
+    ok( $files{'program'},      '  program installed'  );
+    ok( $files{'.packlist'},    '  packlist created'   );
+    ok( $files{'perllocal.pod'},'  perllocal.pod created' );
+    \%files;
+}
 
+SKIP: {
+    ok( -r $DUMMYINST,     '  install dir created' )
+       or skip "$DUMMYINST doesn't exist", 5;
+    check_dummy_inst($DUMMYINST);
+}
 
 SKIP: {
     skip 'VMS install targets do not preserve $(PREFIX)', 8 if $Is_VMS;
@@ -153,13 +183,7 @@ SKIP: {
     like( $install_out, qr/^Installing /m );
 
     ok( -r 'elsewhere',     '  install dir created' );
-    %files = ();
-    find( sub { $files{$_} = $File::Find::name; }, 'elsewhere' );
-    ok( $files{'Dummy.pm'},     '  Dummy.pm installed' );
-    ok( $files{'Liar.pm'},      '  Liar.pm installed'  );
-    ok( $files{'program'},      '  program installed'  );
-    ok( $files{'.packlist'},    '  packlist created'   );
-    ok( $files{'perllocal.pod'},'  perllocal.pod created' );
+    check_dummy_inst('elsewhere');
     rmtree('elsewhere');
 }
 
@@ -173,19 +197,10 @@ SKIP: {
     like( $install_out, qr/^Installing /m );
 
     ok( -d 'other',  '  destdir created' );
-    %files = ();
-    my $perllocal;
-    find( sub {
-        $files{$_} = $File::Find::name;
-    }, 'other' );
-    ok( $files{'Dummy.pm'},     '  Dummy.pm installed' );
-    ok( $files{'Liar.pm'},      '  Liar.pm installed'  );
-    ok( $files{'program'},      '  program installed'  );
-    ok( $files{'.packlist'},    '  packlist created'   );
-    ok( $files{'perllocal.pod'},'  perllocal.pod created' );
+    my $files = check_dummy_inst('other');
 
-    ok( open(PERLLOCAL, $files{'perllocal.pod'} ) ) ||
-        diag("Can't open $files{'perllocal.pod'}: $!");
+    ok( open(PERLLOCAL, $files->{'perllocal.pod'} ) ) ||
+        diag("Can't open $files->{'perllocal.pod'}: $!");
     { local $/;
       unlike(<PERLLOCAL>, qr/other/, 'DESTDIR should not appear in perllocal');
     }
@@ -214,13 +229,7 @@ SKIP: {
 
     ok( !-d 'elsewhere',       '  install dir not created' );
     ok( -d 'other/elsewhere',  '  destdir created' );
-    %files = ();
-    find( sub { $files{$_} = $File::Find::name; }, 'other/elsewhere' );
-    ok( $files{'Dummy.pm'},     '  Dummy.pm installed' );
-    ok( $files{'Liar.pm'},      '  Liar.pm installed'  );
-    ok( $files{'program'},      '  program installed'  );
-    ok( $files{'.packlist'},    '  packlist created'   );
-    ok( $files{'perllocal.pod'},'  perllocal.pod created' );
+    check_dummy_inst('other/elsewhere');
     rmtree('other');
 }
 
@@ -394,7 +403,7 @@ note "META file validity"; {
 
 
 # Make sure init_dirscan doesn't go into the distdir
-@mpl_out = run(qq{$perl Makefile.PL "PREFIX=../dummy-install"});
+@mpl_out = run(qq{$perl Makefile.PL "PREFIX=$DUMMYINST"});
 
 cmp_ok( $?, '==', 0, 'Makefile.PL exited with zero' ) || diag(@mpl_out);
 
@@ -413,7 +422,6 @@ is( $?, 0, 'realclean' ) || diag($realclean_out);
 open(STDERR, ">&SAVERR") or die $!;
 close SAVERR;
 
-
 sub _normalize {
     my $hash = shift;
 
index 9b9e064..16f6667 100644 (file)
@@ -34,7 +34,7 @@ my @cd_args = ($dir, "command1", "command2");
 qq{cd $dir
        command1
        command2
-       cd $expected_updir};
+       cd $expected_updir}, 'nmake';
     }
 
     {
@@ -42,14 +42,14 @@ qq{cd $dir
 
         ::is $mm->cd(@cd_args),
 qq{cd $dir && command1
-       cd $dir && command2};
+       cd $dir && command2}, 'dmake';
     }
 }
 
 {
     is +ExtUtils::MM_Unix->cd(@cd_args),
 qq{cd $dir && command1
-       cd $dir && command2};
+       cd $dir && command2}, 'Unix';
 }
 
 SKIP: {
@@ -61,5 +61,5 @@ q{startdir = F$Environment("Default")
        Set Default [.some.dir]
        command1
        command2
-       Set Default 'startdir'};
+       Set Default 'startdir'}, 'VMS';
 }
index 191999d..355eaa2 100644 (file)
@@ -15,9 +15,10 @@ use File::Temp;
 use Cwd 'abs_path';
 
 use Test::More;
-
-plan skip_all => "no toolchain installed when cross-compiling"
-    if $ENV{PERL_CORE} && $Config{'usecrosscompile'};
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : ();
 
 #--------------------- Setup
 
diff --git a/cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/Unicode.pm b/cpan/ExtUtils-MakeMaker/t/lib/MakeMaker/Test/Setup/Unicode.pm
new file mode 100644 (file)
index 0000000..76641f0
--- /dev/null
@@ -0,0 +1,90 @@
+package MakeMaker::Test::Setup::Unicode;
+
+@ISA = qw(Exporter);
+require Exporter;
+@EXPORT = qw(setup_recurs teardown_recurs);
+
+use strict;
+use File::Path;
+use File::Basename;
+use MakeMaker::Test::Utils;
+use utf8;
+use Config;
+
+my %Files = (
+             'Problem-Module/Makefile.PL'   => <<'PL_END',
+use ExtUtils::MakeMaker;
+use utf8;
+
+WriteMakefile(
+    NAME          => 'Problem::Module',
+    ABSTRACT_FROM => 'lib/Problem/Module.pm',
+    AUTHOR        => q{Danijel Tašov},
+    EXE_FILES     => [ qw(bin/probscript) ],
+    INSTALLMAN1DIR => "some", # even if disabled in $Config{man1dir}
+    MAN1EXT       => 1, # set to 0 if man pages disabled
+);
+PL_END
+
+            'Problem-Module/lib/Problem/Module.pm'  => <<'pm_END',
+use utf8;
+
+=pod
+
+=encoding utf8
+
+=head1 NAME
+
+Problem::Module - Danijel Tašov's great new module
+
+=cut
+
+1;
+pm_END
+
+            'Problem-Module/bin/probscript'  => <<'pl_END',
+#!/usr/bin/perl
+use utf8;
+
+=encoding utf8
+
+=head1 NAME
+
+文档 - Problem script
+pl_END
+);
+
+
+sub setup_recurs {
+    while(my($file, $text) = each %Files) {
+        # Convert to a relative, native file path.
+        $file = File::Spec->catfile(File::Spec->curdir, split m{\/}, $file);
+
+        my $dir = dirname($file);
+        mkpath $dir;
+        my $utf8 = ($] < 5.008 or !$Config{useperlio}) ? "" : ":utf8";
+        open(FILE, ">$utf8", $file) || die "Can't create $file: $!";
+        print FILE $text;
+        close FILE;
+
+        # ensure file at least 1 second old for makes that assume
+        # files with the same time are out of date.
+        my $time = calibrate_mtime();
+        utime $time, $time - 1, $file;
+    }
+
+    return 1;
+}
+
+sub teardown_recurs {
+    foreach my $file (keys %Files) {
+        my $dir = dirname($file);
+        if( -e $dir ) {
+            rmtree($dir) || return;
+        }
+    }
+    return 1;
+}
+
+
+1;
index f47da75..6ebca59 100644 (file)
@@ -8,8 +8,11 @@ use strict;
 use File::Path;
 use File::Basename;
 use MakeMaker::Test::Utils;
+use Config;
 
-my $Is_VMS = $^O eq 'VMS';
+use ExtUtils::MM;
+my $typemap = 'type map';
+$typemap =~ s/ //g unless MM->new({NAME=>'name'})->can_dep_space;
 
 my %Files = (
              'XS-Test/lib/XS/Test.pm'     => <<'END',
@@ -27,15 +30,19 @@ bootstrap XS::Test $VERSION;
 1;
 END
 
-             'XS-Test/Makefile.PL'          => <<'END',
+             'XS-Test/Makefile.PL'          => <<END,
 use ExtUtils::MakeMaker;
 
 WriteMakefile(
     NAME          => 'XS::Test',
     VERSION_FROM  => 'lib/XS/Test.pm',
+    TYPEMAPS      => [ '$typemap' ],
+    PERL          => "\$^X -w",
 );
 END
 
+             "XS-Test/$typemap"             => '',
+
              'XS-Test/Test.xs'              => <<'END',
 #include "EXTERN.h"
 #include "perl.h"
index 7d73927..16d6688 100644 (file)
@@ -30,6 +30,7 @@ our @EXPORT = qw(which_perl perl_lib makefile_name makefile_backup
         HARNESS_VERBOSE
         PREFIX
         MAKEFLAGS
+        PERL_INSTALL_QUIET
     );
 
     my %default_env_keys;
@@ -97,7 +98,7 @@ MakeMaker::Test::Utils - Utility routines for testing MakeMaker
 
 =head1 DESCRIPTION
 
-A consolidation of little utility functions used through out the
+A consolidation of little utility functions used throughout the
 MakeMaker test suite.
 
 =head2 Functions
@@ -138,6 +139,7 @@ sub which_perl {
             last if -x $perlpath;
         }
     }
+    $perlpath = qq{"$perlpath"}; # "safe... in a command line" even with spaces
 
     return $perlpath;
 }
@@ -213,7 +215,7 @@ sub make {
     my $make = $Config{make};
     $make = $ENV{MAKE} if exists $ENV{MAKE};
 
-    return $make;
+    return $Is_VMS ? $make : qq{"$make"};
 }
 
 =item B<make_run>
@@ -304,10 +306,7 @@ sub run {
 
     # Unix, modern Windows and OS/2 from 5.005_54 up can handle 2>&1
     # This makes our failure diagnostics nicer to read.
-    if( MM->os_flavor_is('Unix')                                   or
-        (MM->os_flavor_is('Win32') and !MM->os_flavor_is('Win9x')) or
-        ($] > 5.00554 and MM->os_flavor_is('OS/2'))
-      ) {
+    if (MM->can_redirect_error) {
         return `$cmd 2>&1`;
     }
     else {
index be53786..7053c33 100644 (file)
@@ -116,7 +116,7 @@ note "version object in provides"; {
         META_ADD => {
             provides => {
                 "CPAN::Testers::ParseReport" => {
-                    version => version->declare("v1.2.3"),
+                    version => version->new("v1.2.3"),
                     file    => "lib/CPAN/Testers/ParseReport.pm"
                 }
             }
index 0ec9c22..c5d78d6 100644 (file)
@@ -8,15 +8,16 @@ BEGIN {
 }
 
 use strict;
-use Config;
-use Test::More
-    $ENV{PERL_CORE} && $Config{'usecrosscompile'}
-    ? (skip_all => "no toolchain installed when cross-compiling")
-    : (tests => 36);
 
 use TieOut;
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::MPV;
+use Config;
+use Test::More;
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : (tests => 36);
 use File::Path;
 
 use ExtUtils::MakeMaker;
index 121d731..20ff347 100644 (file)
@@ -6,22 +6,17 @@
 use strict;
 use lib 't/lib';
 
-use Config;
 use Test::More;
+use Config;
 
 # In a BEGIN block so the END tests aren't registered.
 BEGIN {
-    plan skip_all => "miniperl test only necessary for the perl core"
+    plan skip_all => 'miniperl test only necessary for the perl core'
       if !$ENV{PERL_CORE};
 
-    plan skip_all => "no toolchain installed when cross-compiling"
-      if $ENV{PERL_CORE} && $Config{'usecrosscompile'};
-
-    plan "no_plan";
-}
-
-BEGIN {
-    ok !$INC{"ExtUtils/MakeMaker.pm"}, "MakeMaker is not yet loaded";
+    plan $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+      ? (skip_all => 'cross-compiling and make not available')
+      : 'no_plan';
 }
 
 # Disable all XS from here on
@@ -32,7 +27,6 @@ use ExtUtils::MakeMaker;
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::BFD;
 
-
 my $perl     = which_perl();
 my $makefile = makefile_name();
 my $make     = make_run();
index 5e89295..e7c2621 100644 (file)
@@ -12,6 +12,7 @@ use Test::More tests => 16;
 use File::Spec;
 
 my $TB = Test::More->builder;
+my $perl = which_perl;
 
 BEGIN { use_ok('ExtUtils::MM') }
 
@@ -23,7 +24,7 @@ isa_ok($mm, 'ExtUtils::MM_Any');
 sub try_oneliner {
     my($code, $switches, $expect, $name) = @_;
     my $cmd = $mm->oneliner($code, $switches);
-    $cmd =~ s{\$\(ABSPERLRUN\)}{$^X};
+    $cmd =~ s{\$\(ABSPERLRUN\)}{$perl};
 
     # VMS likes to put newlines at the end of commands if there isn't
     # one already.
index 8a02f69..5f5f120 100644 (file)
@@ -29,6 +29,7 @@ my %versions = (q[$VERSION = '1.00']            => '1.00',
                 q[our $VERSION = '1.23';]       => '1.23',
                 q[$CGI::VERSION='3.63']         => '3.63',
                 q[$VERSION = "1.627"; # ==> ALSO update the version in the pod text below!] => '1.627',
+                q[BEGIN { our $VERSION = '1.23' }]       => '1.23',
 
                 '$Something::VERSION == 1.0'    => undef,
                 '$Something::VERSION <= 1.0'    => undef,
index d1b153c..d82fe6a 100644 (file)
@@ -5,18 +5,18 @@
 use strict;
 use lib 't/lib';
 
-use Config;
-use Test::More
-    $ENV{PERL_CORE} && $Config{'usecrosscompile'}
-    ? (skip_all => "no toolchain installed when cross-compiling")
-    : 'no_plan';
 use File::Temp qw[tempdir];
 
 use ExtUtils::MakeMaker;
 
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::BFD;
-
+use Config;
+use Test::More;
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : 'no_plan';
 
 my $perl     = which_perl();
 my $makefile = makefile_name();
@@ -71,7 +71,10 @@ local $ENV{PERL_INSTALL_QUIET};
     run_ok(qq{$perl Makefile.PL});
 
     # XXX This is a fragile way to check that it reran.
-    like run_ok($make), qr/^Skip /ms;
+    TODO: {
+      local $TODO = 'This one is fragile on some systems for some reason that needs investigation';
+      like run_ok($make), qr/^Skip /ms;
+    }
 
     ok( -e "blib/lib/Big/Dummy.pm", "blib copied pm file" );
 }
index 28870c2..dbdea95 100644 (file)
@@ -7,6 +7,7 @@ BEGIN {
 }
 
 use strict;
+use Config;
 use Test::More tests => 8;
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::BFD;
@@ -33,6 +34,11 @@ ok( chdir 'Big-Dummy', q{chdir'd to Big-Dummy} ) ||
 {
     my $warnings = '';
     local $SIG{__WARN__} = sub {
+        if ( $Config{usecrosscompile} ) {
+            # libraries might not be present on the target system
+            # when cross-compiling
+            return if $_[0] =~ /\A\QWarning (mostly harmless): No library found for \E.+/
+        }
         $warnings = join '', @_;
     };
 
index 2436888..48d9d17 100644 (file)
@@ -8,6 +8,7 @@ BEGIN {
 }
 
 use strict;
+use Config;
 use Test::More tests => 16;
 use File::Temp qw[tempdir];
 
@@ -35,6 +36,11 @@ ok( chdir 'Big-Dummy', "chdir'd to Big-Dummy" ) ||
     ok( my $stdout = tie *STDOUT, 'TieOut' );
     my $warnings = '';
     local $SIG{__WARN__} = sub {
+        if ( $Config{usecrosscompile} ) {
+            # libraries might not be present on the target system
+            # when cross-compiling
+            return if $_[0] =~ /\A\QWarning (mostly harmless): No library found for \E.+/
+        }
         $warnings .= join '', @_;
     };
     # prerequisite warnings are disabled while building the perl core:
index 1942370..6f1c093 100644 (file)
@@ -9,14 +9,16 @@ BEGIN {
 use strict;
 use Config;
 
-use Test::More
-    $ENV{PERL_CORE} && $Config{'usecrosscompile'}
-    ? (skip_all => "no toolchain installed when cross-compiling")
-    : (tests => 26);
 use File::Temp qw[tempdir];
 
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::Recurs;
+use Config;
+use Test::More;
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : (tests => 26);
 
 # 'make disttest' sets a bunch of environment variables which interfere
 # with our testing.
index 98569ae..4753541 100644 (file)
@@ -8,16 +8,18 @@ BEGIN {
 }
 
 use strict;
-use Config;
-use Test::More
-    $ENV{PERL_CORE} && $Config{'usecrosscompile'}
-    ? (skip_all => "no toolchain installed when cross-compiling")
-    : (tests => 20);
 
 use TieOut;
 use MakeMaker::Test::Utils;
 use MakeMaker::Test::Setup::SAS;
+use Config;
+use Test::More;
+use ExtUtils::MM;
+plan !MM->can_run(make()) && $ENV{PERL_CORE} && $Config{'usecrosscompile'}
+    ? (skip_all => "cross-compiling and make not available")
+    : (tests => 20);
 use File::Path;
+use File::Temp qw[tempdir];
 
 use ExtUtils::MakeMaker;
 
@@ -28,7 +30,8 @@ my $perl     = which_perl();
 my $make     = make_run();
 my $makefile = makefile_name();
 
-chdir 't';
+my $tmpdir = tempdir( DIR => 't', CLEANUP => 1 );
+chdir $tmpdir;
 
 perl_lib();
 
diff --git a/cpan/ExtUtils-MakeMaker/t/unicode.t b/cpan/ExtUtils-MakeMaker/t/unicode.t
new file mode 100644 (file)
index 0000000..2bb56aa
--- /dev/null
@@ -0,0 +1,87 @@
+# Test problems in Makefile.PL's and hint files.
+
+BEGIN {
+    unshift @INC, 't/lib';
+}
+chdir 't';
+
+use strict;
+use Test::More;
+use Config;
+BEGIN {
+  plan skip_all => 'Need perlio and perl 5.8+.'
+    if $] < 5.008 or !$Config{useperlio};
+  plan tests => 9;
+}
+use ExtUtils::MM;
+use MakeMaker::Test::Setup::Unicode;
+use MakeMaker::Test::Utils qw(makefile_name make_run run);
+use TieOut;
+
+my $MM = bless { DIR => ['.'] }, 'MM';
+
+ok( setup_recurs(), 'setup' );
+END {
+    ok( chdir File::Spec->updir, 'chdir updir' );
+    ok( teardown_recurs(), 'teardown' );
+}
+
+ok( chdir 'Problem-Module', "chdir'd to Problem-Module" ) ||
+  diag("chdir failed: $!");
+
+if ($] >= 5.008) {
+  eval { require ExtUtils::MakeMaker::Locale; };
+  note "ExtUtils::MakeMaker::Locale vars: $ExtUtils::MakeMaker::Locale::ENCODING_LOCALE;$ExtUtils::MakeMaker::Locale::ENCODING_LOCALE_FS;$ExtUtils::MakeMaker::Locale::ENCODING_CONSOLE_IN;$ExtUtils::MakeMaker::Locale::ENCODING_CONSOLE_OUT\n" unless $@;
+  note "Locale env vars: " . join(';', map {
+    "$_=$ENV{$_}"
+  } grep { /LANG|LC/ } keys %ENV) . "\n";
+}
+
+# Make sure when Makefile.PL's break, they issue a warning.
+# Also make sure Makefile.PL's in subdirs still have '.' in @INC.
+{
+    my $stdout = tie *STDOUT, 'TieOut' or die;
+
+    my $warning = '';
+    local $SIG{__WARN__} = sub { $warning .= join '', @_ };
+    $MM->eval_in_subdirs;
+    my $warnlines = grep { !/does not map to/ } split "\n", $warning;
+    is $warnlines, 0, 'no warning' or diag $warning;
+
+    open my $json_fh, '<:utf8', 'MYMETA.json' or die $!;
+    my $json = do { local $/; <$json_fh> };
+    close $json_fh;
+
+    require Encode;
+    my $str = Encode::decode( 'utf8', "Danijel Tašov's" );
+    like( $json, qr/$str/, 'utf8 abstract' );
+
+    untie *STDOUT;
+}
+
+my $make = make_run();
+my $make_out = run("$make");
+is $? >> 8, 0, 'Exit code of make == 0';
+
+my $manfile = File::Spec->catfile(qw(blib man1 probscript.1));
+SKIP: {
+  skip 'Manpage not generated', 1 unless -f $manfile;
+  skip 'Pod::Man >= 2.17 needed', 1 unless do {
+    require Pod::Man; $Pod::Man::VERSION >= 2.17;
+  };
+  open my $man_fh, '<:utf8', $manfile or die "open $manfile: $!";
+  my $man = do { local $/; <$man_fh> };
+  close $man_fh;
+
+  require Encode;
+  my $str = Encode::decode( 'utf8', "文档" );
+  like( $man, qr/$str/, 'utf8 man-snippet' );
+}
+
+$make_out = run("$make realclean");
+is $? >> 8, 0, 'Exit code of make == 0';
+
+sub makefile_content {
+  open my $fh, '<', makefile_name or die;
+  return <$fh>;
+}
diff --git a/cpan/ExtUtils-MakeMaker/t/vstrings.t b/cpan/ExtUtils-MakeMaker/t/vstrings.t
new file mode 100644 (file)
index 0000000..a34b938
--- /dev/null
@@ -0,0 +1,73 @@
+#!/usr/bin/perl -w
+
+# test support for various forms of vstring versions in PREREQ_PM
+
+# Magic for core
+BEGIN {
+    # Always run in t to unify behaviour with core
+    chdir 't' if -d 't';
+}
+
+# Use things from t/lib/
+use lib './lib';
+use strict;
+use warnings;
+use TieOut;
+use MakeMaker::Test::Utils qw(makefile_name);
+use File::Temp qw[tempdir];
+
+use ExtUtils::MakeMaker;
+use Test::More;
+
+my $tmpdir = tempdir( DIR => '.', CLEANUP => 1 );
+chdir $tmpdir;
+
+sub capture_make {
+    my ($package, $version) = @_ ;
+
+    my $warnings = '';
+    local $SIG{__WARN__} = sub {
+        $warnings .= join '', @_;
+    };
+
+    local $ENV{PERL_CORE} = 0;
+
+    WriteMakefile(
+        NAME      => 'VString::Test',
+        PREREQ_PM => { $package , $version }
+    );
+
+    return $warnings;
+}
+
+sub makefile_content {
+    open my $fh, '<', makefile_name or die;
+    return <$fh>;
+}
+
+# [ pkg, version, pattern, descrip, invertre ]
+my @DATA = (
+  [ DecimalString => '1.2.3', qr/isn't\s+numeric/, '3-part Decimal String' ],
+  [ VDecimalString => 'v1.2.3', qr/Unparsable\s+version/, '3-part V-Decimal String' ],
+  [ BareVString => v1.2.3, qr/Unparsable\s+version/, '3-part bare V-string' ],
+  [ VDecimalString => 'v1.2', qr/Unparsable\s+version/, '2-part v-decimal string' ],
+  [ BareVString => v1.2, qr/Unparsable\s+version/, '2-part bare v-string' ],
+  [ BrokenString => 'nan', qr/Unparsable\s+version/, 'random string', 1 ],
+);
+
+ok(my $stdout = tie *STDOUT, 'TieOut');
+for my $tuple (@DATA) {
+  my ($pkg, $version, $pattern, $descrip, $invertre) = @$tuple;
+  next if $] < 5.008 && $pkg eq 'BareVString' && $descrip =~ m!^2-part!;
+  my $out;
+  eval { $out = capture_make("Fake::$pkg" => $version); };
+  is($@, '', "$descrip not fatal");
+  if ($invertre) {
+    like ( $out , qr/$pattern/i, "$descrip parses");
+  } else {
+    unlike ( $out , qr/$pattern/i , "$descrip parses");
+  }
+#  note(join q{}, grep { $_ =~ /Fake/i } makefile_content);
+}
+
+done_testing();
index 0625960..d1b4d41 100644 (file)
@@ -8,6 +8,7 @@ BEGIN {
 }
 
 use strict;
+use Config;
 use Test::More tests => 43;
 
 use TieOut;
@@ -35,6 +36,11 @@ ok( chdir 'Big-Dummy', "chdir'd to Big-Dummy" ) ||
     ok( my $stdout = tie *STDOUT, 'TieOut' );
     my $warnings = '';
     local $SIG{__WARN__} = sub {
+        if ( $Config{usecrosscompile} ) {
+            # libraries might not be present on the target system
+            # when cross-compiling
+            return if $_[0] =~ /\A\QWarning (mostly harmless): No library found for \E.+/
+        }
         $warnings .= join '', @_;
     };
 
@@ -266,13 +272,13 @@ VERIFY
 
     # PERL_MM_OPT
     {
-      local $ENV{PERL_MM_OPT} = 'INSTALL_BASE="/Users/miyagawa/tmp/car1 foo/foo bar"';
+      local $ENV{PERL_MM_OPT} = 'INSTALL_BASE="/Users/miyagawa/tmp/car1  foo/foo bar"';
       $mm = WriteMakefile(
           NAME            => 'Big::Dummy',
           VERSION    => '1.00',
       );
 
-      is( $mm->{INSTALL_BASE}, "/Users/miyagawa/tmp/car1 foo/foo bar", 'parse_args() splits like shell' );
+      is( $mm->{INSTALL_BASE}, "/Users/miyagawa/tmp/car1  foo/foo bar", 'parse_args() splits like shell' );
     }
 
 }
index 81127f3..cdeb6dd 100644 (file)
@@ -13,9 +13,7 @@ use Test::More
     have_compiler()
     ? (tests => 5)
     : (skip_all => "ExtUtils::CBuilder not installed or couldn't find a compiler");
-use File::Find;
 use File::Spec;
-use File::Path;
 
 my $Is_VMS = $^O eq 'VMS';
 my $perl = which_perl();
@@ -36,15 +34,20 @@ ok( chdir('XS-Test'), "chdir'd to XS-Test" ) ||
   diag("chdir failed: $!");
 
 my @mpl_out = run(qq{$perl Makefile.PL});
-
-cmp_ok( $?, '==', 0, 'Makefile.PL exited with zero' ) ||
-  diag(@mpl_out);
-
-my $make = make_run();
-my $make_out = run("$make");
-is( $?, 0,                                 '  make exited normally' ) ||
-    diag $make_out;
-
-my $test_out = run("$make test");
-is( $?, 0,                                 '  make test exited normally' ) ||
-    diag $test_out;
+SKIP: {
+  unless (cmp_ok( $?, '==', 0, 'Makefile.PL exited with zero' )) {
+    diag(@mpl_out);
+    skip 'perl Makefile.PL failed', 2;
+  }
+
+  my $make = make_run();
+  my $make_out = run("$make");
+  unless (is( $?, 0, '  make exited normally' )) {
+      diag $make_out;
+      skip 'Make failed - skipping test', 1;
+  }
+
+  my $test_out = run("$make test");
+  is( $?, 0,                                 '  make test exited normally' ) ||
+      diag $test_out;
+}
index fb431f8..afae5a8 100644 (file)
@@ -1,7 +1,5 @@
 DB_File cpan/DB_File/DB_File.xs f364b661bbb0df075b0c425b104577e7176fe82b
 Digest::MD5 cpan/Digest-MD5/t/files.t bdbe05b705d9da305fedce7a9f4b6ba63250c7cf
-ExtUtils::MakeMaker cpan/ExtUtils-MakeMaker/lib/ExtUtils/Liblist/Kid.pm f738b4b8d6dfdb2bae5f3e43106370867aa88f01
-ExtUtils::MakeMaker cpan/ExtUtils-MakeMaker/t/pm_to_blib.t 2cd28c8279d7900e28962712763eaa4768117414
 IO::Socket::IP cpan/IO-Socket-IP/t/22timeout.t 0a65d4ca44663f70eea3c7f1ccb5faed2940611f
 PerlIO::via::QuotedPrint cpan/PerlIO-via-QuotedPrint/t/QuotedPrint.t ca39f0146e89de02c746e199c45dcb3e5edad691
 Socket cpan/Socket/t/getnameinfo.t f25ae4125d64a81538d4d3b73a3a0b9ce3c0404d