Changeset 8170 for inc

Timestamp:

12/11/05 02:54:59 (3 years ago)

Author:

pjf

Message:

General improvement of Win32/Cygwin GHC detection code.

* Makefile.PL::has_ghc_package() now requires a third argument, being

the 'ghc' command (with path if applicable).

In inc::Module::Install::Pugs:

* assert_ghc now goes looking for GHC on Win32/Cygwin systems.

This performs lexical sorting of version names, and will bite
us if part of a GHC version string contains a two-digits.

* assert_ghc_pkg now caches its findings, rather than re-searching

every time.

* assert_ghc_pkg doesn't trust can_run() on cygwin if we're clearly

trying to work with a Windows-land program. See
https://rt.cpan.org/Ticket/Display.html?id=16375 for details.

Files:

• inc/Module/Install/Pugs.pm (modified) (5 diffs)

inc/Module/Install/Pugs.pm

@@ -6 +6 @@
 use File::Basename;
 use IPC::Open3 'open3';
+use Carp;
 
 sub WritePugs {
@@ -168 +169 @@
     my $self = shift;
     my $ghc = $self->can_run($ENV{GHC} || ( 'ghc' . $Config{_exe} ) );
-    my $ghcver = `$ghc --version`;
-    ($ghcver =~ /Glasgow.*\bversion\s*(\S+)/s) or die << '.';
+
+    # This local subroutine returns the version of ghc passed to it.
+
+    my $test_ghc_ver = sub { 
+        (`$_[0] --version` =~ /Glasgow.*\bversion\s*(\S+)/s)[0]; 
+    };
+
+    my ($ghc_version) = $test_ghc_ver->($ghc);
+
+    if (!$ghc_version and (    $Config{osname} eq "cygwin" 
+                            or $Config{osname} eq "MSWin32"
+                          )
+       ) {
+
+        # Looks like we're on a Windows-ish system, without GHC
+        # in our path.   Let's hunt around for it.
+
+        my $ghc_root = "$ENV{SYSTEMDRIVE}/ghc";
+
+        warn "*** ghc not found in path.  Looking in $ghc_root\n";
+
+        if (-d $ghc_root) {
+            # Looks like we've found a GHC directory.  Find the latest
+            # ghc inside that.  Sorted from lexically highest to lowest.
+
+            # XXX - This will bite us should GHC contain a two-digit
+            #       revision.  Eg, 6.9.0 vs 6.10.0
+
+            my @ghc_choices = reverse glob(qq{$ghc_root/ghc-*});
+
+            GHC_TEST:
+            for my $ghc_dir (@ghc_choices) {
+                my $ghc_candidate = qq{$ghc_dir/bin/ghc.exe};
+                if ($ghc_version = $test_ghc_ver->($ghc_candidate)) {
+                    $ghc = $ghc_candidate;
+                    warn "*** Found $ghc\n";
+                }
+            }
+        }
+    }
+
+    $ghc_version or die << '.';
 *** Cannot find a runnable 'ghc' from path.
 *** Please install GHC from http://haskell.org/ghc/.
 .
 
-    my $ghc_version = $1;
     unless ($ghc_version =~ /^(\d)\.(\d+)/ and $1 >= 6 and $2 >= 4) {
         die << ".";
@@ -196 +236 @@
     chomp $ghc_flags;
 
-    return ($ghc, $ghc_version, $ghc_flags, $self->assert_ghc_pkg);
+    return ($ghc, $ghc_version, $ghc_flags, $self->assert_ghc_pkg($ghc));
 }
 
@@ -205 +245 @@
 }
 
+=head2 assert_ghc_pkg
+
+Assert that we have F<ghc_pkg> installed.  This caches its result,
+any further calls to ghc_pkg This method expects to
+be called with a path (relative, absolute, or a command in
+C<$ENV{PATH}> that can be used to execute F<ghc>.
+
+=cut
+
 sub assert_ghc_pkg {
     my $self = shift;
+
+    # Return immediately if we've cached this.
+    return $self->{ghc_pkg} if $self->{ghc_pkg};
+
+    my $ghc  = shift || $self->{ghc} 
+        or croak "assert_ghc_pkg not cached, and called without path to ghc";
+
     my $ghc_pkg = $ENV{GHC_PKG};
 
     unless($ghc_pkg) {
-        $ghc_pkg = ($ENV{GHC} || 'ghc');
+        $ghc_pkg = $ghc;
         $ghc_pkg =~ s/\bghc(?=[^\\\/]*$)/ghc-pkg/  # ghc-6.5 => ghc-pkg-6.5
             or $ghc_pkg = 'ghc-pkg'; # fallback if !/^ghc/
-        $ghc_pkg = $self->can_run($ghc_pkg) || $self->can_run('ghc-pkg');
+
+
+        my $ghc_exe = $self->can_run($ghc_pkg) || $self->can_run('ghc-pkg');
+
+        # This above fails under cygwin with a Win32-flavoured ghc-pkg.
+        # https://rt.cpan.org/Ticket/Display.html?id=16375 fixes this,
+        # but we can't rely upon everyone having it.  As such, we have
+        # a very special cygwin work-around.  Ugh!
+
+
+        if (not $ghc_exe and $Config{osname} eq 'cygwin') {
+
+            warn "*** ghc-pkg not found in path.  Testing $ghc_pkg\n";
+
+            # If the file exists, and it looks like it's in windows
+            # land, and it has an executable extension...
+
+            if ( -f $ghc_pkg 
+                and $ghc_pkg =~ m{^(?:/cygdrive|[A-Za-z]:)/.*$Config{_exe}$}
+            ) {
+
+                # Smells like a Windows executable called from cygwin-land.
+                # Keep it.
+
+                $ghc_exe = $ghc_pkg;
+
+            }
+        }
+
+        # Our ghc-pkg is whatever executable we've found (which could be
+        # undef, if we didn't find anything).
+
+        $ghc_pkg = $ghc_exe;
+
     }
 
@@ -219 +308 @@
         unless $ghc_pkg;
 
-    return $ghc_pkg;
+    return $self->{ghc_pkg} = $ghc_pkg;
 }