fill out documentation

[imager.git] / lib / Imager / Probe.pm

diff --git a/lib/Imager/Probe.pm b/lib/Imager/Probe.pm
index b333c22c542513a81d71313f310ceca875299cbc..444ce6dba7fdc37591cfe05932e1a589009e6923 100644 (file)
--- a/lib/Imager/Probe.pm
+++ b/lib/Imager/Probe.pm
@@ -2,6 +2,7 @@ package Imager::Probe;
 use strict;
 use File::Spec;
 use Config;
 use strict;
 use File::Spec;
 use Config;

+use Cwd ();

 
 my @alt_transfer = qw/altname incsuffix libbase/;
 
 
 my @alt_transfer = qw/altname incsuffix libbase/;
 


@@ -22,29 +23,40 @@ sub probe {
     $req->{altname} ||= "main";
     $result = _probe_check($req);
   }
     $req->{altname} ||= "main";
     $result = _probe_check($req);
   }

+
+  if ($result && $req->{testcode}) {
+    $result = _probe_test($req, $result);
+  }
+

   if (!$result && $req->{alternatives}) {
   ALTCHECK:
     my $index = 1;
     for my $alt (@{$req->{alternatives}}) {
   if (!$result && $req->{alternatives}) {
   ALTCHECK:
     my $index = 1;
     for my $alt (@{$req->{alternatives}}) {

-      $req->{altname} ||= "alt $index";
+      $req->{altname} = $alt->{altname} || "alt $index";

       $req->{verbose}
        and print "$req->{name}: Trying alternative $index\n";
       my %work = %$req;
       for my $key (@alt_transfer) {
        exists $alt->{$key} and $work{$key} = $alt->{$key};
       }
       $req->{verbose}
        and print "$req->{name}: Trying alternative $index\n";
       my %work = %$req;
       for my $key (@alt_transfer) {
        exists $alt->{$key} and $work{$key} = $alt->{$key};
       }

-      $result = _probe_check(\%work)
+      $result = _probe_check(\%work);
+
+      if ($result && $req->{testcode}) {
+       $result = _probe_test(\%work, $result);
+      }
+
+      $result

        and last;
        and last;

+

       ++$index;
     }
   }
 
   if (!$result && $req->{testcode}) {
     $result = _probe_fake($req);
       ++$index;
     }
   }
 
   if (!$result && $req->{testcode}) {
     $result = _probe_fake($req);

-  }
-  $result or return;

 
 

-  if ($req->{testcode}) {
+    $result or return;
+

     $result = _probe_test($req, $result);
   }
 
     $result = _probe_test($req, $result);
   }
 


@@ -110,13 +122,37 @@ sub _probe_pkg {
       my $lflags = `pkg-config $pkg --libs`
        and !$? or return;
 
       my $lflags = `pkg-config $pkg --libs`
        and !$? or return;
 

+      my $defines = '';
+      $cflags =~ s/(-D\S+)/$defines .= " $1"; ''/ge;
+

       chomp $cflags;
       chomp $lflags;
       print "$req->{name}: Found via pkg-config $pkg\n";
       chomp $cflags;
       chomp $lflags;
       print "$req->{name}: Found via pkg-config $pkg\n";

+      print <<EOS if $req->{verbose};
+  cflags: $cflags
+  defines: $defines
+  lflags: $lflags
+EOS
+      # rt 75869
+      # if Win32 doesn't provide this information, too bad
+      if (!grep(/^-L/, split " ", $lflags)
+         && $^O ne 'MSWin32') {
+       # pkg-config told us about the library, make sure it's
+       # somewhere EU::MM can find it
+       print "Checking if EU::MM can find $lflags\n" if $req->{verbose};
+       my ($extra, $bs_load, $ld_load, $ld_run_path) =
+         ExtUtils::Liblist->ext($lflags, $req->{verbose});
+       unless ($ld_run_path) {
+         # search our standard places
+         $lflags = _resolve_libs($req, $lflags);
+       }
+      }
+

       return
        {
         INC => $cflags,
         LIBS => $lflags,
       return
        {
         INC => $cflags,
         LIBS => $lflags,

+        DEFINE => $defines,

        };
     }
   }
        };
     }
   }


@@ -126,31 +162,83 @@ sub _probe_pkg {
   return;
 }
 
   return;
 }
 

+sub _is_msvc {
+  return $Config{cc} eq "cl";
+}
+
+sub _lib_basename {
+  my ($base) = @_;
+
+  if (_is_msvc()) {
+    return $base;
+  }
+  else {
+    return "lib$base";
+  }
+}
+
+sub _lib_option {
+  my ($base) = @_;
+
+  if (_is_msvc()) {
+    return $base . $Config{_a};
+  }
+  else {
+    return "-l$base";
+  }
+}
+
+sub _quotearg {
+  my ($opt) = @_;
+
+  return $opt =~ /\s/ ? qq("$opt") : $opt;
+}
+

 sub _probe_check {
   my ($req) = @_;
 
 sub _probe_check {
   my ($req) = @_;
 

-  my $libcheck = $req->{libcheck};
-  my $libbase = $req->{libbase};
-  if (!$libcheck && $req->{libbase}) {
-    # synthesize a libcheck
+  my @libcheck;
+  my @libbase;
+  if ($req->{libcheck}) {
+    if (ref $req->{libcheck} eq "ARRAY") {
+      push @libcheck, @{$req->{libcheck}};
+    }
+    else {
+      push @libcheck, $req->{libcheck};
+    }
+  }
+  elsif ($req->{libbase}) {
+    @libbase = ref $req->{libbase} ? @{$req->{libbase}} : $req->{libbase};
+

     my $lext=$Config{'so'};   # Get extensions of libraries
     my $aext=$Config{'_a'};
     my $lext=$Config{'so'};   # Get extensions of libraries
     my $aext=$Config{'_a'};

-    $libcheck = sub {
-      -e File::Spec->catfile($_[0], "lib$libbase$aext")
-       || -e File::Spec->catfile($_[0], "lib$libbase.$lext")
-      };
+
+    for my $libbase (@libbase) {
+      my $basename = _lib_basename($libbase);
+      push @libcheck, sub {
+       -e File::Spec->catfile($_[0], "$basename$aext")
+         || -e File::Spec->catfile($_[0], "$basename.$lext")
+       };
+    }
+  }
+  else {
+    print "$req->{name}: No libcheck or libbase, nothing to search for\n"
+      if $req->{verbose};
+    return;

   }
 
   }
 

-  my $found_libpath;
+  my @found_libpath;

   my @lib_search = _lib_paths($req);
   print "$req->{name}: Searching directories for libraries:\n"
     if $req->{verbose};
   my @lib_search = _lib_paths($req);
   print "$req->{name}: Searching directories for libraries:\n"
     if $req->{verbose};

-  for my $path (@lib_search) {
-    print "$req->{name}:   $path\n" if $req->{verbose};
-    if ($libcheck->($path)) {
-      print "$req->{name}: Found!\n" if $req->{verbose};
-      $found_libpath = $path;
-      last;
+  for my $libcheck (@libcheck) {
+    for my $path (@lib_search) {
+      print "$req->{name}:   $path\n" if $req->{verbose};
+      if ($libcheck->($path)) {
+       print "$req->{name}: Found!\n" if $req->{verbose};
+        push @found_libpath, $path;
+       last;
+      }

     }
   }
 
     }
   }
 


@@ -169,30 +257,31 @@ sub _probe_check {
   }
 
   my $alt = "";
   }
 
   my $alt = "";

-  if ($req->{alternatives}) {
+  if ($req->{altname}) {

     $alt = " $req->{altname}:";
   }
   print "$req->{name}:$alt includes ", $found_incpath ? "" : "not ",
     $alt = " $req->{altname}:";
   }
   print "$req->{name}:$alt includes ", $found_incpath ? "" : "not ",

-    "found - libraries ", $found_libpath ? "" : "not ", "found\n";
+    "found - libraries ", @found_libpath == @libcheck ? "" : "not ", "found\n";

 
 

-  $found_libpath && $found_incpath
+  @found_libpath == @libcheck && $found_incpath

     or return;
 
     or return;
 

-  my @libs = "-L$found_libpath";
+  my @libs = map "-L$_", @found_libpath;

   if ($req->{libopts}) {
     push @libs, $req->{libopts};
   }
   if ($req->{libopts}) {
     push @libs, $req->{libopts};
   }

-  elsif ($libbase) {
-    push @libs, "-l$libbase";
+  elsif (@libbase) {
+    push @libs, map _lib_option($_), @libbase;

   }
   else {
   }
   else {

-    die "$req->{name}: inccheck but no libbase or libopts";
+    die "$req->{altname}: inccheck but no libbase or libopts";

   }
 
   return
     {
   }
 
   return
     {

-     INC => "-I$found_incpath",
-     LIBS => "@libs",
+     INC => _quotearg("-I$found_incpath"),
+     LIBS => join(" ", map _quotearg($_), @libs),
+     DEFINE => "",

     };
 }
 
     };
 }
 


@@ -212,11 +301,12 @@ sub _probe_fake {
     $lopts = $req->{libbase} ? "-l$req->{libbase}" : "";
   }
   if (defined $lopts) {
     $lopts = $req->{libbase} ? "-l$req->{libbase}" : "";
   }
   if (defined $lopts) {

-    print "$req->{name}: Checking if the compiler can find them on it's own\n";
+    print "$req->{name}: Checking if the compiler can find them on its own\n";

     return
       {
        INC => "",
        LIBS => $lopts,
     return
       {
        INC => "",
        LIBS => $lopts,

+       DEFINE => "",

       };
   }
   else {
       };
   }
   else {


@@ -231,6 +321,7 @@ sub _probe_test {
 
   require Devel::CheckLib;
   # setup LD_RUN_PATH to match link time
 
   require Devel::CheckLib;
   # setup LD_RUN_PATH to match link time

+  print "Asking liblist for LD_RUN_PATH:\n" if $req->{verbose};

   my ($extra, $bs_load, $ld_load, $ld_run_path) =
     ExtUtils::Liblist->ext($result->{LIBS}, $req->{verbose});
   local $ENV{LD_RUN_PATH};
   my ($extra, $bs_load, $ld_load, $ld_run_path) =
     ExtUtils::Liblist->ext($result->{LIBS}, $req->{verbose});
   local $ENV{LD_RUN_PATH};


@@ -239,6 +330,15 @@ sub _probe_test {
     print "Setting LD_RUN_PATH=$ld_run_path for $req->{name} probe\n"
       if $req->{verbose};
     $ENV{LD_RUN_PATH} = $ld_run_path;
     print "Setting LD_RUN_PATH=$ld_run_path for $req->{name} probe\n"
       if $req->{verbose};
     $ENV{LD_RUN_PATH} = $ld_run_path;

+    if ($Config{lddlflags} =~ /([^ ]*-(?:rpath|R)[,=]?)([^ ]+)/
+       && -d $2) {
+      # hackety, hackety
+      # LD_RUN_PATH is ignored when there's already an -rpath option
+      # so provide one
+      my $prefix = $1;
+      $result->{LDDLFLAGS} = $Config{lddlflags} . " " .
+       join " ", map "$prefix$_", split $Config{path_sep}, $ld_run_path;
+    }

   }
   my $good =
     Devel::CheckLib::check_lib
   }
   my $good =
     Devel::CheckLib::check_lib


@@ -248,6 +348,7 @@ sub _probe_test {
         INC => $result->{INC},
         header => $req->{testcodeheaders},
         function => $req->{testcode},
         INC => $result->{INC},
         header => $req->{testcodeheaders},
         function => $req->{testcode},

+        prologue => $req->{testcodeprologue},

        );
   unless ($good) {
     print "$req->{name}: Test code failed: $@";
        );
   unless ($good) {
     print "$req->{name}: Test code failed: $@";


@@ -258,6 +359,27 @@ sub _probe_test {
   return $result;
 }
 
   return $result;
 }
 

+sub _resolve_libs {
+  my ($req, $lflags) = @_;
+
+  my @libs = grep /^-l/, split ' ', $lflags;
+  my %paths;
+  my @paths = _lib_paths($req);
+  my $so = $Config{so};
+  my $libext = $Config{_a};
+  for my $lib (@libs) {
+    $lib =~ s/^-l/lib/;
+
+    for my $path (@paths) {
+      if (-e "$path/$lib.$so" || -e "$path/$lib$libext") {
+       $paths{$path} = 1;
+      }
+    }
+  }
+
+  return join(" ", ( map "-L$_", keys %paths ), $lflags );
+}
+

 sub _lib_paths {
   my ($req) = @_;
 
 sub _lib_paths {
   my ($req) = @_;
 


@@ -274,9 +396,28 @@ sub _lib_paths {
      $^O eq "cygwin" ? "/usr/lib/w32api" : "",
      "/usr/lib",
      "/usr/local/lib",
      $^O eq "cygwin" ? "/usr/lib/w32api" : "",
      "/usr/lib",
      "/usr/local/lib",

+     _gcc_lib_paths(),

     );
 }
 
     );
 }
 

+sub _gcc_lib_paths {
+  $Config{gccversion}
+    or return;
+
+  my ($base_version) = $Config{gccversion} =~ /^([0-9]+)/
+    or return;
+
+  $base_version >= 4
+    or return;
+
+  my ($lib_line) = grep /^libraries:/, `$Config{cc} -print-search-dirs`
+    or return;
+  $lib_line =~ s/^libraries: =//;
+  chomp $lib_line;
+
+  return grep !/gcc/ && -d, split /:/, $lib_line;
+}
+

 sub _inc_paths {
   my ($req) = @_;
 
 sub _inc_paths {
   my ($req) = @_;
 


@@ -307,6 +448,9 @@ sub _paths {
 
   my @out;
 
 
   my @out;
 

+  # expand any array refs
+  @in = map { ref() ? @$_ : $_ } @in;
+

   for my $path (@in) {
     $path or next;
     $path = _tilde_expand($path);
   for my $path (@in) {
     $path or next;
     $path = _tilde_expand($path);


@@ -314,6 +458,11 @@ sub _paths {
     push @out, grep -d $_, split /\Q$Config{path_sep}/, $path;
   }
 
     push @out, grep -d $_, split /\Q$Config{path_sep}/, $path;
   }
 

+  @out = map Cwd::realpath($_), @out;
+
+  my %seen;
+  @out = grep !$seen{$_}++, @out;
+

   return @out;
 }
 
   return @out;
 }
 


@@ -391,6 +540,10 @@ C<INC> - C<-I> and other C options
 
 C<LIBS> - C<-L>, C<-l> and other link-time options
 
 
 C<LIBS> - C<-L>, C<-l> and other link-time options
 

+=item *
+
+C<DEFINE> - C<-D> options, if any.
+

 =back
 
 The possible values for the hash supplied to the probe() method are:
 =back
 
 The possible values for the hash supplied to the probe() method are:


@@ -412,14 +565,19 @@ directory contains the required header files.
 C<libcheck> - a code reference that checks if the supplied library
 directory contains the required library files.  Note: the
 F<Makefile.PL> version of this was supplied all of the library file
 C<libcheck> - a code reference that checks if the supplied library
 directory contains the required library files.  Note: the
 F<Makefile.PL> version of this was supplied all of the library file

-names instead.
+names instead.  C<libcheck> can also be an arrayref of library check
+code references, all of which must find a match for the library to be
+considered "found".

 
 =item *
 
 C<libbase> - if C<inccheck> is supplied, but C<libcheck> isn't, then a
 C<libcheck> that checks for C<lib>I<libbase>I<$Config{_a}> and
 C<lib>I<libbase>.I<$Config{so}> is created.  If C<libopts> isn't
 
 =item *
 
 C<libbase> - if C<inccheck> is supplied, but C<libcheck> isn't, then a
 C<libcheck> that checks for C<lib>I<libbase>I<$Config{_a}> and
 C<lib>I<libbase>.I<$Config{so}> is created.  If C<libopts> isn't

-supplied then that can be synthesized as C<-l>C<<I<libbase>>>.
+supplied then that can be synthesized as C<< -lI<libbase>
+>>. C<libbase> can also be an arrayref of library base names to search
+for, in which case all of the libraries mentioned must be found for
+the probe to succeed.

 
 =item *
 
 
 =item *
 


@@ -438,13 +596,26 @@ need to set C<testcodeheaders>.
 
 =item *
 
 
 =item *
 

+C<testcodeprologue> - C code to insert between the headers and the
+main function.
+
+=item *
+

 C<incpath> - C<$Config{path_sep}> separated list of header file
 C<incpath> - C<$Config{path_sep}> separated list of header file

-directories to check.
+directories to check, or a reference to an array of such.

 
 =item *
 
 C<libpath> - C<$Config{path_sep}> separated list of library file
 
 =item *
 
 C<libpath> - C<$Config{path_sep}> separated list of library file

-directories to check.
+directories to check, or a reference to an array of such.
+
+=item *
+
+C<alternatives> - an optional array reference of alternate
+configurations (as hash references) to test if the primary
+configuration isn't successful.  Each alternative should include an
+C<altname> key describing the alternative.  Any key not mentioned in
+an alternative defaults to the value from the main configuration.

 
 =back
 
 
 =back