File Coverage

blib/lib/FFI/Build/Platform.pm

Criterion	Covered	Total	%
statement	161	200	80.5
branch	40	80	50.0
condition	15	38	39.4
subroutine	37	38	97.3
pod	23	23	100.0
total	276	379	72.8

package FFI::Build::Platform;

use strict;
use warnings;
use 5.008004;
use Carp ();
use Text::ParseWords ();
use FFI::Temp;
use Capture::Tiny ();
use File::Spec;
use FFI::Platypus::ShareConfig;

# ABSTRACT: Platform specific configuration.
our $VERSION = '2.07'; # VERSION


sub new
{
  my($class, $config) = @_;
  $config ||= do {
    require Config;
    \%Config::Config;
  };
  my $self = bless {
    config => $config,
  }, $class;
  $self;
}


my $default;
sub default
{
  $default ||= FFI::Build::Platform->new;
}

sub _self
{
  my($self) = @_;
  ref $self ? $self : $self->default;
}


sub osname
{
  _self(shift)->{config}->{osname};
}


sub object_suffix
{
  _self(shift)->{config}->{obj_ext};
}


sub library_suffix
{
  my $self = _self(shift);
  my $osname = $self->osname;
  my @suffix;
  if($osname eq 'darwin')
  {
    push @suffix, '.dylib', '.bundle';
  }
  elsif($osname =~ /^(MSWin32|msys|cygwin)$/)
  {
    push @suffix, '.dll';
  }
  else
  {
    push @suffix, '.' . $self->{config}->{dlext};
  }
  wantarray ? @suffix : $suffix[0];  ## no critic (Community::Wantarray)
}


sub library_prefix
{
  my $self = _self(shift);

  # this almost certainly requires refinement.
  if($self->osname eq 'cygwin')
  {
    return 'cyg';
  }
  elsif($self->osname eq 'msys')
  {
    return 'msys-';
  }
  elsif($self->osname eq 'MSWin32')
  {
    return '';
  }
  else
  {
    return 'lib';
  }
}


sub cc
{
  my $self = _self(shift);
  my $cc = $self->{config}->{cc};
  [$self->shellwords($cc)];
}


sub cpp
{
  my $self = _self(shift);
  my $cpp = $self->{config}->{cpprun};
  [$self->shellwords($cpp)];
}


sub cxx
{
  my $self = _self(shift);

  my @cc = @{ $self->cc };

  if($self->{config}->{ccname} eq 'gcc')
  {
    if($cc[0] =~ /gcc$/)
    {
      my @maybe = @cc;
      $maybe[0] =~ s/gcc$/g++/;
      return \@maybe if $self->which($maybe[0]);
    }
    if($cc[0] =~ /clang/)
    {
      my @maybe = @cc;
      $maybe[0] =~ s/clang/clang++/;
      return \@maybe if $self->which($maybe[0]);
    }

    # TODO: there are probably situations, eg solaris
    # where we don't want to try c++ in the case of
    # a ccname = gcc ?
    my @maybe = qw( c++ g++ clang++ );

    foreach my $maybe (@maybe)
    {
      return [$maybe] if $self->which($maybe);
    }
  }
  elsif($self->osname eq 'MSWin32' && $self->{config}->{ccname} eq 'cl')
  {
    # TODO: see https://github.com/PerlFFI/FFI-Platypus/issues/203
    #return \@cc;
  }

  Carp::croak("unable to detect corresponding C++ compiler");
}


sub cxxld
{
  my $self = _self(shift);

  $DB::single = 1;

  # This is definitely not exhaustive or complete or even
  # particularlly good.  Patches welcome.

  if($self->osname eq 'darwin')
  {
    my @cxx = @{ $self->cxx };
    return [map { /^(cc|clang|gcc)$/ ? @cxx : $_ } @{ $self->ld }];
  }
  else
  {
    return $self->cxx;
  }
}


sub for
{
  my $self = _self(shift);

  my @cc = @{ $self->cc };

  if($self->{config}->{ccname} eq 'gcc')
  {
    if($cc[0] =~ /gcc$/)
    {
      my @maybe = @cc;
      $maybe[0] =~ s/gcc$/gfortran/;
      return \@maybe if $self->which($maybe[0]);
    }

    foreach my $maybe (qw( gfortran ))
    {
      return [$maybe] if $self->which($maybe);
    }
  }
  else
  {
    Carp::croak("unable to detect correspnding Fortran Compiler");
  }
}


sub ld
{
  my($self) = @_;
  my $ld = $self->{config}->{ld};
  [$self->shellwords($ld)];
}


sub shellwords
{
  my $self = _self(shift);

  my $win = !!($self->osname eq 'MSWin32');

  grep { defined $_ } map {
    ref $_
      # if we have an array ref then it has already been shellworded
      ? @$_
      : do {
        # remove leading whitespace, confuses some older versions of shellwords
        my $str = /^\s*(.*)$/ && $1;
        # escape things on windows
        $str =~ s,\\,\\\\,g if $win;
        Text::ParseWords::shellwords($str);
      }
  } @_;

}


sub ccflags
{
  my $self = _self(shift);
  my @ccflags;
  push @ccflags, $self->shellwords($self->{config}->{cccdlflags});
  push @ccflags, $self->shellwords($self->{config}->{ccflags});
  push @ccflags, $self->shellwords($self->{config}->{optimize});
  my $dist_include = eval { File::Spec->catdir(FFI::Platypus::ShareConfig::dist_dir('FFI-Platypus'), 'include') };
  push @ccflags, "-I$dist_include" unless $@;
  \@ccflags;
}


sub ldflags
{
  my $self = _self(shift);
  my @ldflags = $self->shellwords($self->{config}->{lddlflags});
  if($self->osname eq 'cygwin')
  {
    no warnings 'qw';
    # doesn't appear to be necessary, Perl has this in lddlflags already on cygwin
    #push @ldflags, qw( -Wl,--enable-auto-import -Wl,--export-all-symbols -Wl,--enable-auto-image-base );
  }
  elsif($self->osname eq 'MSWin32' && $self->{config}->{ccname} eq 'cl')
  {
    push @ldflags, qw( -dll );
    @ldflags = grep !/^-nodefaultlib$/, @ldflags;
  }
  elsif($self->osname eq 'MSWin32')
  {
    no warnings 'qw';
    push @ldflags, qw( -Wl,--enable-auto-import -Wl,--export-all-symbols -Wl,--enable-auto-image-base );
  }
  elsif($self->osname eq 'darwin')
  {
    # we want to build a .dylib instead of a .bundle
    @ldflags = map { $_ eq '-bundle' ? '-dynamiclib' : $_ } @ldflags;
  }
  \@ldflags;
}


sub cc_mm_works
{
  my $self = _self(shift);
  my $verbose = shift;
  $verbose ||= 0;

  unless(defined $self->{cc_mm_works})
  {
    require FFI::Build::File::C;
    my $c = FFI::Build::File::C->new(\"#include \"foo.h\"\n");
    my $dir = FFI::Temp->newdir;
    {
      open my $fh, '>', "$dir/foo.h";
      print $fh "\n";
      close $fh;
    }

    my @cmd = (
      $self->cc,
      $self->ccflags,
      "-I$dir",
      '-MM',
      $c->path,
    );

    my($out, $exit) = Capture::Tiny::capture_merged(sub {
      $self->run(@cmd);
    });

    if($verbose >= 2)
    {
      print $out;
    }
    elsif($verbose >= 1)
    {
      print "CC (checkfor -MM)\n";
    }


    if(!$exit && $out =~ /foo\.h/)
    {
      $self->{cc_mm_works} = '-MM';
    }
    else
    {
      $self->{cc_mm_works} = 0;
    }
  }

  $self->{cc_mm_works};
}


sub flag_object_output
{
  my $self = _self(shift);
  my $file = shift;
  if($self->osname eq 'MSWin32' && $self->{config}->{ccname} eq 'cl')
  {
    return ("-Fo$file");
  }
  else
  {
    return ('-o' => $file);
  }
}


sub flag_library_output
{
  my $self = _self(shift);
  my $file = shift;
  if($self->osname eq 'MSWin32' && $self->{config}->{ccname} eq 'cl')
  {
    return ("-OUT:$file");
  }
  elsif($self->osname eq 'darwin')
  {
    return ('-install_name' => "\@rpath/$file", -o => $file);
  }
  else
  {
    return ('-o' => $file);
  }
}


sub flag_exe_output
{
  my $self = _self(shift);
  my $file = shift;
  if($self->osname eq 'MSWin32' && $self->{config}->{ccname} eq 'cl')
  {
    my $file = File::Spec->rel2abs($file);
    return ("/Fe:$file");
  }
  else
  {
    return ('-o' => $file);
  }
}


sub flag_export
{
  my $self = _self(shift);
  return () unless $self->osname eq 'MSWin32' && $self->{config}->{ccname} eq 'cl';
  return map { "/EXPORT:$_" } @_;
}


sub which
{
  my(undef, $command) = @_;
  require IPC::Cmd;
  my @command = ref $command ? @$command : ($command);
  IPC::Cmd::can_run($command[0]);
}


sub run
{
  my $self = shift;
  my @command  = map { ref $_ ? @$_ : $_ } grep { defined $_ } @_;
  print "+@command\n";
  system @command;
  $?;
}


sub _c { join ',', @_ }
sub _l { join ' ', map { ref $_ ? @$_ : $_ } @_ }

sub diag
{
  my $self = _self(shift);
  my @diag;

  push @diag, "osname            : ". _c($self->osname);
  push @diag, "cc                : ". _l($self->cc);
  push @diag, "cxx               : ". (eval { _l($self->cxx) } || '---' );
  push @diag, "cxxld             : ". (eval { _l($self->cxxld) } || '---' );
  push @diag, "for               : ". (eval { _l($self->for) } || '---' );
  push @diag, "ld                : ". _l($self->ld);
  push @diag, "ccflags           : ". _l($self->ccflags);
  push @diag, "ldflags           : ". _l($self->ldflags);
  push @diag, "object suffix     : ". _c($self->object_suffix);
  push @diag, "library prefix    : ". _c($self->library_prefix);
  push @diag, "library suffix    : ". _c($self->library_suffix);
  push @diag, "cc mm works       : ". $self->cc_mm_works;

  join "\n", @diag;
}

1;

__END__