Alt-Math-Prime-FastSieve-Inline

 view release on metacpan or  search on metacpan

inc/ExtUtils/CppGuess.pm  view on Meta::CPAN

package ExtUtils::CppGuess;

use strict;
use warnings;

=head1 NAME

ExtUtils::CppGuess - guess C++ compiler and flags

=head1 SYNOPSIS

With L<Extutils::MakeMaker>:

    use ExtUtils::CppGuess;
    
    my $guess = ExtUtils::CppGuess->new;
    
    WriteMakefile
      ( # MakeMaker args,
        $guess->makemaker_options,
        );

With L<Module::Build>:

    my $guess = ExtUtils::CppGuess->new;
    
    my $build = Module::Build->new
      ( # Module::Build arguments
        $guess->module_build_options,
        );
    $build->create_build_script;

=head1 DESCRIPTION

C<ExtUtils::CppGuess> attempts to guess the system's C++ compiler
that is compatible with the C compiler that your perl was built with.

It can generate the necessary options to the L<Module::Build>
constructor or to L<ExtUtils::MakeMaker>'s C<WriteMakefile>
function.

=head1 METHODS

=head2 new

inc/ExtUtils/CppGuess.pm  view on Meta::CPAN

sub new {
    my( $class, %args ) = @_;
    my $self = bless {
      cc => $Config::Config{cc},
      %args
    }, $class;

    return $self;
}

sub guess_compiler {
    my( $self ) = @_;
    return $self->{guess} if $self->{guess};

    if( $^O =~ /^mswin/i ) {
        $self->_guess_win32() or return();
    } else {
        $self->_guess_unix() or return();
    }

    return $self->{guess};
}

sub _get_cflags {
    my( $self ) = @_;
    $self->guess_compiler || die;
    my $cflags = $self->{guess}{extra_cflags};
    $cflags .= ' ' . $self->{extra_compiler_flags}
      if defined $self->{extra_compiler_flags};
    return $cflags;
}

sub _get_lflags {
    my( $self ) = @_;
    $self->guess_compiler || die;
    my $lflags = $self->{guess}{extra_lflags};
    $lflags .= ' ' . $self->{extra_linker_flags}
      if defined $self->{extra_linker_flags};
    return $lflags;
}

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

    my $lflags = $self->_get_lflags;
    my $cflags = $self->_get_cflags;

inc/ExtUtils/CppGuess.pm  view on Meta::CPAN

    my( $self ) = @_;

    my $lflags = $self->_get_lflags;
    my $cflags = $self->_get_cflags;

    return ( extra_compiler_flags => $cflags,
             extra_linker_flags   => $lflags,
             );
}

sub _guess_win32 {
    my( $self ) = @_;
    my $c_compiler = $self->{cc};
    $c_compiler = $Config::Config{cc} if not defined $c_compiler;

    if( $self->_cc_is_gcc( $c_compiler ) ) {
        $self->{guess} = { extra_cflags => ' -xc++ ',
                           extra_lflags => ' -lstdc++ ',
                           };
    } elsif( $self->_cc_is_msvc( $c_compiler ) ) {
        $self->{guess} = { extra_cflags => ' -TP -EHsc ',
                           extra_lflags => ' msvcprt.lib ',
                           };
    } else {
        die "Unable to determine a C++ compiler for '$c_compiler'";
    }

    return 1;
}

sub _guess_unix {
    my( $self ) = @_;
    my $c_compiler = $self->{cc};
    $c_compiler = $Config::Config{cc} if not defined $c_compiler;

    if( !$self->_cc_is_gcc( $c_compiler ) ) {
        die "Unable to determine a C++ compiler for '$c_compiler'";
    }

    $self->{guess} = { extra_cflags => ' -xc++ ',
                       extra_lflags => ' -lstdc++ ',
                       };
    $self->{guess}{extra_cflags} .= ' -D_FILE_OFFSET_BITS=64' if $Config::Config{ccflags} =~ /-D_FILE_OFFSET_BITS=64/;
    $self->{guess}{extra_lflags} .= ' -lgcc_s' if $^O eq 'netbsd' && $self->{guess}{extra_lflags} !~ /-lgcc_s/;
    return 1;
}

# originally from Alien::wxWidgets::Utility

my $quotes = $^O =~ /MSWin32/ ? '"' : "'";

sub _capture {
    my @cmd = @_;
    my $out = capture_merged {

inc/ExtUtils/CppGuess.pm  view on Meta::CPAN

       )
    {
        $self->{is_gcc} = 1;
    }

    return $self->{is_gcc};
}

sub is_gcc {
    my( $self ) = @_;
    $self->guess_compiler || die;
    return $self->{is_gcc};
}

sub is_msvc {
    my( $self ) = @_;
    $self->guess_compiler || die;
    return $self->{is_msvc};
}

sub add_extra_compiler_flags {
    my( $self, $string ) = @_;
    $self->{extra_compiler_flags}
      = defined($self->{extra_compiler_flags})
        ? $self->{extra_compiler_flags} . ' ' . $string
        : $string;
}

inc/Inline/CPP/Config.pm  view on Meta::CPAN

# This module comes from Inline::Module share file: 'CPPConfig.pm'

use strict; use warnings;
package Inline::CPP::Config;

use Config;
use ExtUtils::CppGuess;

our ($compiler, $libs, $iostream_fn, $cpp_flavor_defs) = guess();

sub guess {
    my ($compiler, $libs, $iostream_fn, $cpp_flavor_defs);
    $iostream_fn = 'iostream';
    $cpp_flavor_defs = <<'.';
#define __INLINE_CPP_STANDARD_HEADERS 1
#define __INLINE_CPP_NAMESPACE_STD 1
.

    if ($Config::Config{osname} eq 'freebsd'
        && $Config::Config{osvers} =~ /^(\d+)/
        && $1 >= 10
    ) {
        $compiler = 'clang++';
        $libs = '-lc++';
    }
    else {
        my $guesser = ExtUtils::CppGuess->new;
        my %configuration = $guesser->module_build_options;
        if( $guesser->is_gcc ) {
            $compiler = 'g++';
        }
        elsif ( $guesser->is_msvc ) {
            $compiler = 'cl';
        }

        $compiler .= $configuration{extra_compiler_flags};
        $libs = $configuration{extra_linker_flags};

        ($compiler, $libs) = map {
            _trim_whitespace($_)
        } ($compiler, $libs);
    }