File Coverage

blib/lib/Module/Build/FFI.pm

Criterion	Covered	Total	%
statement	34	153	22.2
branch	2	58	3.4
condition	0	23	0.0
subroutine	12	23	52.1
pod	3	8	37.5
total	51	265	19.2

package Module::Build::FFI;

use strict;
use warnings;
use ExtUtils::CBuilder;
use File::Glob           qw( bsd_glob );
use File::Spec           ();
use File::ShareDir::Dist qw( dist_share );
use File::Path           ();
use Text::ParseWords     ();
use Config;
use base qw( Module::Build );

# ABSTRACT: (Deprecated) Build Perl extensions in C with FFI
our $VERSION = '0.54'; # VERSION


__PACKAGE__->add_property( ffi_libtest_dir =>
  default => [ 'libtest' ],
);

__PACKAGE__->add_property( ffi_include_dir =>
  default => [ 'include' ],
);

__PACKAGE__->add_property( ffi_libtest_optional =>
  default => 1,
);

__PACKAGE__->add_property( ffi_source_dir =>
  default => [ 'ffi' ],
);

sub _inflate ($)
{
  my($self) = @_;
  $self->ffi_source_dir([$self->ffi_source_dir])
    unless ref $self->ffi_source_dir;

  $self->ffi_libtest_dir([$self->ffi_libtest_dir])
    unless ref $self->ffi_libtest_dir;
}

sub new
{
  my($class, %args) = @_;

  my $self = $class->SUPER::new(%args);

  _inflate($self);
  my $have_compiler = $self->ffi_have_compiler;

  if(-d $self->ffi_source_dir->[0] && !$have_compiler)
  {
    print STDERR "This distribution requires a compiler\n";
    exit;
  }

  if(-d $self->ffi_libtest_dir->[0] && !$self->ffi_libtest_optional && !$have_compiler)
  {
    print STDERR "This distribution requires a compiler\n";
    exit;
  }

  $self;
}


my @cpp_extensions = qw( c cpp cxx cc c++ );

sub ffi_have_compiler
{
  my($self) = @_;

  my $cpp = 0;

  foreach my $dir (@{ $self->ffi_source_dir }, @{ $self->ffi_libtest_dir })
  {
    next unless -d $dir;
    $cpp = 1 if scalar map { bsd_glob("$dir/*.$_") } @cpp_extensions;
  }

  my $cb = $self->cbuilder;
  $cpp ? $cb->have_cplusplus && $cb->have_compiler : $cb->have_compiler;
}


sub _ffi_headers ($$)
{
  my($self, $dir) = @_;

  my @headers;

  my @dirs = @$dir;
  push @dirs, grep { -d $_ } ref $self->ffi_include_dir ? @{ $self->ffi_include_dir } : ($self->ffi_include_dir);

  push @headers, map { bsd_glob("$_/*.h") } @dirs;

  \@headers;
}

sub _share_dir
{
  dist_share('Module-Build-FFI') or die "unable to find dist share directory";
}

sub _ffi_include_dirs ($$)
{
  my($self, $dir) = @_;

  my @includes = (@$dir);

  push @includes, grep { -d $_ } ref $self->ffi_include_dir ? @{ $self->ffi_include_dir } : ($self->ffi_include_dir);

  push @includes, $ENV{FFI_PLATYPUS_INCLUDE_DIR} || File::Spec->catdir(_share_dir, 'include');

  push @includes, ref($self->include_dirs) ? @{ $self->include_dirs } : $self->include_dirs
    if defined $self->include_dirs;

  \@includes;
}


sub ffi_build_dynamic_lib ($$$;$)
{
  my($self, $dirs, $name, $dest_dir) = @_;

  $dest_dir ||= $dirs->[0];

  my $header_time = do {
    my @list = sort map { (stat $_)[9] } @{ _ffi_headers $self, $dirs };
    pop @list;
  } || 0;
  my $compile_count = 0;
  my $b = $self->cbuilder;

  my @obj;

  foreach my $dir (@$dirs)
  {
    push @obj,  map {
      my $filename = $_;
      my($source_time) = reverse sort ((stat $filename)[9], $header_time);
      my $obj_name = $b->object_file($filename);
      $self->add_to_cleanup($obj_name);
      my $obj_time = -e $obj_name ? ((stat $obj_name)[9]) : 0;

      my %compile_options = (
        source               => $filename,
        include_dirs         => _ffi_include_dirs($self, $dirs),
        extra_compiler_flags => $self->extra_compiler_flags,
      );
      $compile_options{"C++"} = 1 if $filename =~ /\.(cpp|cxx|cc|\c\+\+)$/;

      if($obj_time < $source_time)
      {
        $b->compile(%compile_options);
        $compile_count++;
      }
      $obj_name;
    } sort map { bsd_glob("$dir/*.$_") } qw( c cpp cxx cc c++ s );
  }

  return unless $compile_count > 0;

  if($^O ne 'MSWin32')
  {
    return $b->link(
      lib_file           => $b->lib_file(File::Spec->catfile($dest_dir, $b->object_file("$name.c"))),
      objects            => \@obj,
      extra_linker_flags => $self->extra_linker_flags,
    );
  }
  else
  {
    # On windows we can't depend on MM::CBuilder to make the .dll file because it creates dlls
    # that export only one symbol (which is used for bootstrapping XS modules).
    my $dll = File::Spec->catfile($dest_dir, "$name.dll");
    $dll =~ s{\\}{/}g;
    my @cmd;
    my $cc = $Config{cc};
    if($cc !~ /cl(.exe)?$/i)
    {
      my $lddlflags = $Config{lddlflags};
      $lddlflags =~ s{\\}{/}g;
      @cmd = ($cc, Text::ParseWords::shellwords($lddlflags), -o => $dll, "-Wl,--export-all-symbols", @obj);
    }
    else
    {
      @cmd = ($cc, @obj, '/link', '/dll', '/out:' . $dll);
    }
    print "@cmd\n";
    system @cmd;
    exit 2 if $?;
    return $dll;
  }
}


sub ffi_dlext
{
  if($^O eq 'darwin')
  { ('bundle', 'dylib', 'so' ) }
  else
  {
    require Config;
    $Config::Config{dlext};
  }
}

sub _ffi_libtest_name ()
{
  $^O eq 'cygwin' ? 'cygtest-1' : $^O eq 'msys' ? 'msys-test-1' : 'libtest';
}

sub ACTION_libtest
{
  my $self = shift;
  _inflate($self);
  my @dirs = @{ $self->ffi_libtest_dir };

  return unless -d $dirs[0];

  foreach my $dir (@dirs)
  {
    $self->add_to_cleanup(map { "$dir/$_" } qw(
      *.o
      *.obj
      *.so
      *.dll
      *.bundle
    ));
  }

  my $have_compiler = $self->ffi_have_compiler;

  unless($have_compiler)
  {
    print STDERR "libtest directory is included, but not compiler is available\n";
    print STDERR "some tests may fail if they depend on libtest\n";
    return;
  }

  $self->ffi_build_dynamic_lib(\@dirs, _ffi_libtest_name);
}

sub ACTION_ffi
{
  my $self = shift;
  _inflate($self);
  my @dirs = @{ $self->ffi_source_dir };

  return unless -d $dirs[0];

  foreach my $dir (@dirs)
  {
    $self->add_to_cleanup(map { "$dir/$_" } qw(
      *.o
      *.obj
      *.so
      *.dll
      *.bundle
    ));
  }

  unless($self->ffi_have_compiler)
  {
    print STDERR "a compiler is required.\n";
    exit 2;
  }

  die "Can't determine module name" unless $self->module_name;
  my @parts = split /::/, $self->module_name;

  my $arch_dir = File::Spec->catdir($self->blib, 'arch', 'auto', @parts);
  File::Path::mkpath($arch_dir, 0, oct(777)) unless -d $arch_dir;

  my $name = $parts[-1];
  # yes, of course Strawberry has to be "different"
  if($^O eq 'MSWin32' && $Config{dlext} eq 'xs.dll')
  {
    $name = "$name.xs";
  }

  $self->ffi_build_dynamic_lib(\@dirs, $name, $arch_dir);
}

sub ACTION_build
{
  my $self = shift;
  $self->depends_on('ffi');
  $self->SUPER::ACTION_build(@_);
}

sub ACTION_test
{
  my $self = shift;
  $self->depends_on('libtest');
  $self->SUPER::ACTION_test(@_);
}

1;

__END__