3417 lines
106 KiB
Perl
3417 lines
106 KiB
Perl
# $Id$
|
|
package ExtUtils::MakeMaker;
|
|
|
|
use strict;
|
|
|
|
BEGIN {require 5.006;}
|
|
|
|
require Exporter;
|
|
use ExtUtils::MakeMaker::Config;
|
|
use ExtUtils::MakeMaker::version; # ensure we always have our fake version.pm
|
|
use Carp;
|
|
use File::Path;
|
|
my $CAN_DECODE = eval { require ExtUtils::MakeMaker::Locale; }; # 2 birds, 1 stone
|
|
eval { ExtUtils::MakeMaker::Locale::reinit('UTF-8') }
|
|
if $CAN_DECODE and Encode::find_encoding('locale')->name eq 'ascii';
|
|
|
|
our $Verbose = 0; # exported
|
|
our @Parent; # needs to be localized
|
|
our @Get_from_Config; # referenced by MM_Unix
|
|
our @MM_Sections;
|
|
our @Overridable;
|
|
my @Prepend_parent;
|
|
my %Recognized_Att_Keys;
|
|
our %macro_fsentity; # whether a macro is a filesystem name
|
|
our %macro_dep; # whether a macro is a dependency
|
|
|
|
our $VERSION = '7.34';
|
|
$VERSION = eval $VERSION; ## no critic [BuiltinFunctions::ProhibitStringyEval]
|
|
|
|
# Emulate something resembling CVS $Revision$
|
|
(our $Revision = $VERSION) =~ s{_}{};
|
|
$Revision = int $Revision * 10000;
|
|
|
|
our $Filename = __FILE__; # referenced outside MakeMaker
|
|
|
|
our @ISA = qw(Exporter);
|
|
our @EXPORT = qw(&WriteMakefile $Verbose &prompt &os_unsupported);
|
|
our @EXPORT_OK = qw($VERSION &neatvalue &mkbootstrap &mksymlists
|
|
&WriteEmptyMakefile &open_for_writing &write_file_via_tmp
|
|
&_sprintf562);
|
|
|
|
# These will go away once the last of the Win32 & VMS specific code is
|
|
# purged.
|
|
my $Is_VMS = $^O eq 'VMS';
|
|
my $Is_Win32 = $^O eq 'MSWin32';
|
|
our $UNDER_CORE = $ENV{PERL_CORE}; # needs to be our
|
|
|
|
full_setup();
|
|
|
|
require ExtUtils::MM; # Things like CPAN assume loading ExtUtils::MakeMaker
|
|
# will give them MM.
|
|
|
|
require ExtUtils::MY; # XXX pre-5.8 versions of ExtUtils::Embed expect
|
|
# loading ExtUtils::MakeMaker will give them MY.
|
|
# This will go when Embed is its own CPAN module.
|
|
|
|
|
|
# 5.6.2 can't do sprintf "%1$s" - this can only do %s
|
|
sub _sprintf562 {
|
|
my ($format, @args) = @_;
|
|
for (my $i = 1; $i <= @args; $i++) {
|
|
$format =~ s#%$i\$s#$args[$i-1]#g;
|
|
}
|
|
$format;
|
|
}
|
|
|
|
sub WriteMakefile {
|
|
croak "WriteMakefile: Need even number of args" if @_ % 2;
|
|
|
|
require ExtUtils::MY;
|
|
my %att = @_;
|
|
|
|
_convert_compat_attrs(\%att);
|
|
|
|
_verify_att(\%att);
|
|
|
|
my $mm = MM->new(\%att);
|
|
$mm->flush;
|
|
|
|
return $mm;
|
|
}
|
|
|
|
|
|
# Basic signatures of the attributes WriteMakefile takes. Each is the
|
|
# reference type. Empty value indicate it takes a non-reference
|
|
# scalar.
|
|
my %Att_Sigs;
|
|
my %Special_Sigs = (
|
|
AUTHOR => 'ARRAY',
|
|
C => 'ARRAY',
|
|
CONFIG => 'ARRAY',
|
|
CONFIGURE => 'CODE',
|
|
DIR => 'ARRAY',
|
|
DL_FUNCS => 'HASH',
|
|
DL_VARS => 'ARRAY',
|
|
EXCLUDE_EXT => 'ARRAY',
|
|
EXE_FILES => 'ARRAY',
|
|
FUNCLIST => 'ARRAY',
|
|
H => 'ARRAY',
|
|
IMPORTS => 'HASH',
|
|
INCLUDE_EXT => 'ARRAY',
|
|
LIBS => ['ARRAY',''],
|
|
MAN1PODS => 'HASH',
|
|
MAN3PODS => 'HASH',
|
|
META_ADD => 'HASH',
|
|
META_MERGE => 'HASH',
|
|
OBJECT => ['ARRAY', ''],
|
|
PL_FILES => 'HASH',
|
|
PM => 'HASH',
|
|
PMLIBDIRS => 'ARRAY',
|
|
PMLIBPARENTDIRS => 'ARRAY',
|
|
PREREQ_PM => 'HASH',
|
|
BUILD_REQUIRES => 'HASH',
|
|
CONFIGURE_REQUIRES => 'HASH',
|
|
TEST_REQUIRES => 'HASH',
|
|
SKIP => 'ARRAY',
|
|
TYPEMAPS => 'ARRAY',
|
|
XS => 'HASH',
|
|
XSBUILD => 'HASH',
|
|
VERSION => ['version',''],
|
|
_KEEP_AFTER_FLUSH => '',
|
|
|
|
clean => 'HASH',
|
|
depend => 'HASH',
|
|
dist => 'HASH',
|
|
dynamic_lib=> 'HASH',
|
|
linkext => 'HASH',
|
|
macro => 'HASH',
|
|
postamble => 'HASH',
|
|
realclean => 'HASH',
|
|
test => 'HASH',
|
|
tool_autosplit => 'HASH',
|
|
);
|
|
|
|
@Att_Sigs{keys %Recognized_Att_Keys} = ('') x keys %Recognized_Att_Keys;
|
|
@Att_Sigs{keys %Special_Sigs} = values %Special_Sigs;
|
|
|
|
sub _convert_compat_attrs { #result of running several times should be same
|
|
my($att) = @_;
|
|
if (exists $att->{AUTHOR}) {
|
|
if ($att->{AUTHOR}) {
|
|
if (!ref($att->{AUTHOR})) {
|
|
my $t = $att->{AUTHOR};
|
|
$att->{AUTHOR} = [$t];
|
|
}
|
|
} else {
|
|
$att->{AUTHOR} = [];
|
|
}
|
|
}
|
|
}
|
|
|
|
sub _verify_att {
|
|
my($att) = @_;
|
|
|
|
foreach my $key (sort keys %$att) {
|
|
my $val = $att->{$key};
|
|
my $sig = $Att_Sigs{$key};
|
|
unless( defined $sig ) {
|
|
warn "WARNING: $key is not a known parameter.\n";
|
|
next;
|
|
}
|
|
|
|
my @sigs = ref $sig ? @$sig : $sig;
|
|
my $given = ref $val;
|
|
unless( grep { _is_of_type($val, $_) } @sigs ) {
|
|
my $takes = join " or ", map { _format_att($_) } @sigs;
|
|
|
|
my $has = _format_att($given);
|
|
warn "WARNING: $key takes a $takes not a $has.\n".
|
|
" Please inform the author.\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
# Check if a given thing is a reference or instance of $type
|
|
sub _is_of_type {
|
|
my($thing, $type) = @_;
|
|
|
|
return 1 if ref $thing eq $type;
|
|
|
|
local $SIG{__DIE__};
|
|
return 1 if eval{ $thing->isa($type) };
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
sub _format_att {
|
|
my $given = shift;
|
|
|
|
return $given eq '' ? "string/number"
|
|
: uc $given eq $given ? "$given reference"
|
|
: "$given object"
|
|
;
|
|
}
|
|
|
|
|
|
sub prompt ($;$) { ## no critic
|
|
my($mess, $def) = @_;
|
|
confess("prompt function called without an argument")
|
|
unless defined $mess;
|
|
|
|
my $isa_tty = -t STDIN && (-t STDOUT || !(-f STDOUT || -c STDOUT)) ;
|
|
|
|
my $dispdef = defined $def ? "[$def] " : " ";
|
|
$def = defined $def ? $def : "";
|
|
|
|
local $|=1;
|
|
local $\;
|
|
print "$mess $dispdef";
|
|
|
|
my $ans;
|
|
if ($ENV{PERL_MM_USE_DEFAULT} || (!$isa_tty && eof STDIN)) {
|
|
print "$def\n";
|
|
}
|
|
else {
|
|
$ans = <STDIN>;
|
|
if( defined $ans ) {
|
|
$ans =~ s{\015?\012$}{};
|
|
}
|
|
else { # user hit ctrl-D
|
|
print "\n";
|
|
}
|
|
}
|
|
|
|
return (!defined $ans || $ans eq '') ? $def : $ans;
|
|
}
|
|
|
|
sub os_unsupported {
|
|
die "OS unsupported\n";
|
|
}
|
|
|
|
sub eval_in_subdirs {
|
|
my($self) = @_;
|
|
use Cwd qw(cwd abs_path);
|
|
my $pwd = cwd() || die "Can't figure out your cwd!";
|
|
|
|
local @INC = map eval {abs_path($_) if -e} || $_, @INC;
|
|
push @INC, '.'; # '.' has to always be at the end of @INC
|
|
|
|
foreach my $dir (@{$self->{DIR}}){
|
|
my($abs) = $self->catdir($pwd,$dir);
|
|
eval { $self->eval_in_x($abs); };
|
|
last if $@;
|
|
}
|
|
chdir $pwd;
|
|
die $@ if $@;
|
|
}
|
|
|
|
sub eval_in_x {
|
|
my($self,$dir) = @_;
|
|
chdir $dir or carp("Couldn't change to directory $dir: $!");
|
|
|
|
{
|
|
package main;
|
|
do './Makefile.PL';
|
|
};
|
|
if ($@) {
|
|
# if ($@ =~ /prerequisites/) {
|
|
# die "MakeMaker WARNING: $@";
|
|
# } else {
|
|
# warn "WARNING from evaluation of $dir/Makefile.PL: $@";
|
|
# }
|
|
die "ERROR from evaluation of $dir/Makefile.PL: $@";
|
|
}
|
|
}
|
|
|
|
|
|
# package name for the classes into which the first object will be blessed
|
|
my $PACKNAME = 'PACK000';
|
|
|
|
sub full_setup {
|
|
$Verbose ||= 0;
|
|
|
|
my @dep_macros = qw/
|
|
PERL_INCDEP PERL_ARCHLIBDEP PERL_ARCHIVEDEP
|
|
/;
|
|
|
|
my @fs_macros = qw/
|
|
FULLPERL XSUBPPDIR
|
|
|
|
INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB INST_MAN1DIR INST_MAN3DIR
|
|
INSTALLDIRS
|
|
DESTDIR PREFIX INSTALL_BASE
|
|
PERLPREFIX SITEPREFIX VENDORPREFIX
|
|
INSTALLPRIVLIB INSTALLSITELIB INSTALLVENDORLIB
|
|
INSTALLARCHLIB INSTALLSITEARCH INSTALLVENDORARCH
|
|
INSTALLBIN INSTALLSITEBIN INSTALLVENDORBIN
|
|
INSTALLMAN1DIR INSTALLMAN3DIR
|
|
INSTALLSITEMAN1DIR INSTALLSITEMAN3DIR
|
|
INSTALLVENDORMAN1DIR INSTALLVENDORMAN3DIR
|
|
INSTALLSCRIPT INSTALLSITESCRIPT INSTALLVENDORSCRIPT
|
|
PERL_LIB PERL_ARCHLIB
|
|
SITELIBEXP SITEARCHEXP
|
|
|
|
MAKE LIBPERL_A LIB PERL_SRC PERL_INC
|
|
PPM_INSTALL_EXEC PPM_UNINSTALL_EXEC
|
|
PPM_INSTALL_SCRIPT PPM_UNINSTALL_SCRIPT
|
|
/;
|
|
|
|
my @attrib_help = qw/
|
|
|
|
AUTHOR ABSTRACT ABSTRACT_FROM BINARY_LOCATION
|
|
C CAPI CCFLAGS CONFIG CONFIGURE DEFINE DIR DISTNAME DISTVNAME
|
|
DL_FUNCS DL_VARS
|
|
EXCLUDE_EXT EXE_FILES FIRST_MAKEFILE
|
|
FULLPERLRUN FULLPERLRUNINST
|
|
FUNCLIST H IMPORTS
|
|
|
|
INC INCLUDE_EXT LDFROM LIBS LICENSE
|
|
LINKTYPE MAKEAPERL MAKEFILE MAKEFILE_OLD MAN1PODS MAN3PODS MAP_TARGET
|
|
META_ADD META_MERGE MIN_PERL_VERSION BUILD_REQUIRES CONFIGURE_REQUIRES
|
|
MYEXTLIB NAME NEEDS_LINKING NOECHO NO_META NO_MYMETA NO_PACKLIST NO_PERLLOCAL
|
|
NORECURS NO_VC OBJECT OPTIMIZE PERL_MALLOC_OK PERL PERLMAINCC PERLRUN
|
|
PERLRUNINST PERL_CORE
|
|
PERM_DIR PERM_RW PERM_RWX MAGICXS
|
|
PL_FILES PM PM_FILTER PMLIBDIRS PMLIBPARENTDIRS POLLUTE
|
|
PREREQ_FATAL PREREQ_PM PREREQ_PRINT PRINT_PREREQ
|
|
SIGN SKIP TEST_REQUIRES TYPEMAPS UNINST VERSION VERSION_FROM XS
|
|
XSBUILD XSMULTI XSOPT XSPROTOARG XS_VERSION
|
|
clean depend dist dynamic_lib linkext macro realclean tool_autosplit
|
|
|
|
MAN1EXT MAN3EXT
|
|
|
|
MACPERL_SRC MACPERL_LIB MACLIBS_68K MACLIBS_PPC MACLIBS_SC MACLIBS_MRC
|
|
MACLIBS_ALL_68K MACLIBS_ALL_PPC MACLIBS_SHARED
|
|
/;
|
|
push @attrib_help, @fs_macros;
|
|
@macro_fsentity{@fs_macros, @dep_macros} = (1) x (@fs_macros+@dep_macros);
|
|
@macro_dep{@dep_macros} = (1) x @dep_macros;
|
|
|
|
# IMPORTS is used under OS/2 and Win32
|
|
|
|
# @Overridable is close to @MM_Sections but not identical. The
|
|
# order is important. Many subroutines declare macros. These
|
|
# depend on each other. Let's try to collect the macros up front,
|
|
# then pasthru, then the rules.
|
|
|
|
# MM_Sections are the sections we have to call explicitly
|
|
# in Overridable we have subroutines that are used indirectly
|
|
|
|
|
|
@MM_Sections =
|
|
qw(
|
|
|
|
post_initialize const_config constants platform_constants
|
|
tool_autosplit tool_xsubpp tools_other
|
|
|
|
makemakerdflt
|
|
|
|
dist macro depend cflags const_loadlibs const_cccmd
|
|
post_constants
|
|
|
|
pasthru
|
|
|
|
special_targets
|
|
c_o xs_c xs_o
|
|
top_targets blibdirs linkext dlsyms dynamic_bs dynamic
|
|
dynamic_lib static static_lib manifypods processPL
|
|
installbin subdirs
|
|
clean_subdirs clean realclean_subdirs realclean
|
|
metafile signature
|
|
dist_basics dist_core distdir dist_test dist_ci distmeta distsignature
|
|
install force perldepend makefile staticmake test ppd
|
|
|
|
); # loses section ordering
|
|
|
|
@Overridable = @MM_Sections;
|
|
push @Overridable, qw[
|
|
|
|
libscan makeaperl needs_linking
|
|
subdir_x test_via_harness test_via_script
|
|
|
|
init_VERSION init_dist init_INST init_INSTALL init_DEST init_dirscan
|
|
init_PM init_MANPODS init_xs init_PERL init_DIRFILESEP init_linker
|
|
];
|
|
|
|
push @MM_Sections, qw[
|
|
|
|
pm_to_blib selfdocument
|
|
|
|
];
|
|
|
|
# Postamble needs to be the last that was always the case
|
|
push @MM_Sections, "postamble";
|
|
push @Overridable, "postamble";
|
|
|
|
# All sections are valid keys.
|
|
@Recognized_Att_Keys{@MM_Sections} = (1) x @MM_Sections;
|
|
|
|
# we will use all these variables in the Makefile
|
|
@Get_from_Config =
|
|
qw(
|
|
ar cc cccdlflags ccdlflags dlext dlsrc exe_ext full_ar ld
|
|
lddlflags ldflags libc lib_ext obj_ext osname osvers ranlib
|
|
sitelibexp sitearchexp so
|
|
);
|
|
|
|
# 5.5.3 doesn't have any concept of vendor libs
|
|
push @Get_from_Config, qw( vendorarchexp vendorlibexp ) if $] >= 5.006;
|
|
|
|
foreach my $item (@attrib_help){
|
|
$Recognized_Att_Keys{$item} = 1;
|
|
}
|
|
foreach my $item (@Get_from_Config) {
|
|
$Recognized_Att_Keys{uc $item} = $Config{$item};
|
|
print "Attribute '\U$item\E' => '$Config{$item}'\n"
|
|
if ($Verbose >= 2);
|
|
}
|
|
|
|
#
|
|
# When we eval a Makefile.PL in a subdirectory, that one will ask
|
|
# us (the parent) for the values and will prepend "..", so that
|
|
# all files to be installed end up below OUR ./blib
|
|
#
|
|
@Prepend_parent = qw(
|
|
INST_BIN INST_LIB INST_ARCHLIB INST_SCRIPT
|
|
MAP_TARGET INST_MAN1DIR INST_MAN3DIR PERL_SRC
|
|
PERL FULLPERL
|
|
);
|
|
}
|
|
|
|
sub _has_cpan_meta_requirements {
|
|
return eval {
|
|
require CPAN::Meta::Requirements;
|
|
CPAN::Meta::Requirements->VERSION(2.130);
|
|
require B; # CMR requires this, for core we have to too.
|
|
};
|
|
}
|
|
|
|
sub new {
|
|
my($class,$self) = @_;
|
|
my($key);
|
|
|
|
_convert_compat_attrs($self) if defined $self && $self;
|
|
|
|
# Store the original args passed to WriteMakefile()
|
|
foreach my $k (keys %$self) {
|
|
$self->{ARGS}{$k} = $self->{$k};
|
|
}
|
|
|
|
$self = {} unless defined $self;
|
|
|
|
# Temporarily bless it into MM so it can be used as an
|
|
# object. It will be blessed into a temp package later.
|
|
bless $self, "MM";
|
|
|
|
# Cleanup all the module requirement bits
|
|
my %key2cmr;
|
|
for my $key (qw(PREREQ_PM BUILD_REQUIRES CONFIGURE_REQUIRES TEST_REQUIRES)) {
|
|
$self->{$key} ||= {};
|
|
if (_has_cpan_meta_requirements) {
|
|
my $cmr = CPAN::Meta::Requirements->from_string_hash(
|
|
$self->{$key},
|
|
{
|
|
bad_version_hook => sub {
|
|
#no warnings 'numeric'; # module doesn't use warnings
|
|
my $fallback;
|
|
if ( $_[0] =~ m!^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$! ) {
|
|
$fallback = sprintf "%f", $_[0];
|
|
} else {
|
|
($fallback) = $_[0] ? ($_[0] =~ /^([0-9.]+)/) : 0;
|
|
$fallback += 0;
|
|
carp "Unparsable version '$_[0]' for prerequisite $_[1] treated as $fallback";
|
|
}
|
|
version->new($fallback);
|
|
},
|
|
},
|
|
);
|
|
$self->{$key} = $cmr->as_string_hash;
|
|
$key2cmr{$key} = $cmr;
|
|
} else {
|
|
for my $module (sort keys %{ $self->{$key} }) {
|
|
my $version = $self->{$key}->{$module};
|
|
my $fallback = 0;
|
|
if (!defined($version) or !length($version)) {
|
|
carp "Undefined requirement for $module treated as '0' (CPAN::Meta::Requirements not available)";
|
|
}
|
|
elsif ($version =~ /^\d+(?:\.\d+(?:_\d+)*)?$/) {
|
|
next;
|
|
}
|
|
else {
|
|
if ( $version =~ m!^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$! ) {
|
|
$fallback = sprintf "%f", $version;
|
|
} else {
|
|
($fallback) = $version ? ($version =~ /^([0-9.]+)/) : 0;
|
|
$fallback += 0;
|
|
carp "Unparsable version '$version' for prerequisite $module treated as $fallback (CPAN::Meta::Requirements not available)";
|
|
}
|
|
}
|
|
$self->{$key}->{$module} = $fallback;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ("@ARGV" =~ /\bPREREQ_PRINT\b/) {
|
|
$self->_PREREQ_PRINT;
|
|
}
|
|
|
|
# PRINT_PREREQ is RedHatism.
|
|
if ("@ARGV" =~ /\bPRINT_PREREQ\b/) {
|
|
$self->_PRINT_PREREQ;
|
|
}
|
|
|
|
print "MakeMaker (v$VERSION)\n" if $Verbose;
|
|
if (-f "MANIFEST" && ! -f "Makefile" && ! $UNDER_CORE){
|
|
check_manifest();
|
|
}
|
|
|
|
check_hints($self);
|
|
|
|
if ( defined $self->{MIN_PERL_VERSION}
|
|
&& $self->{MIN_PERL_VERSION} !~ /^v?[\d_\.]+$/ ) {
|
|
require version;
|
|
my $normal = eval {
|
|
local $SIG{__WARN__} = sub {
|
|
# simulate "use warnings FATAL => 'all'" for vintage perls
|
|
die @_;
|
|
};
|
|
version->new( $self->{MIN_PERL_VERSION} )
|
|
};
|
|
$self->{MIN_PERL_VERSION} = $normal if defined $normal && !$@;
|
|
}
|
|
|
|
# Translate X.Y.Z to X.00Y00Z
|
|
if( defined $self->{MIN_PERL_VERSION} ) {
|
|
$self->{MIN_PERL_VERSION} =~ s{ ^v? (\d+) \. (\d+) \. (\d+) $ }
|
|
{sprintf "%d.%03d%03d", $1, $2, $3}ex;
|
|
}
|
|
|
|
my $perl_version_ok = eval {
|
|
local $SIG{__WARN__} = sub {
|
|
# simulate "use warnings FATAL => 'all'" for vintage perls
|
|
die @_;
|
|
};
|
|
!$self->{MIN_PERL_VERSION} or $self->{MIN_PERL_VERSION} <= $]
|
|
};
|
|
if (!$perl_version_ok) {
|
|
if (!defined $perl_version_ok) {
|
|
die <<'END';
|
|
Warning: MIN_PERL_VERSION is not in a recognized format.
|
|
Recommended is a quoted numerical value like '5.005' or '5.008001'.
|
|
END
|
|
}
|
|
elsif ($self->{PREREQ_FATAL}) {
|
|
die sprintf <<"END", $self->{MIN_PERL_VERSION}, $];
|
|
MakeMaker FATAL: perl version too low for this distribution.
|
|
Required is %s. We run %s.
|
|
END
|
|
}
|
|
else {
|
|
warn sprintf
|
|
"Warning: Perl version %s or higher required. We run %s.\n",
|
|
$self->{MIN_PERL_VERSION}, $];
|
|
}
|
|
}
|
|
|
|
my %configure_att; # record &{$self->{CONFIGURE}} attributes
|
|
my(%initial_att) = %$self; # record initial attributes
|
|
|
|
my(%unsatisfied) = ();
|
|
my %prereq2version;
|
|
my $cmr;
|
|
if (_has_cpan_meta_requirements) {
|
|
$cmr = CPAN::Meta::Requirements->new;
|
|
for my $key (qw(PREREQ_PM BUILD_REQUIRES CONFIGURE_REQUIRES TEST_REQUIRES)) {
|
|
$cmr->add_requirements($key2cmr{$key}) if $key2cmr{$key};
|
|
}
|
|
foreach my $prereq ($cmr->required_modules) {
|
|
$prereq2version{$prereq} = $cmr->requirements_for_module($prereq);
|
|
}
|
|
} else {
|
|
for my $key (qw(PREREQ_PM BUILD_REQUIRES CONFIGURE_REQUIRES TEST_REQUIRES)) {
|
|
next unless my $module2version = $self->{$key};
|
|
$prereq2version{$_} = $module2version->{$_} for keys %$module2version;
|
|
}
|
|
}
|
|
foreach my $prereq (sort keys %prereq2version) {
|
|
my $required_version = $prereq2version{$prereq};
|
|
|
|
my $pr_version = 0;
|
|
my $installed_file;
|
|
|
|
if ( $prereq eq 'perl' ) {
|
|
if ( defined $required_version && $required_version =~ /^v?[\d_\.]+$/
|
|
|| $required_version !~ /^v?[\d_\.]+$/ ) {
|
|
require version;
|
|
my $normal = eval { version->new( $required_version ) };
|
|
$required_version = $normal if defined $normal;
|
|
}
|
|
$installed_file = $prereq;
|
|
$pr_version = $];
|
|
}
|
|
else {
|
|
$installed_file = MM->_installed_file_for_module($prereq);
|
|
$pr_version = MM->parse_version($installed_file) if $installed_file;
|
|
$pr_version = 0 if $pr_version eq 'undef';
|
|
if ( !eval { version->new( $pr_version ); 1 } ) {
|
|
#no warnings 'numeric'; # module doesn't use warnings
|
|
my $fallback;
|
|
if ( $pr_version =~ m!^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$! ) {
|
|
$fallback = sprintf '%f', $pr_version;
|
|
} else {
|
|
($fallback) = $pr_version ? ($pr_version =~ /^([0-9.]+)/) : 0;
|
|
$fallback += 0;
|
|
carp "Unparsable version '$pr_version' for installed prerequisite $prereq treated as $fallback";
|
|
}
|
|
$pr_version = $fallback;
|
|
}
|
|
}
|
|
|
|
# convert X.Y_Z alpha version #s to X.YZ for easier comparisons
|
|
$pr_version =~ s/(\d+)\.(\d+)_(\d+)/$1.$2$3/;
|
|
|
|
if (!$installed_file) {
|
|
warn sprintf "Warning: prerequisite %s %s not found.\n",
|
|
$prereq, $required_version
|
|
unless $self->{PREREQ_FATAL}
|
|
or $UNDER_CORE;
|
|
|
|
$unsatisfied{$prereq} = 'not installed';
|
|
}
|
|
elsif (
|
|
$cmr
|
|
? !$cmr->accepts_module($prereq, $pr_version)
|
|
: $required_version > $pr_version
|
|
) {
|
|
warn sprintf "Warning: prerequisite %s %s not found. We have %s.\n",
|
|
$prereq, $required_version, ($pr_version || 'unknown version')
|
|
unless $self->{PREREQ_FATAL}
|
|
or $UNDER_CORE;
|
|
|
|
$unsatisfied{$prereq} = $required_version || 'unknown version' ;
|
|
}
|
|
}
|
|
|
|
if (%unsatisfied && $self->{PREREQ_FATAL}){
|
|
my $failedprereqs = join "\n", map {" $_ $unsatisfied{$_}"}
|
|
sort { $a cmp $b } keys %unsatisfied;
|
|
die <<"END";
|
|
MakeMaker FATAL: prerequisites not found.
|
|
$failedprereqs
|
|
|
|
Please install these modules first and rerun 'perl Makefile.PL'.
|
|
END
|
|
}
|
|
|
|
if (defined $self->{CONFIGURE}) {
|
|
if (ref $self->{CONFIGURE} eq 'CODE') {
|
|
%configure_att = %{&{$self->{CONFIGURE}}};
|
|
_convert_compat_attrs(\%configure_att);
|
|
$self = { %$self, %configure_att };
|
|
} else {
|
|
croak "Attribute 'CONFIGURE' to WriteMakefile() not a code reference\n";
|
|
}
|
|
}
|
|
|
|
my $newclass = ++$PACKNAME;
|
|
local @Parent = @Parent; # Protect against non-local exits
|
|
{
|
|
print "Blessing Object into class [$newclass]\n" if $Verbose>=2;
|
|
mv_all_methods("MY",$newclass);
|
|
bless $self, $newclass;
|
|
push @Parent, $self;
|
|
require ExtUtils::MY;
|
|
|
|
no strict 'refs'; ## no critic;
|
|
@{"$newclass\:\:ISA"} = 'MM';
|
|
}
|
|
|
|
if (defined $Parent[-2]){
|
|
$self->{PARENT} = $Parent[-2];
|
|
for my $key (@Prepend_parent) {
|
|
next unless defined $self->{PARENT}{$key};
|
|
|
|
# Don't stomp on WriteMakefile() args.
|
|
next if defined $self->{ARGS}{$key} and
|
|
$self->{ARGS}{$key} eq $self->{$key};
|
|
|
|
$self->{$key} = $self->{PARENT}{$key};
|
|
|
|
if ($Is_VMS && $key =~ /PERL$/) {
|
|
# PERL or FULLPERL will be a command verb or even a
|
|
# command with an argument instead of a full file
|
|
# specification under VMS. So, don't turn the command
|
|
# into a filespec, but do add a level to the path of
|
|
# the argument if not already absolute.
|
|
my @cmd = split /\s+/, $self->{$key};
|
|
$cmd[1] = $self->catfile('[-]',$cmd[1])
|
|
unless (@cmd < 2) || $self->file_name_is_absolute($cmd[1]);
|
|
$self->{$key} = join(' ', @cmd);
|
|
} else {
|
|
my $value = $self->{$key};
|
|
# not going to test in FS so only stripping start
|
|
$value =~ s/^"// if $key =~ /PERL$/;
|
|
$value = $self->catdir("..", $value)
|
|
unless $self->file_name_is_absolute($value);
|
|
$value = qq{"$value} if $key =~ /PERL$/;
|
|
$self->{$key} = $value;
|
|
}
|
|
}
|
|
if ($self->{PARENT}) {
|
|
$self->{PARENT}->{CHILDREN}->{$newclass} = $self;
|
|
foreach my $opt (qw(POLLUTE PERL_CORE LINKTYPE LD OPTIMIZE)) {
|
|
if (exists $self->{PARENT}->{$opt}
|
|
and not exists $self->{$opt})
|
|
{
|
|
# inherit, but only if already unspecified
|
|
$self->{$opt} = $self->{PARENT}->{$opt};
|
|
}
|
|
}
|
|
}
|
|
my @fm = grep /^FIRST_MAKEFILE=/, @ARGV;
|
|
parse_args($self,@fm) if @fm;
|
|
}
|
|
else {
|
|
parse_args($self, _shellwords($ENV{PERL_MM_OPT} || ''),@ARGV);
|
|
}
|
|
|
|
# RT#91540 PREREQ_FATAL not recognized on command line
|
|
if (%unsatisfied && $self->{PREREQ_FATAL}){
|
|
my $failedprereqs = join "\n", map {" $_ $unsatisfied{$_}"}
|
|
sort { $a cmp $b } keys %unsatisfied;
|
|
die <<"END";
|
|
MakeMaker FATAL: prerequisites not found.
|
|
$failedprereqs
|
|
|
|
Please install these modules first and rerun 'perl Makefile.PL'.
|
|
END
|
|
}
|
|
|
|
$self->{NAME} ||= $self->guess_name;
|
|
|
|
warn "Warning: NAME must be a package name\n"
|
|
unless $self->{NAME} =~ m!^[A-Z_a-z][0-9A-Z_a-z]*(?:::[0-9A-Z_a-z]+)*$!;
|
|
|
|
($self->{NAME_SYM} = $self->{NAME}) =~ s/\W+/_/g;
|
|
|
|
$self->init_MAKE;
|
|
$self->init_main;
|
|
$self->init_VERSION;
|
|
$self->init_dist;
|
|
$self->init_INST;
|
|
$self->init_INSTALL;
|
|
$self->init_DEST;
|
|
$self->init_dirscan;
|
|
$self->init_PM;
|
|
$self->init_MANPODS;
|
|
$self->init_xs;
|
|
$self->init_PERL;
|
|
$self->init_DIRFILESEP;
|
|
$self->init_linker;
|
|
$self->init_ABSTRACT;
|
|
|
|
$self->arch_check(
|
|
$INC{'Config.pm'},
|
|
$self->catfile($Config{'archlibexp'}, "Config.pm")
|
|
);
|
|
|
|
$self->init_tools();
|
|
$self->init_others();
|
|
$self->init_platform();
|
|
$self->init_PERM();
|
|
my @args = @ARGV;
|
|
@args = map { Encode::decode(locale => $_) } @args if $CAN_DECODE;
|
|
my($argv) = neatvalue(\@args);
|
|
$argv =~ s/^\[/(/;
|
|
$argv =~ s/\]$/)/;
|
|
|
|
push @{$self->{RESULT}}, <<END;
|
|
# This Makefile is for the $self->{NAME} extension to perl.
|
|
#
|
|
# It was generated automatically by MakeMaker version
|
|
# $VERSION (Revision: $Revision) from the contents of
|
|
# Makefile.PL. Don't edit this file, edit Makefile.PL instead.
|
|
#
|
|
# ANY CHANGES MADE HERE WILL BE LOST!
|
|
#
|
|
# MakeMaker ARGV: $argv
|
|
#
|
|
END
|
|
|
|
push @{$self->{RESULT}}, $self->_MakeMaker_Parameters_section(\%initial_att);
|
|
|
|
if (defined $self->{CONFIGURE}) {
|
|
push @{$self->{RESULT}}, <<END;
|
|
|
|
# MakeMaker 'CONFIGURE' Parameters:
|
|
END
|
|
if (scalar(keys %configure_att) > 0) {
|
|
foreach my $key (sort keys %configure_att){
|
|
next if $key eq 'ARGS';
|
|
my($v) = neatvalue($configure_att{$key});
|
|
$v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
|
|
$v =~ tr/\n/ /s;
|
|
push @{$self->{RESULT}}, "# $key => $v";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
push @{$self->{RESULT}}, "# no values returned";
|
|
}
|
|
undef %configure_att; # free memory
|
|
}
|
|
|
|
# turn the SKIP array into a SKIPHASH hash
|
|
for my $skip (@{$self->{SKIP} || []}) {
|
|
$self->{SKIPHASH}{$skip} = 1;
|
|
}
|
|
delete $self->{SKIP}; # free memory
|
|
|
|
if ($self->{PARENT}) {
|
|
for (qw/install dist dist_basics dist_core distdir dist_test dist_ci/) {
|
|
$self->{SKIPHASH}{$_} = 1;
|
|
}
|
|
}
|
|
|
|
# We run all the subdirectories now. They don't have much to query
|
|
# from the parent, but the parent has to query them: if they need linking!
|
|
unless ($self->{NORECURS}) {
|
|
$self->eval_in_subdirs if @{$self->{DIR}};
|
|
}
|
|
|
|
foreach my $section ( @MM_Sections ){
|
|
# Support for new foo_target() methods.
|
|
my $method = $section;
|
|
$method .= '_target' unless $self->can($method);
|
|
|
|
print "Processing Makefile '$section' section\n" if ($Verbose >= 2);
|
|
my($skipit) = $self->skipcheck($section);
|
|
if ($skipit){
|
|
push @{$self->{RESULT}}, "\n# --- MakeMaker $section section $skipit.";
|
|
} else {
|
|
my(%a) = %{$self->{$section} || {}};
|
|
push @{$self->{RESULT}}, "\n# --- MakeMaker $section section:";
|
|
push @{$self->{RESULT}}, "# " . join ", ", %a if $Verbose && %a;
|
|
push @{$self->{RESULT}}, $self->maketext_filter(
|
|
$self->$method( %a )
|
|
);
|
|
}
|
|
}
|
|
|
|
push @{$self->{RESULT}}, "\n# End.";
|
|
|
|
$self;
|
|
}
|
|
|
|
sub WriteEmptyMakefile {
|
|
croak "WriteEmptyMakefile: Need an even number of args" if @_ % 2;
|
|
|
|
my %att = @_;
|
|
$att{DIR} = [] unless $att{DIR}; # don't recurse by default
|
|
my $self = MM->new(\%att);
|
|
|
|
my $new = $self->{MAKEFILE};
|
|
my $old = $self->{MAKEFILE_OLD};
|
|
if (-f $old) {
|
|
_unlink($old) or warn "unlink $old: $!";
|
|
}
|
|
if ( -f $new ) {
|
|
_rename($new, $old) or warn "rename $new => $old: $!"
|
|
}
|
|
open my $mfh, '>', $new or die "open $new for write: $!";
|
|
print $mfh <<'EOP';
|
|
all :
|
|
|
|
manifypods :
|
|
|
|
subdirs :
|
|
|
|
dynamic :
|
|
|
|
static :
|
|
|
|
clean :
|
|
|
|
install :
|
|
|
|
makemakerdflt :
|
|
|
|
test :
|
|
|
|
test_dynamic :
|
|
|
|
test_static :
|
|
|
|
EOP
|
|
close $mfh or die "close $new for write: $!";
|
|
}
|
|
|
|
|
|
=begin private
|
|
|
|
=head3 _installed_file_for_module
|
|
|
|
my $file = MM->_installed_file_for_module($module);
|
|
|
|
Return the first installed .pm $file associated with the $module. The
|
|
one which will show up when you C<use $module>.
|
|
|
|
$module is something like "strict" or "Test::More".
|
|
|
|
=end private
|
|
|
|
=cut
|
|
|
|
sub _installed_file_for_module {
|
|
my $class = shift;
|
|
my $prereq = shift;
|
|
|
|
my $file = "$prereq.pm";
|
|
$file =~ s{::}{/}g;
|
|
|
|
my $path;
|
|
for my $dir (@INC) {
|
|
my $tmp = File::Spec->catfile($dir, $file);
|
|
if ( -r $tmp ) {
|
|
$path = $tmp;
|
|
last;
|
|
}
|
|
}
|
|
|
|
return $path;
|
|
}
|
|
|
|
|
|
# Extracted from MakeMaker->new so we can test it
|
|
sub _MakeMaker_Parameters_section {
|
|
my $self = shift;
|
|
my $att = shift;
|
|
|
|
my @result = <<'END';
|
|
# MakeMaker Parameters:
|
|
END
|
|
|
|
foreach my $key (sort keys %$att){
|
|
next if $key eq 'ARGS';
|
|
my $v;
|
|
if ($key eq 'PREREQ_PM') {
|
|
# CPAN.pm takes prereqs from this field in 'Makefile'
|
|
# and does not know about BUILD_REQUIRES
|
|
$v = neatvalue({
|
|
%{ $att->{PREREQ_PM} || {} },
|
|
%{ $att->{BUILD_REQUIRES} || {} },
|
|
%{ $att->{TEST_REQUIRES} || {} },
|
|
});
|
|
} else {
|
|
$v = neatvalue($att->{$key});
|
|
}
|
|
|
|
$v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
|
|
$v =~ tr/\n/ /s;
|
|
push @result, "# $key => $v";
|
|
}
|
|
|
|
return @result;
|
|
}
|
|
|
|
# _shellwords and _parseline borrowed from Text::ParseWords
|
|
sub _shellwords {
|
|
my (@lines) = @_;
|
|
my @allwords;
|
|
|
|
foreach my $line (@lines) {
|
|
$line =~ s/^\s+//;
|
|
my @words = _parse_line('\s+', 0, $line);
|
|
pop @words if (@words and !defined $words[-1]);
|
|
return() unless (@words || !length($line));
|
|
push(@allwords, @words);
|
|
}
|
|
return(@allwords);
|
|
}
|
|
|
|
sub _parse_line {
|
|
my($delimiter, $keep, $line) = @_;
|
|
my($word, @pieces);
|
|
|
|
no warnings 'uninitialized'; # we will be testing undef strings
|
|
|
|
while (length($line)) {
|
|
# This pattern is optimised to be stack conservative on older perls.
|
|
# Do not refactor without being careful and testing it on very long strings.
|
|
# See Perl bug #42980 for an example of a stack busting input.
|
|
$line =~ s/^
|
|
(?:
|
|
# double quoted string
|
|
(") # $quote
|
|
((?>[^\\"]*(?:\\.[^\\"]*)*))" # $quoted
|
|
| # --OR--
|
|
# singe quoted string
|
|
(') # $quote
|
|
((?>[^\\']*(?:\\.[^\\']*)*))' # $quoted
|
|
| # --OR--
|
|
# unquoted string
|
|
( # $unquoted
|
|
(?:\\.|[^\\"'])*?
|
|
)
|
|
# followed by
|
|
( # $delim
|
|
\Z(?!\n) # EOL
|
|
| # --OR--
|
|
(?-x:$delimiter) # delimiter
|
|
| # --OR--
|
|
(?!^)(?=["']) # a quote
|
|
)
|
|
)//xs or return; # extended layout
|
|
my ($quote, $quoted, $unquoted, $delim) = (($1 ? ($1,$2) : ($3,$4)), $5, $6);
|
|
|
|
|
|
return() unless( defined($quote) || length($unquoted) || length($delim));
|
|
|
|
if ($keep) {
|
|
$quoted = "$quote$quoted$quote";
|
|
}
|
|
else {
|
|
$unquoted =~ s/\\(.)/$1/sg;
|
|
if (defined $quote) {
|
|
$quoted =~ s/\\(.)/$1/sg if ($quote eq '"');
|
|
#$quoted =~ s/\\([\\'])/$1/g if ( $PERL_SINGLE_QUOTE && $quote eq "'");
|
|
}
|
|
}
|
|
$word .= substr($line, 0, 0); # leave results tainted
|
|
$word .= defined $quote ? $quoted : $unquoted;
|
|
|
|
if (length($delim)) {
|
|
push(@pieces, $word);
|
|
push(@pieces, $delim) if ($keep eq 'delimiters');
|
|
undef $word;
|
|
}
|
|
if (!length($line)) {
|
|
push(@pieces, $word);
|
|
}
|
|
}
|
|
return(@pieces);
|
|
}
|
|
|
|
sub check_manifest {
|
|
print "Checking if your kit is complete...\n";
|
|
require ExtUtils::Manifest;
|
|
# avoid warning
|
|
$ExtUtils::Manifest::Quiet = $ExtUtils::Manifest::Quiet = 1;
|
|
my(@missed) = ExtUtils::Manifest::manicheck();
|
|
if (@missed) {
|
|
print "Warning: the following files are missing in your kit:\n";
|
|
print "\t", join "\n\t", @missed;
|
|
print "\n";
|
|
print "Please inform the author.\n";
|
|
} else {
|
|
print "Looks good\n";
|
|
}
|
|
}
|
|
|
|
sub parse_args{
|
|
my($self, @args) = @_;
|
|
@args = map { Encode::decode(locale => $_) } @args if $CAN_DECODE;
|
|
foreach (@args) {
|
|
unless (m/(.*?)=(.*)/) {
|
|
++$Verbose if m/^verb/;
|
|
next;
|
|
}
|
|
my($name, $value) = ($1, $2);
|
|
if ($value =~ m/^~(\w+)?/) { # tilde with optional username
|
|
$value =~ s [^~(\w*)]
|
|
[$1 ?
|
|
((getpwnam($1))[7] || "~$1") :
|
|
(getpwuid($>))[7]
|
|
]ex;
|
|
}
|
|
|
|
# Remember the original args passed it. It will be useful later.
|
|
$self->{ARGS}{uc $name} = $self->{uc $name} = $value;
|
|
}
|
|
|
|
# catch old-style 'potential_libs' and inform user how to 'upgrade'
|
|
if (defined $self->{potential_libs}){
|
|
my($msg)="'potential_libs' => '$self->{potential_libs}' should be";
|
|
if ($self->{potential_libs}){
|
|
print "$msg changed to:\n\t'LIBS' => ['$self->{potential_libs}']\n";
|
|
} else {
|
|
print "$msg deleted.\n";
|
|
}
|
|
$self->{LIBS} = [$self->{potential_libs}];
|
|
delete $self->{potential_libs};
|
|
}
|
|
# catch old-style 'ARMAYBE' and inform user how to 'upgrade'
|
|
if (defined $self->{ARMAYBE}){
|
|
my($armaybe) = $self->{ARMAYBE};
|
|
print "ARMAYBE => '$armaybe' should be changed to:\n",
|
|
"\t'dynamic_lib' => {ARMAYBE => '$armaybe'}\n";
|
|
my(%dl) = %{$self->{dynamic_lib} || {}};
|
|
$self->{dynamic_lib} = { %dl, ARMAYBE => $armaybe};
|
|
delete $self->{ARMAYBE};
|
|
}
|
|
if (defined $self->{LDTARGET}){
|
|
print "LDTARGET should be changed to LDFROM\n";
|
|
$self->{LDFROM} = $self->{LDTARGET};
|
|
delete $self->{LDTARGET};
|
|
}
|
|
# Turn a DIR argument on the command line into an array
|
|
if (defined $self->{DIR} && ref \$self->{DIR} eq 'SCALAR') {
|
|
# So they can choose from the command line, which extensions they want
|
|
# the grep enables them to have some colons too much in case they
|
|
# have to build a list with the shell
|
|
$self->{DIR} = [grep $_, split ":", $self->{DIR}];
|
|
}
|
|
# Turn a INCLUDE_EXT argument on the command line into an array
|
|
if (defined $self->{INCLUDE_EXT} && ref \$self->{INCLUDE_EXT} eq 'SCALAR') {
|
|
$self->{INCLUDE_EXT} = [grep $_, split '\s+', $self->{INCLUDE_EXT}];
|
|
}
|
|
# Turn a EXCLUDE_EXT argument on the command line into an array
|
|
if (defined $self->{EXCLUDE_EXT} && ref \$self->{EXCLUDE_EXT} eq 'SCALAR') {
|
|
$self->{EXCLUDE_EXT} = [grep $_, split '\s+', $self->{EXCLUDE_EXT}];
|
|
}
|
|
|
|
foreach my $mmkey (sort keys %$self){
|
|
next if $mmkey eq 'ARGS';
|
|
print " $mmkey => ", neatvalue($self->{$mmkey}), "\n" if $Verbose;
|
|
print "'$mmkey' is not a known MakeMaker parameter name.\n"
|
|
unless exists $Recognized_Att_Keys{$mmkey};
|
|
}
|
|
$| = 1 if $Verbose;
|
|
}
|
|
|
|
sub check_hints {
|
|
my($self) = @_;
|
|
# We allow extension-specific hints files.
|
|
|
|
require File::Spec;
|
|
my $curdir = File::Spec->curdir;
|
|
|
|
my $hint_dir = File::Spec->catdir($curdir, "hints");
|
|
return unless -d $hint_dir;
|
|
|
|
# First we look for the best hintsfile we have
|
|
my($hint)="${^O}_$Config{osvers}";
|
|
$hint =~ s/\./_/g;
|
|
$hint =~ s/_$//;
|
|
return unless $hint;
|
|
|
|
# Also try without trailing minor version numbers.
|
|
while (1) {
|
|
last if -f File::Spec->catfile($hint_dir, "$hint.pl"); # found
|
|
} continue {
|
|
last unless $hint =~ s/_[^_]*$//; # nothing to cut off
|
|
}
|
|
my $hint_file = File::Spec->catfile($hint_dir, "$hint.pl");
|
|
|
|
return unless -f $hint_file; # really there
|
|
|
|
_run_hintfile($self, $hint_file);
|
|
}
|
|
|
|
sub _run_hintfile {
|
|
our $self;
|
|
local($self) = shift; # make $self available to the hint file.
|
|
my($hint_file) = shift;
|
|
|
|
local($@, $!);
|
|
print "Processing hints file $hint_file\n" if $Verbose;
|
|
|
|
# Just in case the ./ isn't on the hint file, which File::Spec can
|
|
# often strip off, we bung the curdir into @INC
|
|
local @INC = (File::Spec->curdir, @INC);
|
|
my $ret = do $hint_file;
|
|
if( !defined $ret ) {
|
|
my $error = $@ || $!;
|
|
warn $error;
|
|
}
|
|
}
|
|
|
|
sub mv_all_methods {
|
|
my($from,$to) = @_;
|
|
local $SIG{__WARN__} = sub {
|
|
# can't use 'no warnings redefined', 5.6 only
|
|
warn @_ unless $_[0] =~ /^Subroutine .* redefined/
|
|
};
|
|
foreach my $method (@Overridable) {
|
|
next unless defined &{"${from}::$method"};
|
|
no strict 'refs'; ## no critic
|
|
*{"${to}::$method"} = \&{"${from}::$method"};
|
|
|
|
# If we delete a method, then it will be undefined and cannot
|
|
# be called. But as long as we have Makefile.PLs that rely on
|
|
# %MY:: being intact, we have to fill the hole with an
|
|
# inheriting method:
|
|
|
|
{
|
|
package MY;
|
|
my $super = "SUPER::".$method;
|
|
*{$method} = sub {
|
|
shift->$super(@_);
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
sub skipcheck {
|
|
my($self) = shift;
|
|
my($section) = @_;
|
|
return 'skipped' if $section eq 'metafile' && $UNDER_CORE;
|
|
if ($section eq 'dynamic') {
|
|
print "Warning (non-fatal): Target 'dynamic' depends on targets ",
|
|
"in skipped section 'dynamic_bs'\n"
|
|
if $self->{SKIPHASH}{dynamic_bs} && $Verbose;
|
|
print "Warning (non-fatal): Target 'dynamic' depends on targets ",
|
|
"in skipped section 'dynamic_lib'\n"
|
|
if $self->{SKIPHASH}{dynamic_lib} && $Verbose;
|
|
}
|
|
if ($section eq 'dynamic_lib') {
|
|
print "Warning (non-fatal): Target '\$(INST_DYNAMIC)' depends on ",
|
|
"targets in skipped section 'dynamic_bs'\n"
|
|
if $self->{SKIPHASH}{dynamic_bs} && $Verbose;
|
|
}
|
|
if ($section eq 'static') {
|
|
print "Warning (non-fatal): Target 'static' depends on targets ",
|
|
"in skipped section 'static_lib'\n"
|
|
if $self->{SKIPHASH}{static_lib} && $Verbose;
|
|
}
|
|
return 'skipped' if $self->{SKIPHASH}{$section};
|
|
return '';
|
|
}
|
|
|
|
# returns filehandle, dies on fail. :raw so no :crlf
|
|
sub open_for_writing {
|
|
my ($file) = @_;
|
|
open my $fh ,">", $file or die "Unable to open $file: $!";
|
|
my @layers = ':raw';
|
|
push @layers, join ' ', ':encoding(locale)' if $CAN_DECODE;
|
|
binmode $fh, join ' ', @layers;
|
|
$fh;
|
|
}
|
|
|
|
sub flush {
|
|
my $self = shift;
|
|
|
|
my $finalname = $self->{MAKEFILE};
|
|
printf "Generating a %s %s\n", $self->make_type, $finalname if $Verbose || !$self->{PARENT};
|
|
print "Writing $finalname for $self->{NAME}\n" if $Verbose || !$self->{PARENT};
|
|
|
|
unlink($finalname, "MakeMaker.tmp", $Is_VMS ? 'Descrip.MMS' : ());
|
|
|
|
write_file_via_tmp($finalname, $self->{RESULT});
|
|
|
|
# Write MYMETA.yml to communicate metadata up to the CPAN clients
|
|
print "Writing MYMETA.yml and MYMETA.json\n"
|
|
if !$self->{NO_MYMETA} and $self->write_mymeta( $self->mymeta );
|
|
|
|
# save memory
|
|
if ($self->{PARENT} && !$self->{_KEEP_AFTER_FLUSH}) {
|
|
my %keep = map { ($_ => 1) } qw(NEEDS_LINKING HAS_LINK_CODE);
|
|
delete $self->{$_} for grep !$keep{$_}, keys %$self;
|
|
}
|
|
|
|
system("$Config::Config{eunicefix} $finalname")
|
|
if $Config::Config{eunicefix} ne ":";
|
|
|
|
return;
|
|
}
|
|
|
|
sub write_file_via_tmp {
|
|
my ($finalname, $contents) = @_;
|
|
my $fh = open_for_writing("MakeMaker.tmp");
|
|
die "write_file_via_tmp: 2nd arg must be ref" unless ref $contents;
|
|
for my $chunk (@$contents) {
|
|
my $to_write = $chunk;
|
|
utf8::encode $to_write if !$CAN_DECODE && $] > 5.008;
|
|
print $fh "$to_write\n" or die "Can't write to MakeMaker.tmp: $!";
|
|
}
|
|
close $fh or die "Can't write to MakeMaker.tmp: $!";
|
|
_rename("MakeMaker.tmp", $finalname) or
|
|
warn "rename MakeMaker.tmp => $finalname: $!";
|
|
chmod 0644, $finalname if !$Is_VMS;
|
|
return;
|
|
}
|
|
|
|
# This is a rename for OS's where the target must be unlinked first.
|
|
sub _rename {
|
|
my($src, $dest) = @_;
|
|
_unlink($dest);
|
|
return rename $src, $dest;
|
|
}
|
|
|
|
# This is an unlink for OS's where the target must be writable first.
|
|
sub _unlink {
|
|
my @files = @_;
|
|
chmod 0666, @files;
|
|
return unlink @files;
|
|
}
|
|
|
|
|
|
# The following mkbootstrap() is only for installations that are calling
|
|
# the pre-4.1 mkbootstrap() from their old Makefiles. This MakeMaker
|
|
# writes Makefiles, that use ExtUtils::Mkbootstrap directly.
|
|
sub mkbootstrap {
|
|
die <<END;
|
|
!!! Your Makefile has been built such a long time ago, !!!
|
|
!!! that is unlikely to work with current MakeMaker. !!!
|
|
!!! Please rebuild your Makefile !!!
|
|
END
|
|
}
|
|
|
|
# Ditto for mksymlists() as of MakeMaker 5.17
|
|
sub mksymlists {
|
|
die <<END;
|
|
!!! Your Makefile has been built such a long time ago, !!!
|
|
!!! that is unlikely to work with current MakeMaker. !!!
|
|
!!! Please rebuild your Makefile !!!
|
|
END
|
|
}
|
|
|
|
sub neatvalue {
|
|
my($v) = @_;
|
|
return "undef" unless defined $v;
|
|
my($t) = ref $v;
|
|
return "q[$v]" unless $t;
|
|
if ($t eq 'ARRAY') {
|
|
my(@m, @neat);
|
|
push @m, "[";
|
|
foreach my $elem (@$v) {
|
|
push @neat, "q[$elem]";
|
|
}
|
|
push @m, join ", ", @neat;
|
|
push @m, "]";
|
|
return join "", @m;
|
|
}
|
|
return $v unless $t eq 'HASH';
|
|
my(@m, $key, $val);
|
|
for my $key (sort keys %$v) {
|
|
last unless defined $key; # cautious programming in case (undef,undef) is true
|
|
push @m,"$key=>".neatvalue($v->{$key});
|
|
}
|
|
return "{ ".join(', ',@m)." }";
|
|
}
|
|
|
|
sub _find_magic_vstring {
|
|
my $value = shift;
|
|
return $value if $UNDER_CORE;
|
|
my $tvalue = '';
|
|
require B;
|
|
my $sv = B::svref_2object(\$value);
|
|
my $magic = ref($sv) eq 'B::PVMG' ? $sv->MAGIC : undef;
|
|
while ( $magic ) {
|
|
if ( $magic->TYPE eq 'V' ) {
|
|
$tvalue = $magic->PTR;
|
|
$tvalue =~ s/^v?(.+)$/v$1/;
|
|
last;
|
|
}
|
|
else {
|
|
$magic = $magic->MOREMAGIC;
|
|
}
|
|
}
|
|
return $tvalue;
|
|
}
|
|
|
|
sub selfdocument {
|
|
my($self) = @_;
|
|
my(@m);
|
|
if ($Verbose){
|
|
push @m, "\n# Full list of MakeMaker attribute values:";
|
|
foreach my $key (sort keys %$self){
|
|
next if $key eq 'RESULT' || $key =~ /^[A-Z][a-z]/;
|
|
my($v) = neatvalue($self->{$key});
|
|
$v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
|
|
$v =~ tr/\n/ /s;
|
|
push @m, "# $key => $v";
|
|
}
|
|
}
|
|
# added here as selfdocument is not overridable
|
|
push @m, <<'EOF';
|
|
|
|
# here so even if top_targets is overridden, these will still be defined
|
|
# gmake will silently still work if any are .PHONY-ed but nmake won't
|
|
EOF
|
|
push @m, join "\n", map "$_ ::\n\t\$(NOECHO) \$(NOOP)\n",
|
|
# config is so manifypods won't puke if no subdirs
|
|
grep !$self->{SKIPHASH}{$_},
|
|
qw(static dynamic config);
|
|
join "\n", @m;
|
|
}
|
|
|
|
1;
|
|
|
|
__END__
|
|
|
|
=head1 NAME
|
|
|
|
ExtUtils::MakeMaker - Create a module Makefile
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
use ExtUtils::MakeMaker;
|
|
|
|
WriteMakefile(
|
|
NAME => "Foo::Bar",
|
|
VERSION_FROM => "lib/Foo/Bar.pm",
|
|
);
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
This utility is designed to write a Makefile for an extension module
|
|
from a Makefile.PL. It is based on the Makefile.SH model provided by
|
|
Andy Dougherty and the perl5-porters.
|
|
|
|
It splits the task of generating the Makefile into several subroutines
|
|
that can be individually overridden. Each subroutine returns the text
|
|
it wishes to have written to the Makefile.
|
|
|
|
As there are various Make programs with incompatible syntax, which
|
|
use operating system shells, again with incompatible syntax, it is
|
|
important for users of this module to know which flavour of Make
|
|
a Makefile has been written for so they'll use the correct one and
|
|
won't have to face the possibly bewildering errors resulting from
|
|
using the wrong one.
|
|
|
|
On POSIX systems, that program will likely be GNU Make; on Microsoft
|
|
Windows, it will be either Microsoft NMake, DMake or GNU Make.
|
|
See the section on the L</"MAKE"> parameter for details.
|
|
|
|
ExtUtils::MakeMaker (EUMM) is object oriented. Each directory below the current
|
|
directory that contains a Makefile.PL is treated as a separate
|
|
object. This makes it possible to write an unlimited number of
|
|
Makefiles with a single invocation of WriteMakefile().
|
|
|
|
All inputs to WriteMakefile are Unicode characters, not just octets. EUMM
|
|
seeks to handle all of these correctly. It is currently still not possible
|
|
to portably use Unicode characters in module names, because this requires
|
|
Perl to handle Unicode filenames, which is not yet the case on Windows.
|
|
|
|
=head2 How To Write A Makefile.PL
|
|
|
|
See L<ExtUtils::MakeMaker::Tutorial>.
|
|
|
|
The long answer is the rest of the manpage :-)
|
|
|
|
=head2 Default Makefile Behaviour
|
|
|
|
The generated Makefile enables the user of the extension to invoke
|
|
|
|
perl Makefile.PL # optionally "perl Makefile.PL verbose"
|
|
make
|
|
make test # optionally set TEST_VERBOSE=1
|
|
make install # See below
|
|
|
|
The Makefile to be produced may be altered by adding arguments of the
|
|
form C<KEY=VALUE>. E.g.
|
|
|
|
perl Makefile.PL INSTALL_BASE=~
|
|
|
|
Other interesting targets in the generated Makefile are
|
|
|
|
make config # to check if the Makefile is up-to-date
|
|
make clean # delete local temp files (Makefile gets renamed)
|
|
make realclean # delete derived files (including ./blib)
|
|
make ci # check in all the files in the MANIFEST file
|
|
make dist # see below the Distribution Support section
|
|
|
|
=head2 make test
|
|
|
|
MakeMaker checks for the existence of a file named F<test.pl> in the
|
|
current directory, and if it exists it executes the script with the
|
|
proper set of perl C<-I> options.
|
|
|
|
MakeMaker also checks for any files matching glob("t/*.t"). It will
|
|
execute all matching files in alphabetical order via the
|
|
L<Test::Harness> module with the C<-I> switches set correctly.
|
|
|
|
You can also organize your tests within subdirectories in the F<t/> directory.
|
|
To do so, use the F<test> directive in your I<Makefile.PL>. For example, if you
|
|
had tests in:
|
|
|
|
t/foo
|
|
t/foo/bar
|
|
|
|
You could tell make to run tests in both of those directories with the
|
|
following directives:
|
|
|
|
test => {TESTS => 't/*/*.t t/*/*/*.t'}
|
|
test => {TESTS => 't/foo/*.t t/foo/bar/*.t'}
|
|
|
|
The first will run all test files in all first-level subdirectories and all
|
|
subdirectories they contain. The second will run tests in only the F<t/foo>
|
|
and F<t/foo/bar>.
|
|
|
|
If you'd like to see the raw output of your tests, set the
|
|
C<TEST_VERBOSE> variable to true.
|
|
|
|
make test TEST_VERBOSE=1
|
|
|
|
If you want to run particular test files, set the C<TEST_FILES> variable.
|
|
It is possible to use globbing with this mechanism.
|
|
|
|
make test TEST_FILES='t/foobar.t t/dagobah*.t'
|
|
|
|
Windows users who are using C<nmake> should note that due to a bug in C<nmake>,
|
|
when specifying C<TEST_FILES> you must use back-slashes instead of forward-slashes.
|
|
|
|
nmake test TEST_FILES='t\foobar.t t\dagobah*.t'
|
|
|
|
=head2 make testdb
|
|
|
|
A useful variation of the above is the target C<testdb>. It runs the
|
|
test under the Perl debugger (see L<perldebug>). If the file
|
|
F<test.pl> exists in the current directory, it is used for the test.
|
|
|
|
If you want to debug some other testfile, set the C<TEST_FILE> variable
|
|
thusly:
|
|
|
|
make testdb TEST_FILE=t/mytest.t
|
|
|
|
By default the debugger is called using C<-d> option to perl. If you
|
|
want to specify some other option, set the C<TESTDB_SW> variable:
|
|
|
|
make testdb TESTDB_SW=-Dx
|
|
|
|
=head2 make install
|
|
|
|
make alone puts all relevant files into directories that are named by
|
|
the macros INST_LIB, INST_ARCHLIB, INST_SCRIPT, INST_MAN1DIR and
|
|
INST_MAN3DIR. All these default to something below ./blib if you are
|
|
I<not> building below the perl source directory. If you I<are>
|
|
building below the perl source, INST_LIB and INST_ARCHLIB default to
|
|
../../lib, and INST_SCRIPT is not defined.
|
|
|
|
The I<install> target of the generated Makefile copies the files found
|
|
below each of the INST_* directories to their INSTALL*
|
|
counterparts. Which counterparts are chosen depends on the setting of
|
|
INSTALLDIRS according to the following table:
|
|
|
|
INSTALLDIRS set to
|
|
perl site vendor
|
|
|
|
PERLPREFIX SITEPREFIX VENDORPREFIX
|
|
INST_ARCHLIB INSTALLARCHLIB INSTALLSITEARCH INSTALLVENDORARCH
|
|
INST_LIB INSTALLPRIVLIB INSTALLSITELIB INSTALLVENDORLIB
|
|
INST_BIN INSTALLBIN INSTALLSITEBIN INSTALLVENDORBIN
|
|
INST_SCRIPT INSTALLSCRIPT INSTALLSITESCRIPT INSTALLVENDORSCRIPT
|
|
INST_MAN1DIR INSTALLMAN1DIR INSTALLSITEMAN1DIR INSTALLVENDORMAN1DIR
|
|
INST_MAN3DIR INSTALLMAN3DIR INSTALLSITEMAN3DIR INSTALLVENDORMAN3DIR
|
|
|
|
The INSTALL... macros in turn default to their %Config
|
|
($Config{installprivlib}, $Config{installarchlib}, etc.) counterparts.
|
|
|
|
You can check the values of these variables on your system with
|
|
|
|
perl '-V:install.*'
|
|
|
|
And to check the sequence in which the library directories are
|
|
searched by perl, run
|
|
|
|
perl -le 'print join $/, @INC'
|
|
|
|
Sometimes older versions of the module you're installing live in other
|
|
directories in @INC. Because Perl loads the first version of a module it
|
|
finds, not the newest, you might accidentally get one of these older
|
|
versions even after installing a brand new version. To delete I<all other
|
|
versions of the module you're installing> (not simply older ones) set the
|
|
C<UNINST> variable.
|
|
|
|
make install UNINST=1
|
|
|
|
|
|
=head2 INSTALL_BASE
|
|
|
|
INSTALL_BASE can be passed into Makefile.PL to change where your
|
|
module will be installed. INSTALL_BASE is more like what everyone
|
|
else calls "prefix" than PREFIX is.
|
|
|
|
To have everything installed in your home directory, do the following.
|
|
|
|
# Unix users, INSTALL_BASE=~ works fine
|
|
perl Makefile.PL INSTALL_BASE=/path/to/your/home/dir
|
|
|
|
Like PREFIX, it sets several INSTALL* attributes at once. Unlike
|
|
PREFIX it is easy to predict where the module will end up. The
|
|
installation pattern looks like this:
|
|
|
|
INSTALLARCHLIB INSTALL_BASE/lib/perl5/$Config{archname}
|
|
INSTALLPRIVLIB INSTALL_BASE/lib/perl5
|
|
INSTALLBIN INSTALL_BASE/bin
|
|
INSTALLSCRIPT INSTALL_BASE/bin
|
|
INSTALLMAN1DIR INSTALL_BASE/man/man1
|
|
INSTALLMAN3DIR INSTALL_BASE/man/man3
|
|
|
|
INSTALL_BASE in MakeMaker and C<--install_base> in Module::Build (as
|
|
of 0.28) install to the same location. If you want MakeMaker and
|
|
Module::Build to install to the same location simply set INSTALL_BASE
|
|
and C<--install_base> to the same location.
|
|
|
|
INSTALL_BASE was added in 6.31.
|
|
|
|
|
|
=head2 PREFIX and LIB attribute
|
|
|
|
PREFIX and LIB can be used to set several INSTALL* attributes in one
|
|
go. Here's an example for installing into your home directory.
|
|
|
|
# Unix users, PREFIX=~ works fine
|
|
perl Makefile.PL PREFIX=/path/to/your/home/dir
|
|
|
|
This will install all files in the module under your home directory,
|
|
with man pages and libraries going into an appropriate place (usually
|
|
~/man and ~/lib). How the exact location is determined is complicated
|
|
and depends on how your Perl was configured. INSTALL_BASE works more
|
|
like what other build systems call "prefix" than PREFIX and we
|
|
recommend you use that instead.
|
|
|
|
Another way to specify many INSTALL directories with a single
|
|
parameter is LIB.
|
|
|
|
perl Makefile.PL LIB=~/lib
|
|
|
|
This will install the module's architecture-independent files into
|
|
~/lib, the architecture-dependent files into ~/lib/$archname.
|
|
|
|
Note, that in both cases the tilde expansion is done by MakeMaker, not
|
|
by perl by default, nor by make.
|
|
|
|
Conflicts between parameters LIB, PREFIX and the various INSTALL*
|
|
arguments are resolved so that:
|
|
|
|
=over 4
|
|
|
|
=item *
|
|
|
|
setting LIB overrides any setting of INSTALLPRIVLIB, INSTALLARCHLIB,
|
|
INSTALLSITELIB, INSTALLSITEARCH (and they are not affected by PREFIX);
|
|
|
|
=item *
|
|
|
|
without LIB, setting PREFIX replaces the initial C<$Config{prefix}>
|
|
part of those INSTALL* arguments, even if the latter are explicitly
|
|
set (but are set to still start with C<$Config{prefix}>).
|
|
|
|
=back
|
|
|
|
If the user has superuser privileges, and is not working on AFS or
|
|
relatives, then the defaults for INSTALLPRIVLIB, INSTALLARCHLIB,
|
|
INSTALLSCRIPT, etc. will be appropriate, and this incantation will be
|
|
the best:
|
|
|
|
perl Makefile.PL;
|
|
make;
|
|
make test
|
|
make install
|
|
|
|
make install by default writes some documentation of what has been
|
|
done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This feature
|
|
can be bypassed by calling make pure_install.
|
|
|
|
=head2 AFS users
|
|
|
|
will have to specify the installation directories as these most
|
|
probably have changed since perl itself has been installed. They will
|
|
have to do this by calling
|
|
|
|
perl Makefile.PL INSTALLSITELIB=/afs/here/today \
|
|
INSTALLSCRIPT=/afs/there/now INSTALLMAN3DIR=/afs/for/manpages
|
|
make
|
|
|
|
Be careful to repeat this procedure every time you recompile an
|
|
extension, unless you are sure the AFS installation directories are
|
|
still valid.
|
|
|
|
=head2 Static Linking of a new Perl Binary
|
|
|
|
An extension that is built with the above steps is ready to use on
|
|
systems supporting dynamic loading. On systems that do not support
|
|
dynamic loading, any newly created extension has to be linked together
|
|
with the available resources. MakeMaker supports the linking process
|
|
by creating appropriate targets in the Makefile whenever an extension
|
|
is built. You can invoke the corresponding section of the makefile with
|
|
|
|
make perl
|
|
|
|
That produces a new perl binary in the current directory with all
|
|
extensions linked in that can be found in INST_ARCHLIB, SITELIBEXP,
|
|
and PERL_ARCHLIB. To do that, MakeMaker writes a new Makefile, on
|
|
UNIX, this is called F<Makefile.aperl> (may be system dependent). If you
|
|
want to force the creation of a new perl, it is recommended that you
|
|
delete this F<Makefile.aperl>, so the directories are searched through
|
|
for linkable libraries again.
|
|
|
|
The binary can be installed into the directory where perl normally
|
|
resides on your machine with
|
|
|
|
make inst_perl
|
|
|
|
To produce a perl binary with a different name than C<perl>, either say
|
|
|
|
perl Makefile.PL MAP_TARGET=myperl
|
|
make myperl
|
|
make inst_perl
|
|
|
|
or say
|
|
|
|
perl Makefile.PL
|
|
make myperl MAP_TARGET=myperl
|
|
make inst_perl MAP_TARGET=myperl
|
|
|
|
In any case you will be prompted with the correct invocation of the
|
|
C<inst_perl> target that installs the new binary into INSTALLBIN.
|
|
|
|
make inst_perl by default writes some documentation of what has been
|
|
done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This
|
|
can be bypassed by calling make pure_inst_perl.
|
|
|
|
Warning: the inst_perl: target will most probably overwrite your
|
|
existing perl binary. Use with care!
|
|
|
|
Sometimes you might want to build a statically linked perl although
|
|
your system supports dynamic loading. In this case you may explicitly
|
|
set the linktype with the invocation of the Makefile.PL or make:
|
|
|
|
perl Makefile.PL LINKTYPE=static # recommended
|
|
|
|
or
|
|
|
|
make LINKTYPE=static # works on most systems
|
|
|
|
=head2 Determination of Perl Library and Installation Locations
|
|
|
|
MakeMaker needs to know, or to guess, where certain things are
|
|
located. Especially INST_LIB and INST_ARCHLIB (where to put the files
|
|
during the make(1) run), PERL_LIB and PERL_ARCHLIB (where to read
|
|
existing modules from), and PERL_INC (header files and C<libperl*.*>).
|
|
|
|
Extensions may be built either using the contents of the perl source
|
|
directory tree or from the installed perl library. The recommended way
|
|
is to build extensions after you have run 'make install' on perl
|
|
itself. You can do that in any directory on your hard disk that is not
|
|
below the perl source tree. The support for extensions below the ext
|
|
directory of the perl distribution is only good for the standard
|
|
extensions that come with perl.
|
|
|
|
If an extension is being built below the C<ext/> directory of the perl
|
|
source then MakeMaker will set PERL_SRC automatically (e.g.,
|
|
C<../..>). If PERL_SRC is defined and the extension is recognized as
|
|
a standard extension, then other variables default to the following:
|
|
|
|
PERL_INC = PERL_SRC
|
|
PERL_LIB = PERL_SRC/lib
|
|
PERL_ARCHLIB = PERL_SRC/lib
|
|
INST_LIB = PERL_LIB
|
|
INST_ARCHLIB = PERL_ARCHLIB
|
|
|
|
If an extension is being built away from the perl source then MakeMaker
|
|
will leave PERL_SRC undefined and default to using the installed copy
|
|
of the perl library. The other variables default to the following:
|
|
|
|
PERL_INC = $archlibexp/CORE
|
|
PERL_LIB = $privlibexp
|
|
PERL_ARCHLIB = $archlibexp
|
|
INST_LIB = ./blib/lib
|
|
INST_ARCHLIB = ./blib/arch
|
|
|
|
If perl has not yet been installed then PERL_SRC can be defined on the
|
|
command line as shown in the previous section.
|
|
|
|
|
|
=head2 Which architecture dependent directory?
|
|
|
|
If you don't want to keep the defaults for the INSTALL* macros,
|
|
MakeMaker helps you to minimize the typing needed: the usual
|
|
relationship between INSTALLPRIVLIB and INSTALLARCHLIB is determined
|
|
by Configure at perl compilation time. MakeMaker supports the user who
|
|
sets INSTALLPRIVLIB. If INSTALLPRIVLIB is set, but INSTALLARCHLIB not,
|
|
then MakeMaker defaults the latter to be the same subdirectory of
|
|
INSTALLPRIVLIB as Configure decided for the counterparts in %Config,
|
|
otherwise it defaults to INSTALLPRIVLIB. The same relationship holds
|
|
for INSTALLSITELIB and INSTALLSITEARCH.
|
|
|
|
MakeMaker gives you much more freedom than needed to configure
|
|
internal variables and get different results. It is worth mentioning
|
|
that make(1) also lets you configure most of the variables that are
|
|
used in the Makefile. But in the majority of situations this will not
|
|
be necessary, and should only be done if the author of a package
|
|
recommends it (or you know what you're doing).
|
|
|
|
=head2 Using Attributes and Parameters
|
|
|
|
The following attributes may be specified as arguments to WriteMakefile()
|
|
or as NAME=VALUE pairs on the command line. Attributes that became
|
|
available with later versions of MakeMaker are indicated.
|
|
|
|
In order to maintain portability of attributes with older versions of
|
|
MakeMaker you may want to use L<App::EUMM::Upgrade> with your C<Makefile.PL>.
|
|
|
|
=over 2
|
|
|
|
=item ABSTRACT
|
|
|
|
One line description of the module. Will be included in PPD file.
|
|
|
|
=item ABSTRACT_FROM
|
|
|
|
Name of the file that contains the package description. MakeMaker looks
|
|
for a line in the POD matching /^($package\s-\s)(.*)/. This is typically
|
|
the first line in the "=head1 NAME" section. $2 becomes the abstract.
|
|
|
|
=item AUTHOR
|
|
|
|
Array of strings containing name (and email address) of package author(s).
|
|
Is used in CPAN Meta files (META.yml or META.json) and PPD
|
|
(Perl Package Description) files for PPM (Perl Package Manager).
|
|
|
|
=item BINARY_LOCATION
|
|
|
|
Used when creating PPD files for binary packages. It can be set to a
|
|
full or relative path or URL to the binary archive for a particular
|
|
architecture. For example:
|
|
|
|
perl Makefile.PL BINARY_LOCATION=x86/Agent.tar.gz
|
|
|
|
builds a PPD package that references a binary of the C<Agent> package,
|
|
located in the C<x86> directory relative to the PPD itself.
|
|
|
|
=item BUILD_REQUIRES
|
|
|
|
Available in version 6.55_03 and above.
|
|
|
|
A hash of modules that are needed to build your module but not run it.
|
|
|
|
This will go into the C<build_requires> field of your F<META.yml> and the C<build> of the C<prereqs> field of your F<META.json>.
|
|
|
|
Defaults to C<<< { "ExtUtils::MakeMaker" => 0 } >>> if this attribute is not specified.
|
|
|
|
The format is the same as PREREQ_PM.
|
|
|
|
=item C
|
|
|
|
Ref to array of *.c file names. Initialised from a directory scan
|
|
and the values portion of the XS attribute hash. This is not
|
|
currently used by MakeMaker but may be handy in Makefile.PLs.
|
|
|
|
=item CCFLAGS
|
|
|
|
String that will be included in the compiler call command line between
|
|
the arguments INC and OPTIMIZE.
|
|
|
|
The default value is taken from $Config{ccflags}. When overriding
|
|
CCFLAGS, make sure to include the $Config{ccflags} settings to avoid
|
|
binary incompatibilities.
|
|
|
|
=item CONFIG
|
|
|
|
Arrayref. E.g. [qw(archname manext)] defines ARCHNAME & MANEXT from
|
|
config.sh. MakeMaker will add to CONFIG the following values anyway:
|
|
ar
|
|
cc
|
|
cccdlflags
|
|
ccdlflags
|
|
dlext
|
|
dlsrc
|
|
ld
|
|
lddlflags
|
|
ldflags
|
|
libc
|
|
lib_ext
|
|
obj_ext
|
|
ranlib
|
|
sitelibexp
|
|
sitearchexp
|
|
so
|
|
|
|
=item CONFIGURE
|
|
|
|
CODE reference. The subroutine should return a hash reference. The
|
|
hash may contain further attributes, e.g. {LIBS =E<gt> ...}, that have to
|
|
be determined by some evaluation method.
|
|
|
|
=item CONFIGURE_REQUIRES
|
|
|
|
Available in version 6.52 and above.
|
|
|
|
A hash of modules that are required to run Makefile.PL itself, but not
|
|
to run your distribution.
|
|
|
|
This will go into the C<configure_requires> field of your F<META.yml> and the C<configure> of the C<prereqs> field of your F<META.json>.
|
|
|
|
Defaults to C<<< { "ExtUtils::MakeMaker" => 0 } >>> if this attribute is not specified.
|
|
|
|
The format is the same as PREREQ_PM.
|
|
|
|
=item DEFINE
|
|
|
|
Something like C<"-DHAVE_UNISTD_H">
|
|
|
|
=item DESTDIR
|
|
|
|
This is the root directory into which the code will be installed. It
|
|
I<prepends itself to the normal prefix>. For example, if your code
|
|
would normally go into F</usr/local/lib/perl> you could set DESTDIR=~/tmp/
|
|
and installation would go into F<~/tmp/usr/local/lib/perl>.
|
|
|
|
This is primarily of use for people who repackage Perl modules.
|
|
|
|
NOTE: Due to the nature of make, it is important that you put the trailing
|
|
slash on your DESTDIR. F<~/tmp/> not F<~/tmp>.
|
|
|
|
=item DIR
|
|
|
|
Ref to array of subdirectories containing Makefile.PLs e.g. ['sdbm']
|
|
in ext/SDBM_File
|
|
|
|
=item DISTNAME
|
|
|
|
A safe filename for the package.
|
|
|
|
Defaults to NAME below but with :: replaced with -.
|
|
|
|
For example, Foo::Bar becomes Foo-Bar.
|
|
|
|
=item DISTVNAME
|
|
|
|
Your name for distributing the package with the version number
|
|
included. This is used by 'make dist' to name the resulting archive
|
|
file.
|
|
|
|
Defaults to DISTNAME-VERSION.
|
|
|
|
For example, version 1.04 of Foo::Bar becomes Foo-Bar-1.04.
|
|
|
|
On some OS's where . has special meaning VERSION_SYM may be used in
|
|
place of VERSION.
|
|
|
|
=item DLEXT
|
|
|
|
Specifies the extension of the module's loadable object. For example:
|
|
|
|
DLEXT => 'unusual_ext', # Default value is $Config{so}
|
|
|
|
NOTE: When using this option to alter the extension of a module's
|
|
loadable object, it is also necessary that the module's pm file
|
|
specifies the same change:
|
|
|
|
local $DynaLoader::dl_dlext = 'unusual_ext';
|
|
|
|
=item DL_FUNCS
|
|
|
|
Hashref of symbol names for routines to be made available as universal
|
|
symbols. Each key/value pair consists of the package name and an
|
|
array of routine names in that package. Used only under AIX, OS/2,
|
|
VMS and Win32 at present. The routine names supplied will be expanded
|
|
in the same way as XSUB names are expanded by the XS() macro.
|
|
Defaults to
|
|
|
|
{"$(NAME)" => ["boot_$(NAME)" ] }
|
|
|
|
e.g.
|
|
|
|
{"RPC" => [qw( boot_rpcb rpcb_gettime getnetconfigent )],
|
|
"NetconfigPtr" => [ 'DESTROY'] }
|
|
|
|
Please see the L<ExtUtils::Mksymlists> documentation for more information
|
|
about the DL_FUNCS, DL_VARS and FUNCLIST attributes.
|
|
|
|
=item DL_VARS
|
|
|
|
Array of symbol names for variables to be made available as universal symbols.
|
|
Used only under AIX, OS/2, VMS and Win32 at present. Defaults to [].
|
|
(e.g. [ qw(Foo_version Foo_numstreams Foo_tree ) ])
|
|
|
|
=item EXCLUDE_EXT
|
|
|
|
Array of extension names to exclude when doing a static build. This
|
|
is ignored if INCLUDE_EXT is present. Consult INCLUDE_EXT for more
|
|
details. (e.g. [ qw( Socket POSIX ) ] )
|
|
|
|
This attribute may be most useful when specified as a string on the
|
|
command line: perl Makefile.PL EXCLUDE_EXT='Socket Safe'
|
|
|
|
=item EXE_FILES
|
|
|
|
Ref to array of executable files. The files will be copied to the
|
|
INST_SCRIPT directory. Make realclean will delete them from there
|
|
again.
|
|
|
|
If your executables start with something like #!perl or
|
|
#!/usr/bin/perl MakeMaker will change this to the path of the perl
|
|
'Makefile.PL' was invoked with so the programs will be sure to run
|
|
properly even if perl is not in /usr/bin/perl.
|
|
|
|
=item FIRST_MAKEFILE
|
|
|
|
The name of the Makefile to be produced. This is used for the second
|
|
Makefile that will be produced for the MAP_TARGET.
|
|
|
|
Defaults to 'Makefile' or 'Descrip.MMS' on VMS.
|
|
|
|
(Note: we couldn't use MAKEFILE because dmake uses this for something
|
|
else).
|
|
|
|
=item FULLPERL
|
|
|
|
Perl binary able to run this extension, load XS modules, etc...
|
|
|
|
=item FULLPERLRUN
|
|
|
|
Like PERLRUN, except it uses FULLPERL.
|
|
|
|
=item FULLPERLRUNINST
|
|
|
|
Like PERLRUNINST, except it uses FULLPERL.
|
|
|
|
=item FUNCLIST
|
|
|
|
This provides an alternate means to specify function names to be
|
|
exported from the extension. Its value is a reference to an
|
|
array of function names to be exported by the extension. These
|
|
names are passed through unaltered to the linker options file.
|
|
|
|
=item H
|
|
|
|
Ref to array of *.h file names. Similar to C.
|
|
|
|
=item IMPORTS
|
|
|
|
This attribute is used to specify names to be imported into the
|
|
extension. Takes a hash ref.
|
|
|
|
It is only used on OS/2 and Win32.
|
|
|
|
=item INC
|
|
|
|
Include file dirs eg: C<"-I/usr/5include -I/path/to/inc">
|
|
|
|
=item INCLUDE_EXT
|
|
|
|
Array of extension names to be included when doing a static build.
|
|
MakeMaker will normally build with all of the installed extensions when
|
|
doing a static build, and that is usually the desired behavior. If
|
|
INCLUDE_EXT is present then MakeMaker will build only with those extensions
|
|
which are explicitly mentioned. (e.g. [ qw( Socket POSIX ) ])
|
|
|
|
It is not necessary to mention DynaLoader or the current extension when
|
|
filling in INCLUDE_EXT. If the INCLUDE_EXT is mentioned but is empty then
|
|
only DynaLoader and the current extension will be included in the build.
|
|
|
|
This attribute may be most useful when specified as a string on the
|
|
command line: perl Makefile.PL INCLUDE_EXT='POSIX Socket Devel::Peek'
|
|
|
|
=item INSTALLARCHLIB
|
|
|
|
Used by 'make install', which copies files from INST_ARCHLIB to this
|
|
directory if INSTALLDIRS is set to perl.
|
|
|
|
=item INSTALLBIN
|
|
|
|
Directory to install binary files (e.g. tkperl) into if
|
|
INSTALLDIRS=perl.
|
|
|
|
=item INSTALLDIRS
|
|
|
|
Determines which of the sets of installation directories to choose:
|
|
perl, site or vendor. Defaults to site.
|
|
|
|
=item INSTALLMAN1DIR
|
|
|
|
=item INSTALLMAN3DIR
|
|
|
|
These directories get the man pages at 'make install' time if
|
|
INSTALLDIRS=perl. Defaults to $Config{installman*dir}.
|
|
|
|
If set to 'none', no man pages will be installed.
|
|
|
|
=item INSTALLPRIVLIB
|
|
|
|
Used by 'make install', which copies files from INST_LIB to this
|
|
directory if INSTALLDIRS is set to perl.
|
|
|
|
Defaults to $Config{installprivlib}.
|
|
|
|
=item INSTALLSCRIPT
|
|
|
|
Available in version 6.30_02 and above.
|
|
|
|
Used by 'make install' which copies files from INST_SCRIPT to this
|
|
directory if INSTALLDIRS=perl.
|
|
|
|
=item INSTALLSITEARCH
|
|
|
|
Used by 'make install', which copies files from INST_ARCHLIB to this
|
|
directory if INSTALLDIRS is set to site (default).
|
|
|
|
=item INSTALLSITEBIN
|
|
|
|
Used by 'make install', which copies files from INST_BIN to this
|
|
directory if INSTALLDIRS is set to site (default).
|
|
|
|
=item INSTALLSITELIB
|
|
|
|
Used by 'make install', which copies files from INST_LIB to this
|
|
directory if INSTALLDIRS is set to site (default).
|
|
|
|
=item INSTALLSITEMAN1DIR
|
|
|
|
=item INSTALLSITEMAN3DIR
|
|
|
|
These directories get the man pages at 'make install' time if
|
|
INSTALLDIRS=site (default). Defaults to
|
|
$(SITEPREFIX)/man/man$(MAN*EXT).
|
|
|
|
If set to 'none', no man pages will be installed.
|
|
|
|
=item INSTALLSITESCRIPT
|
|
|
|
Used by 'make install' which copies files from INST_SCRIPT to this
|
|
directory if INSTALLDIRS is set to site (default).
|
|
|
|
=item INSTALLVENDORARCH
|
|
|
|
Used by 'make install', which copies files from INST_ARCHLIB to this
|
|
directory if INSTALLDIRS is set to vendor. Note that if you do not set
|
|
this, the value of INSTALLVENDORLIB will be used, which is probably not
|
|
what you want.
|
|
|
|
=item INSTALLVENDORBIN
|
|
|
|
Used by 'make install', which copies files from INST_BIN to this
|
|
directory if INSTALLDIRS is set to vendor.
|
|
|
|
=item INSTALLVENDORLIB
|
|
|
|
Used by 'make install', which copies files from INST_LIB to this
|
|
directory if INSTALLDIRS is set to vendor.
|
|
|
|
=item INSTALLVENDORMAN1DIR
|
|
|
|
=item INSTALLVENDORMAN3DIR
|
|
|
|
These directories get the man pages at 'make install' time if
|
|
INSTALLDIRS=vendor. Defaults to $(VENDORPREFIX)/man/man$(MAN*EXT).
|
|
|
|
If set to 'none', no man pages will be installed.
|
|
|
|
=item INSTALLVENDORSCRIPT
|
|
|
|
Available in version 6.30_02 and above.
|
|
|
|
Used by 'make install' which copies files from INST_SCRIPT to this
|
|
directory if INSTALLDIRS is set to vendor.
|
|
|
|
=item INST_ARCHLIB
|
|
|
|
Same as INST_LIB for architecture dependent files.
|
|
|
|
=item INST_BIN
|
|
|
|
Directory to put real binary files during 'make'. These will be copied
|
|
to INSTALLBIN during 'make install'
|
|
|
|
=item INST_LIB
|
|
|
|
Directory where we put library files of this extension while building
|
|
it.
|
|
|
|
=item INST_MAN1DIR
|
|
|
|
Directory to hold the man pages at 'make' time
|
|
|
|
=item INST_MAN3DIR
|
|
|
|
Directory to hold the man pages at 'make' time
|
|
|
|
=item INST_SCRIPT
|
|
|
|
Directory where executable files should be installed during
|
|
'make'. Defaults to "./blib/script", just to have a dummy location during
|
|
testing. make install will copy the files in INST_SCRIPT to
|
|
INSTALLSCRIPT.
|
|
|
|
=item LD
|
|
|
|
Program to be used to link libraries for dynamic loading.
|
|
|
|
Defaults to $Config{ld}.
|
|
|
|
=item LDDLFLAGS
|
|
|
|
Any special flags that might need to be passed to ld to create a
|
|
shared library suitable for dynamic loading. It is up to the makefile
|
|
to use it. (See L<Config/lddlflags>)
|
|
|
|
Defaults to $Config{lddlflags}.
|
|
|
|
=item LDFROM
|
|
|
|
Defaults to "$(OBJECT)" and is used in the ld command to specify
|
|
what files to link/load from (also see dynamic_lib below for how to
|
|
specify ld flags)
|
|
|
|
=item LIB
|
|
|
|
LIB should only be set at C<perl Makefile.PL> time but is allowed as a
|
|
MakeMaker argument. It has the effect of setting both INSTALLPRIVLIB
|
|
and INSTALLSITELIB to that value regardless any explicit setting of
|
|
those arguments (or of PREFIX). INSTALLARCHLIB and INSTALLSITEARCH
|
|
are set to the corresponding architecture subdirectory.
|
|
|
|
=item LIBPERL_A
|
|
|
|
The filename of the perllibrary that will be used together with this
|
|
extension. Defaults to libperl.a.
|
|
|
|
=item LIBS
|
|
|
|
An anonymous array of alternative library
|
|
specifications to be searched for (in order) until
|
|
at least one library is found. E.g.
|
|
|
|
'LIBS' => ["-lgdbm", "-ldbm -lfoo", "-L/path -ldbm.nfs"]
|
|
|
|
Mind, that any element of the array
|
|
contains a complete set of arguments for the ld
|
|
command. So do not specify
|
|
|
|
'LIBS' => ["-ltcl", "-ltk", "-lX11"]
|
|
|
|
See ODBM_File/Makefile.PL for an example, where an array is needed. If
|
|
you specify a scalar as in
|
|
|
|
'LIBS' => "-ltcl -ltk -lX11"
|
|
|
|
MakeMaker will turn it into an array with one element.
|
|
|
|
=item LICENSE
|
|
|
|
Available in version 6.31 and above.
|
|
|
|
The licensing terms of your distribution. Generally it's "perl_5" for the
|
|
same license as Perl itself.
|
|
|
|
See L<CPAN::Meta::Spec> for the list of options.
|
|
|
|
Defaults to "unknown".
|
|
|
|
=item LINKTYPE
|
|
|
|
'static' or 'dynamic' (default unless usedl=undef in
|
|
config.sh). Should only be used to force static linking (also see
|
|
linkext below).
|
|
|
|
=item MAGICXS
|
|
|
|
Available in version 6.8305 and above.
|
|
|
|
When this is set to C<1>, C<OBJECT> will be automagically derived from
|
|
C<O_FILES>.
|
|
|
|
=item MAKE
|
|
|
|
Available in version 6.30_01 and above.
|
|
|
|
Variant of make you intend to run the generated Makefile with. This
|
|
parameter lets Makefile.PL know what make quirks to account for when
|
|
generating the Makefile.
|
|
|
|
MakeMaker also honors the MAKE environment variable. This parameter
|
|
takes precedence.
|
|
|
|
Currently the only significant values are 'dmake' and 'nmake' for Windows
|
|
users, instructing MakeMaker to generate a Makefile in the flavour of
|
|
DMake ("Dennis Vadura's Make") or Microsoft NMake respectively.
|
|
|
|
Defaults to $Config{make}, which may go looking for a Make program
|
|
in your environment.
|
|
|
|
How are you supposed to know what flavour of Make a Makefile has
|
|
been generated for if you didn't specify a value explicitly? Search
|
|
the generated Makefile for the definition of the MAKE variable,
|
|
which is used to recursively invoke the Make utility. That will tell
|
|
you what Make you're supposed to invoke the Makefile with.
|
|
|
|
=item MAKEAPERL
|
|
|
|
Boolean which tells MakeMaker that it should include the rules to
|
|
make a perl. This is handled automatically as a switch by
|
|
MakeMaker. The user normally does not need it.
|
|
|
|
=item MAKEFILE_OLD
|
|
|
|
When 'make clean' or similar is run, the $(FIRST_MAKEFILE) will be
|
|
backed up at this location.
|
|
|
|
Defaults to $(FIRST_MAKEFILE).old or $(FIRST_MAKEFILE)_old on VMS.
|
|
|
|
=item MAN1PODS
|
|
|
|
Hashref of pod-containing files. MakeMaker will default this to all
|
|
EXE_FILES files that include POD directives. The files listed
|
|
here will be converted to man pages and installed as was requested
|
|
at Configure time.
|
|
|
|
This hash should map POD files (or scripts containing POD) to the
|
|
man file names under the C<blib/man1/> directory, as in the following
|
|
example:
|
|
|
|
MAN1PODS => {
|
|
'doc/command.pod' => 'blib/man1/command.1',
|
|
'scripts/script.pl' => 'blib/man1/script.1',
|
|
}
|
|
|
|
=item MAN3PODS
|
|
|
|
Hashref that assigns to *.pm and *.pod files the files into which the
|
|
manpages are to be written. MakeMaker parses all *.pod and *.pm files
|
|
for POD directives. Files that contain POD will be the default keys of
|
|
the MAN3PODS hashref. These will then be converted to man pages during
|
|
C<make> and will be installed during C<make install>.
|
|
|
|
Example similar to MAN1PODS.
|
|
|
|
=item MAP_TARGET
|
|
|
|
If it is intended that a new perl binary be produced, this variable
|
|
may hold a name for that binary. Defaults to perl
|
|
|
|
=item META_ADD
|
|
|
|
=item META_MERGE
|
|
|
|
Available in version 6.46 and above.
|
|
|
|
A hashref of items to add to the CPAN Meta file (F<META.yml> or
|
|
F<META.json>).
|
|
|
|
They differ in how they behave if they have the same key as the
|
|
default metadata. META_ADD will override the default value with its
|
|
own. META_MERGE will merge its value with the default.
|
|
|
|
Unless you want to override the defaults, prefer META_MERGE so as to
|
|
get the advantage of any future defaults.
|
|
|
|
Where prereqs are concerned, if META_MERGE is used, prerequisites are merged
|
|
with their counterpart C<WriteMakefile()> argument
|
|
(PREREQ_PM is merged into {prereqs}{runtime}{requires},
|
|
BUILD_REQUIRES into C<{prereqs}{build}{requires}>,
|
|
CONFIGURE_REQUIRES into C<{prereqs}{configure}{requires}>,
|
|
and TEST_REQUIRES into C<{prereqs}{test}{requires})>.
|
|
When prereqs are specified with META_ADD, the only prerequisites added to the
|
|
file come from the metadata, not C<WriteMakefile()> arguments.
|
|
|
|
Note that these configuration options are only used for generating F<META.yml>
|
|
and F<META.json> -- they are NOT used for F<MYMETA.yml> and F<MYMETA.json>.
|
|
Therefore data in these fields should NOT be used for dynamic (user-side)
|
|
configuration.
|
|
|
|
By default CPAN Meta specification C<1.4> is used. In order to use
|
|
CPAN Meta specification C<2.0>, indicate with C<meta-spec> the version
|
|
you want to use.
|
|
|
|
META_MERGE => {
|
|
|
|
"meta-spec" => { version => 2 },
|
|
|
|
resources => {
|
|
|
|
repository => {
|
|
type => 'git',
|
|
url => 'git://github.com/Perl-Toolchain-Gang/ExtUtils-MakeMaker.git',
|
|
web => 'https://github.com/Perl-Toolchain-Gang/ExtUtils-MakeMaker',
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
=item MIN_PERL_VERSION
|
|
|
|
Available in version 6.48 and above.
|
|
|
|
The minimum required version of Perl for this distribution.
|
|
|
|
Either the 5.006001 or the 5.6.1 format is acceptable.
|
|
|
|
=item MYEXTLIB
|
|
|
|
If the extension links to a library that it builds, set this to the
|
|
name of the library (see SDBM_File)
|
|
|
|
=item NAME
|
|
|
|
The package representing the distribution. For example, C<Test::More>
|
|
or C<ExtUtils::MakeMaker>. It will be used to derive information about
|
|
the distribution such as the L</DISTNAME>, installation locations
|
|
within the Perl library and where XS files will be looked for by
|
|
default (see L</XS>).
|
|
|
|
C<NAME> I<must> be a valid Perl package name and it I<must> have an
|
|
associated C<.pm> file. For example, C<Foo::Bar> is a valid C<NAME>
|
|
and there must exist F<Foo/Bar.pm>. Any XS code should be in
|
|
F<Bar.xs> unless stated otherwise.
|
|
|
|
Your distribution B<must> have a C<NAME>.
|
|
|
|
=item NEEDS_LINKING
|
|
|
|
MakeMaker will figure out if an extension contains linkable code
|
|
anywhere down the directory tree, and will set this variable
|
|
accordingly, but you can speed it up a very little bit if you define
|
|
this boolean variable yourself.
|
|
|
|
=item NOECHO
|
|
|
|
Command so make does not print the literal commands it's running.
|
|
|
|
By setting it to an empty string you can generate a Makefile that
|
|
prints all commands. Mainly used in debugging MakeMaker itself.
|
|
|
|
Defaults to C<@>.
|
|
|
|
=item NORECURS
|
|
|
|
Boolean. Attribute to inhibit descending into subdirectories.
|
|
|
|
=item NO_META
|
|
|
|
When true, suppresses the generation and addition to the MANIFEST of
|
|
the META.yml and META.json module meta-data files during 'make distdir'.
|
|
|
|
Defaults to false.
|
|
|
|
=item NO_MYMETA
|
|
|
|
Available in version 6.57_02 and above.
|
|
|
|
When true, suppresses the generation of MYMETA.yml and MYMETA.json module
|
|
meta-data files during 'perl Makefile.PL'.
|
|
|
|
Defaults to false.
|
|
|
|
=item NO_PACKLIST
|
|
|
|
Available in version 6.7501 and above.
|
|
|
|
When true, suppresses the writing of C<packlist> files for installs.
|
|
|
|
Defaults to false.
|
|
|
|
=item NO_PERLLOCAL
|
|
|
|
Available in version 6.7501 and above.
|
|
|
|
When true, suppresses the appending of installations to C<perllocal>.
|
|
|
|
Defaults to false.
|
|
|
|
=item NO_VC
|
|
|
|
In general, any generated Makefile checks for the current version of
|
|
MakeMaker and the version the Makefile was built under. If NO_VC is
|
|
set, the version check is neglected. Do not write this into your
|
|
Makefile.PL, use it interactively instead.
|
|
|
|
=item OBJECT
|
|
|
|
List of object files, defaults to '$(BASEEXT)$(OBJ_EXT)', but can be a long
|
|
string or an array containing all object files, e.g. "tkpBind.o
|
|
tkpButton.o tkpCanvas.o" or ["tkpBind.o", "tkpButton.o", "tkpCanvas.o"]
|
|
|
|
(Where BASEEXT is the last component of NAME, and OBJ_EXT is $Config{obj_ext}.)
|
|
|
|
=item OPTIMIZE
|
|
|
|
Defaults to C<-O>. Set it to C<-g> to turn debugging on. The flag is
|
|
passed to subdirectory makes.
|
|
|
|
=item PERL
|
|
|
|
Perl binary for tasks that can be done by miniperl. If it contains
|
|
spaces or other shell metacharacters, it needs to be quoted in a way
|
|
that protects them, since this value is intended to be inserted in a
|
|
shell command line in the Makefile. E.g.:
|
|
|
|
# Perl executable lives in "C:/Program Files/Perl/bin"
|
|
# Normally you don't need to set this yourself!
|
|
$ perl Makefile.PL PERL='"C:/Program Files/Perl/bin/perl.exe" -w'
|
|
|
|
=item PERL_CORE
|
|
|
|
Set only when MakeMaker is building the extensions of the Perl core
|
|
distribution.
|
|
|
|
=item PERLMAINCC
|
|
|
|
The call to the program that is able to compile perlmain.c. Defaults
|
|
to $(CC).
|
|
|
|
=item PERL_ARCHLIB
|
|
|
|
Same as for PERL_LIB, but for architecture dependent files.
|
|
|
|
Used only when MakeMaker is building the extensions of the Perl core
|
|
distribution (because normally $(PERL_ARCHLIB) is automatically in @INC,
|
|
and adding it would get in the way of PERL5LIB).
|
|
|
|
=item PERL_LIB
|
|
|
|
Directory containing the Perl library to use.
|
|
|
|
Used only when MakeMaker is building the extensions of the Perl core
|
|
distribution (because normally $(PERL_LIB) is automatically in @INC,
|
|
and adding it would get in the way of PERL5LIB).
|
|
|
|
=item PERL_MALLOC_OK
|
|
|
|
defaults to 0. Should be set to TRUE if the extension can work with
|
|
the memory allocation routines substituted by the Perl malloc() subsystem.
|
|
This should be applicable to most extensions with exceptions of those
|
|
|
|
=over 4
|
|
|
|
=item *
|
|
|
|
with bugs in memory allocations which are caught by Perl's malloc();
|
|
|
|
=item *
|
|
|
|
which interact with the memory allocator in other ways than via
|
|
malloc(), realloc(), free(), calloc(), sbrk() and brk();
|
|
|
|
=item *
|
|
|
|
which rely on special alignment which is not provided by Perl's malloc().
|
|
|
|
=back
|
|
|
|
B<NOTE.> Neglecting to set this flag in I<any one> of the loaded extension
|
|
nullifies many advantages of Perl's malloc(), such as better usage of
|
|
system resources, error detection, memory usage reporting, catchable failure
|
|
of memory allocations, etc.
|
|
|
|
=item PERLPREFIX
|
|
|
|
Directory under which core modules are to be installed.
|
|
|
|
Defaults to $Config{installprefixexp}, falling back to
|
|
$Config{installprefix}, $Config{prefixexp} or $Config{prefix} should
|
|
$Config{installprefixexp} not exist.
|
|
|
|
Overridden by PREFIX.
|
|
|
|
=item PERLRUN
|
|
|
|
Use this instead of $(PERL) when you wish to run perl. It will set up
|
|
extra necessary flags for you.
|
|
|
|
=item PERLRUNINST
|
|
|
|
Use this instead of $(PERL) when you wish to run perl to work with
|
|
modules. It will add things like -I$(INST_ARCH) and other necessary
|
|
flags so perl can see the modules you're about to install.
|
|
|
|
=item PERL_SRC
|
|
|
|
Directory containing the Perl source code (use of this should be
|
|
avoided, it may be undefined)
|
|
|
|
=item PERM_DIR
|
|
|
|
Available in version 6.51_01 and above.
|
|
|
|
Desired permission for directories. Defaults to C<755>.
|
|
|
|
=item PERM_RW
|
|
|
|
Desired permission for read/writable files. Defaults to C<644>.
|
|
|
|
=item PERM_RWX
|
|
|
|
Desired permission for executable files. Defaults to C<755>.
|
|
|
|
=item PL_FILES
|
|
|
|
MakeMaker can run programs to generate files for you at build time.
|
|
By default any file named *.PL (except Makefile.PL and Build.PL) in
|
|
the top level directory will be assumed to be a Perl program and run
|
|
passing its own basename in as an argument. This basename is actually a build
|
|
target, and there is an intention, but not a requirement, that the *.PL file
|
|
make the file passed to to as an argument. For example...
|
|
|
|
perl foo.PL foo
|
|
|
|
This behavior can be overridden by supplying your own set of files to
|
|
search. PL_FILES accepts a hash ref, the key being the file to run
|
|
and the value is passed in as the first argument when the PL file is run.
|
|
|
|
PL_FILES => {'bin/foobar.PL' => 'bin/foobar'}
|
|
|
|
PL_FILES => {'foo.PL' => 'foo.c'}
|
|
|
|
Would run bin/foobar.PL like this:
|
|
|
|
perl bin/foobar.PL bin/foobar
|
|
|
|
If multiple files from one program are desired an array ref can be used.
|
|
|
|
PL_FILES => {'bin/foobar.PL' => [qw(bin/foobar1 bin/foobar2)]}
|
|
|
|
In this case the program will be run multiple times using each target file.
|
|
|
|
perl bin/foobar.PL bin/foobar1
|
|
perl bin/foobar.PL bin/foobar2
|
|
|
|
PL files are normally run B<after> pm_to_blib and include INST_LIB and
|
|
INST_ARCH in their C<@INC>, so the just built modules can be
|
|
accessed... unless the PL file is making a module (or anything else in
|
|
PM) in which case it is run B<before> pm_to_blib and does not include
|
|
INST_LIB and INST_ARCH in its C<@INC>. This apparently odd behavior
|
|
is there for backwards compatibility (and it's somewhat DWIM). The argument
|
|
passed to the .PL is set up as a target to build in the Makefile. In other
|
|
sections such as C<postamble> you can specify a dependency on the
|
|
filename/argument that the .PL is supposed (or will have, now that that is
|
|
is a dependency) to generate. Note the file to be generated will still be
|
|
generated and the .PL will still run even without an explicit dependency created
|
|
by you, since the C<all> target still depends on running all eligible to run.PL
|
|
files.
|
|
|
|
=item PM
|
|
|
|
Hashref of .pm files and *.pl files to be installed. e.g.
|
|
|
|
{'name_of_file.pm' => '$(INST_LIB)/install_as.pm'}
|
|
|
|
By default this will include *.pm and *.pl and the files found in
|
|
the PMLIBDIRS directories. Defining PM in the
|
|
Makefile.PL will override PMLIBDIRS.
|
|
|
|
=item PMLIBDIRS
|
|
|
|
Ref to array of subdirectories containing library files. Defaults to
|
|
[ 'lib', $(BASEEXT) ]. The directories will be scanned and I<any> files
|
|
they contain will be installed in the corresponding location in the
|
|
library. A libscan() method can be used to alter the behaviour.
|
|
Defining PM in the Makefile.PL will override PMLIBDIRS.
|
|
|
|
(Where BASEEXT is the last component of NAME.)
|
|
|
|
=item PM_FILTER
|
|
|
|
A filter program, in the traditional Unix sense (input from stdin, output
|
|
to stdout) that is passed on each .pm file during the build (in the
|
|
pm_to_blib() phase). It is empty by default, meaning no filtering is done.
|
|
You could use:
|
|
|
|
PM_FILTER => 'perl -ne "print unless /^\\#/"',
|
|
|
|
to remove all the leading comments on the fly during the build. In order
|
|
to be as portable as possible, please consider using a Perl one-liner
|
|
rather than Unix (or other) utilities, as above. The # is escaped for
|
|
the Makefile, since what is going to be generated will then be:
|
|
|
|
PM_FILTER = perl -ne "print unless /^\#/"
|
|
|
|
Without the \ before the #, we'd have the start of a Makefile comment,
|
|
and the macro would be incorrectly defined.
|
|
|
|
You will almost certainly be better off using the C<PL_FILES> system,
|
|
instead. See above, or the L<ExtUtils::MakeMaker::FAQ> entry.
|
|
|
|
=item POLLUTE
|
|
|
|
Release 5.005 grandfathered old global symbol names by providing preprocessor
|
|
macros for extension source compatibility. As of release 5.6, these
|
|
preprocessor definitions are not available by default. The POLLUTE flag
|
|
specifies that the old names should still be defined:
|
|
|
|
perl Makefile.PL POLLUTE=1
|
|
|
|
Please inform the module author if this is necessary to successfully install
|
|
a module under 5.6 or later.
|
|
|
|
=item PPM_INSTALL_EXEC
|
|
|
|
Name of the executable used to run C<PPM_INSTALL_SCRIPT> below. (e.g. perl)
|
|
|
|
=item PPM_INSTALL_SCRIPT
|
|
|
|
Name of the script that gets executed by the Perl Package Manager after
|
|
the installation of a package.
|
|
|
|
=item PPM_UNINSTALL_EXEC
|
|
|
|
Available in version 6.8502 and above.
|
|
|
|
Name of the executable used to run C<PPM_UNINSTALL_SCRIPT> below. (e.g. perl)
|
|
|
|
=item PPM_UNINSTALL_SCRIPT
|
|
|
|
Available in version 6.8502 and above.
|
|
|
|
Name of the script that gets executed by the Perl Package Manager before
|
|
the removal of a package.
|
|
|
|
=item PREFIX
|
|
|
|
This overrides all the default install locations. Man pages,
|
|
libraries, scripts, etc... MakeMaker will try to make an educated
|
|
guess about where to place things under the new PREFIX based on your
|
|
Config defaults. Failing that, it will fall back to a structure
|
|
which should be sensible for your platform.
|
|
|
|
If you specify LIB or any INSTALL* variables they will not be affected
|
|
by the PREFIX.
|
|
|
|
=item PREREQ_FATAL
|
|
|
|
Bool. If this parameter is true, failing to have the required modules
|
|
(or the right versions thereof) will be fatal. C<perl Makefile.PL>
|
|
will C<die> instead of simply informing the user of the missing dependencies.
|
|
|
|
It is I<extremely> rare to have to use C<PREREQ_FATAL>. Its use by module
|
|
authors is I<strongly discouraged> and should never be used lightly.
|
|
|
|
For dependencies that are required in order to run C<Makefile.PL>,
|
|
see C<CONFIGURE_REQUIRES>.
|
|
|
|
Module installation tools have ways of resolving unmet dependencies but
|
|
to do that they need a F<Makefile>. Using C<PREREQ_FATAL> breaks this.
|
|
That's bad.
|
|
|
|
Assuming you have good test coverage, your tests should fail with
|
|
missing dependencies informing the user more strongly that something
|
|
is wrong. You can write a F<t/00compile.t> test which will simply
|
|
check that your code compiles and stop "make test" prematurely if it
|
|
doesn't. See L<Test::More/BAIL_OUT> for more details.
|
|
|
|
|
|
=item PREREQ_PM
|
|
|
|
A hash of modules that are needed to run your module. The keys are
|
|
the module names ie. Test::More, and the minimum version is the
|
|
value. If the required version number is 0 any version will do.
|
|
The versions given may be a Perl v-string (see L<version>) or a range
|
|
(see L<CPAN::Meta::Requirements>).
|
|
|
|
This will go into the C<requires> field of your F<META.yml> and the
|
|
C<runtime> of the C<prereqs> field of your F<META.json>.
|
|
|
|
PREREQ_PM => {
|
|
# Require Test::More at least 0.47
|
|
"Test::More" => "0.47",
|
|
|
|
# Require any version of Acme::Buffy
|
|
"Acme::Buffy" => 0,
|
|
}
|
|
|
|
=item PREREQ_PRINT
|
|
|
|
Bool. If this parameter is true, the prerequisites will be printed to
|
|
stdout and MakeMaker will exit. The output format is an evalable hash
|
|
ref.
|
|
|
|
$PREREQ_PM = {
|
|
'A::B' => Vers1,
|
|
'C::D' => Vers2,
|
|
...
|
|
};
|
|
|
|
If a distribution defines a minimal required perl version, this is
|
|
added to the output as an additional line of the form:
|
|
|
|
$MIN_PERL_VERSION = '5.008001';
|
|
|
|
If BUILD_REQUIRES is not empty, it will be dumped as $BUILD_REQUIRES hashref.
|
|
|
|
=item PRINT_PREREQ
|
|
|
|
RedHatism for C<PREREQ_PRINT>. The output format is different, though:
|
|
|
|
perl(A::B)>=Vers1 perl(C::D)>=Vers2 ...
|
|
|
|
A minimal required perl version, if present, will look like this:
|
|
|
|
perl(perl)>=5.008001
|
|
|
|
=item SITEPREFIX
|
|
|
|
Like PERLPREFIX, but only for the site install locations.
|
|
|
|
Defaults to $Config{siteprefixexp}. Perls prior to 5.6.0 didn't have
|
|
an explicit siteprefix in the Config. In those cases
|
|
$Config{installprefix} will be used.
|
|
|
|
Overridable by PREFIX
|
|
|
|
=item SIGN
|
|
|
|
Available in version 6.18 and above.
|
|
|
|
When true, perform the generation and addition to the MANIFEST of the
|
|
SIGNATURE file in the distdir during 'make distdir', via 'cpansign
|
|
-s'.
|
|
|
|
Note that you need to install the Module::Signature module to
|
|
perform this operation.
|
|
|
|
Defaults to false.
|
|
|
|
=item SKIP
|
|
|
|
Arrayref. E.g. [qw(name1 name2)] skip (do not write) sections of the
|
|
Makefile. Caution! Do not use the SKIP attribute for the negligible
|
|
speedup. It may seriously damage the resulting Makefile. Only use it
|
|
if you really need it.
|
|
|
|
=item TEST_REQUIRES
|
|
|
|
Available in version 6.64 and above.
|
|
|
|
A hash of modules that are needed to test your module but not run or
|
|
build it.
|
|
|
|
This will go into the C<build_requires> field of your F<META.yml> and the C<test> of the C<prereqs> field of your F<META.json>.
|
|
|
|
The format is the same as PREREQ_PM.
|
|
|
|
=item TYPEMAPS
|
|
|
|
Ref to array of typemap file names. Use this when the typemaps are
|
|
in some directory other than the current directory or when they are
|
|
not named B<typemap>. The last typemap in the list takes
|
|
precedence. A typemap in the current directory has highest
|
|
precedence, even if it isn't listed in TYPEMAPS. The default system
|
|
typemap has lowest precedence.
|
|
|
|
=item VENDORPREFIX
|
|
|
|
Like PERLPREFIX, but only for the vendor install locations.
|
|
|
|
Defaults to $Config{vendorprefixexp}.
|
|
|
|
Overridable by PREFIX
|
|
|
|
=item VERBINST
|
|
|
|
If true, make install will be verbose
|
|
|
|
=item VERSION
|
|
|
|
Your version number for distributing the package. This defaults to
|
|
0.1.
|
|
|
|
=item VERSION_FROM
|
|
|
|
Instead of specifying the VERSION in the Makefile.PL you can let
|
|
MakeMaker parse a file to determine the version number. The parsing
|
|
routine requires that the file named by VERSION_FROM contains one
|
|
single line to compute the version number. The first line in the file
|
|
that contains something like a $VERSION assignment or C<package Name
|
|
VERSION> will be used. The following lines will be parsed o.k.:
|
|
|
|
# Good
|
|
package Foo::Bar 1.23; # 1.23
|
|
$VERSION = '1.00'; # 1.00
|
|
*VERSION = \'1.01'; # 1.01
|
|
($VERSION) = q$Revision$ =~ /(\d+)/g; # The digits in $Revision$
|
|
$FOO::VERSION = '1.10'; # 1.10
|
|
*FOO::VERSION = \'1.11'; # 1.11
|
|
|
|
but these will fail:
|
|
|
|
# Bad
|
|
my $VERSION = '1.01';
|
|
local $VERSION = '1.02';
|
|
local $FOO::VERSION = '1.30';
|
|
|
|
(Putting C<my> or C<local> on the preceding line will work o.k.)
|
|
|
|
"Version strings" are incompatible and should not be used.
|
|
|
|
# Bad
|
|
$VERSION = 1.2.3;
|
|
$VERSION = v1.2.3;
|
|
|
|
L<version> objects are fine. As of MakeMaker 6.35 version.pm will be
|
|
automatically loaded, but you must declare the dependency on version.pm.
|
|
For compatibility with older MakeMaker you should load on the same line
|
|
as $VERSION is declared.
|
|
|
|
# All on one line
|
|
use version; our $VERSION = qv(1.2.3);
|
|
|
|
The file named in VERSION_FROM is not added as a dependency to
|
|
Makefile. This is not really correct, but it would be a major pain
|
|
during development to have to rewrite the Makefile for any smallish
|
|
change in that file. If you want to make sure that the Makefile
|
|
contains the correct VERSION macro after any change of the file, you
|
|
would have to do something like
|
|
|
|
depend => { Makefile => '$(VERSION_FROM)' }
|
|
|
|
See attribute C<depend> below.
|
|
|
|
=item VERSION_SYM
|
|
|
|
A sanitized VERSION with . replaced by _. For places where . has
|
|
special meaning (some filesystems, RCS labels, etc...)
|
|
|
|
=item XS
|
|
|
|
Hashref of .xs files. MakeMaker will default this. e.g.
|
|
|
|
{'name_of_file.xs' => 'name_of_file.c'}
|
|
|
|
The .c files will automatically be included in the list of files
|
|
deleted by a make clean.
|
|
|
|
=item XSBUILD
|
|
|
|
Available in version 7.12 and above.
|
|
|
|
Hashref with options controlling the operation of C<XSMULTI>:
|
|
|
|
{
|
|
xs => {
|
|
all => {
|
|
# options applying to all .xs files for this distribution
|
|
},
|
|
'lib/Class/Name/File' => { # specifically for this file
|
|
DEFINE => '-Dfunktastic', # defines for only this file
|
|
INC => "-I$funkyliblocation", # include flags for only this file
|
|
# OBJECT => 'lib/Class/Name/File$(OBJ_EXT)', # default
|
|
LDFROM => "lib/Class/Name/File\$(OBJ_EXT) $otherfile\$(OBJ_EXT)", # what's linked
|
|
},
|
|
},
|
|
}
|
|
|
|
Note C<xs> is the file-extension. More possibilities may arise in the
|
|
future. Note that object names are specified without their XS extension.
|
|
|
|
C<LDFROM> defaults to the same as C<OBJECT>. C<OBJECT> defaults to,
|
|
for C<XSMULTI>, just the XS filename with the extension replaced with
|
|
the compiler-specific object-file extension.
|
|
|
|
The distinction between C<OBJECT> and C<LDFROM>: C<OBJECT> is the make
|
|
target, so make will try to build it. However, C<LDFROM> is what will
|
|
actually be linked together to make the shared object or static library
|
|
(SO/SL), so if you override it, make sure it includes what you want to
|
|
make the final SO/SL, almost certainly including the XS basename with
|
|
C<$(OBJ_EXT)> appended.
|
|
|
|
=item XSMULTI
|
|
|
|
Available in version 7.12 and above.
|
|
|
|
When this is set to C<1>, multiple XS files may be placed under F<lib/>
|
|
next to their corresponding C<*.pm> files (this is essential for compiling
|
|
with the correct C<VERSION> values). This feature should be considered
|
|
experimental, and details of it may change.
|
|
|
|
This feature was inspired by, and small portions of code copied from,
|
|
L<ExtUtils::MakeMaker::BigHelper>. Hopefully this feature will render
|
|
that module mainly obsolete.
|
|
|
|
=item XSOPT
|
|
|
|
String of options to pass to xsubpp. This might include C<-C++> or
|
|
C<-extern>. Do not include typemaps here; the TYPEMAP parameter exists for
|
|
that purpose.
|
|
|
|
=item XSPROTOARG
|
|
|
|
May be set to C<-protoypes>, C<-noprototypes> or the empty string. The
|
|
empty string is equivalent to the xsubpp default, or C<-noprototypes>.
|
|
See the xsubpp documentation for details. MakeMaker
|
|
defaults to the empty string.
|
|
|
|
=item XS_VERSION
|
|
|
|
Your version number for the .xs file of this package. This defaults
|
|
to the value of the VERSION attribute.
|
|
|
|
=back
|
|
|
|
=head2 Additional lowercase attributes
|
|
|
|
can be used to pass parameters to the methods which implement that
|
|
part of the Makefile. Parameters are specified as a hash ref but are
|
|
passed to the method as a hash.
|
|
|
|
=over 2
|
|
|
|
=item clean
|
|
|
|
{FILES => "*.xyz foo"}
|
|
|
|
=item depend
|
|
|
|
{ANY_TARGET => ANY_DEPENDENCY, ...}
|
|
|
|
(ANY_TARGET must not be given a double-colon rule by MakeMaker.)
|
|
|
|
=item dist
|
|
|
|
{TARFLAGS => 'cvfF', COMPRESS => 'gzip', SUFFIX => '.gz',
|
|
SHAR => 'shar -m', DIST_CP => 'ln', ZIP => '/bin/zip',
|
|
ZIPFLAGS => '-rl', DIST_DEFAULT => 'private tardist' }
|
|
|
|
If you specify COMPRESS, then SUFFIX should also be altered, as it is
|
|
needed to tell make the target file of the compression. Setting
|
|
DIST_CP to ln can be useful, if you need to preserve the timestamps on
|
|
your files. DIST_CP can take the values 'cp', which copies the file,
|
|
'ln', which links the file, and 'best' which copies symbolic links and
|
|
links the rest. Default is 'best'.
|
|
|
|
=item dynamic_lib
|
|
|
|
{ARMAYBE => 'ar', OTHERLDFLAGS => '...', INST_DYNAMIC_DEP => '...'}
|
|
|
|
=item linkext
|
|
|
|
{LINKTYPE => 'static', 'dynamic' or ''}
|
|
|
|
NB: Extensions that have nothing but *.pm files had to say
|
|
|
|
{LINKTYPE => ''}
|
|
|
|
with Pre-5.0 MakeMakers. Since version 5.00 of MakeMaker such a line
|
|
can be deleted safely. MakeMaker recognizes when there's nothing to
|
|
be linked.
|
|
|
|
=item macro
|
|
|
|
{ANY_MACRO => ANY_VALUE, ...}
|
|
|
|
=item postamble
|
|
|
|
Anything put here will be passed to MY::postamble() if you have one.
|
|
|
|
=item realclean
|
|
|
|
{FILES => '$(INST_ARCHAUTODIR)/*.xyz'}
|
|
|
|
=item test
|
|
|
|
Specify the targets for testing.
|
|
|
|
{TESTS => 't/*.t'}
|
|
|
|
C<RECURSIVE_TEST_FILES> can be used to include all directories
|
|
recursively under C<t> that contain C<.t> files. It will be ignored if
|
|
you provide your own C<TESTS> attribute, defaults to false.
|
|
|
|
{RECURSIVE_TEST_FILES=>1}
|
|
|
|
This is supported since 6.76
|
|
|
|
=item tool_autosplit
|
|
|
|
{MAXLEN => 8}
|
|
|
|
=back
|
|
|
|
=head2 Overriding MakeMaker Methods
|
|
|
|
If you cannot achieve the desired Makefile behaviour by specifying
|
|
attributes you may define private subroutines in the Makefile.PL.
|
|
Each subroutine returns the text it wishes to have written to
|
|
the Makefile. To override a section of the Makefile you can
|
|
either say:
|
|
|
|
sub MY::c_o { "new literal text" }
|
|
|
|
or you can edit the default by saying something like:
|
|
|
|
package MY; # so that "SUPER" works right
|
|
sub c_o {
|
|
my $inherited = shift->SUPER::c_o(@_);
|
|
$inherited =~ s/old text/new text/;
|
|
$inherited;
|
|
}
|
|
|
|
If you are running experiments with embedding perl as a library into
|
|
other applications, you might find MakeMaker is not sufficient. You'd
|
|
better have a look at ExtUtils::Embed which is a collection of utilities
|
|
for embedding.
|
|
|
|
If you still need a different solution, try to develop another
|
|
subroutine that fits your needs and submit the diffs to
|
|
C<makemaker@perl.org>
|
|
|
|
For a complete description of all MakeMaker methods see
|
|
L<ExtUtils::MM_Unix>.
|
|
|
|
Here is a simple example of how to add a new target to the generated
|
|
Makefile:
|
|
|
|
sub MY::postamble {
|
|
return <<'MAKE_FRAG';
|
|
$(MYEXTLIB): sdbm/Makefile
|
|
cd sdbm && $(MAKE) all
|
|
|
|
MAKE_FRAG
|
|
}
|
|
|
|
=head2 The End Of Cargo Cult Programming
|
|
|
|
WriteMakefile() now does some basic sanity checks on its parameters to
|
|
protect against typos and malformatted values. This means some things
|
|
which happened to work in the past will now throw warnings and
|
|
possibly produce internal errors.
|
|
|
|
Some of the most common mistakes:
|
|
|
|
=over 2
|
|
|
|
=item C<< MAN3PODS => ' ' >>
|
|
|
|
This is commonly used to suppress the creation of man pages. MAN3PODS
|
|
takes a hash ref not a string, but the above worked by accident in old
|
|
versions of MakeMaker.
|
|
|
|
The correct code is C<< MAN3PODS => { } >>.
|
|
|
|
=back
|
|
|
|
|
|
=head2 Hintsfile support
|
|
|
|
MakeMaker.pm uses the architecture-specific information from
|
|
Config.pm. In addition it evaluates architecture specific hints files
|
|
in a C<hints/> directory. The hints files are expected to be named
|
|
like their counterparts in C<PERL_SRC/hints>, but with an C<.pl> file
|
|
name extension (eg. C<next_3_2.pl>). They are simply C<eval>ed by
|
|
MakeMaker within the WriteMakefile() subroutine, and can be used to
|
|
execute commands as well as to include special variables. The rules
|
|
which hintsfile is chosen are the same as in Configure.
|
|
|
|
The hintsfile is eval()ed immediately after the arguments given to
|
|
WriteMakefile are stuffed into a hash reference $self but before this
|
|
reference becomes blessed. So if you want to do the equivalent to
|
|
override or create an attribute you would say something like
|
|
|
|
$self->{LIBS} = ['-ldbm -lucb -lc'];
|
|
|
|
=head2 Distribution Support
|
|
|
|
For authors of extensions MakeMaker provides several Makefile
|
|
targets. Most of the support comes from the ExtUtils::Manifest module,
|
|
where additional documentation can be found.
|
|
|
|
=over 4
|
|
|
|
=item make distcheck
|
|
|
|
reports which files are below the build directory but not in the
|
|
MANIFEST file and vice versa. (See ExtUtils::Manifest::fullcheck() for
|
|
details)
|
|
|
|
=item make skipcheck
|
|
|
|
reports which files are skipped due to the entries in the
|
|
C<MANIFEST.SKIP> file (See ExtUtils::Manifest::skipcheck() for
|
|
details)
|
|
|
|
=item make distclean
|
|
|
|
does a realclean first and then the distcheck. Note that this is not
|
|
needed to build a new distribution as long as you are sure that the
|
|
MANIFEST file is ok.
|
|
|
|
=item make veryclean
|
|
|
|
does a realclean first and then removes backup files such as C<*~>,
|
|
C<*.bak>, C<*.old> and C<*.orig>
|
|
|
|
=item make manifest
|
|
|
|
rewrites the MANIFEST file, adding all remaining files found (See
|
|
ExtUtils::Manifest::mkmanifest() for details)
|
|
|
|
=item make distdir
|
|
|
|
Copies all the files that are in the MANIFEST file to a newly created
|
|
directory with the name C<$(DISTNAME)-$(VERSION)>. If that directory
|
|
exists, it will be removed first.
|
|
|
|
Additionally, it will create META.yml and META.json module meta-data file
|
|
in the distdir and add this to the distdir's MANIFEST. You can shut this
|
|
behavior off with the NO_META flag.
|
|
|
|
=item make disttest
|
|
|
|
Makes a distdir first, and runs a C<perl Makefile.PL>, a make, and
|
|
a make test in that directory.
|
|
|
|
=item make tardist
|
|
|
|
First does a distdir. Then a command $(PREOP) which defaults to a null
|
|
command, followed by $(TO_UNIX), which defaults to a null command under
|
|
UNIX, and will convert files in distribution directory to UNIX format
|
|
otherwise. Next it runs C<tar> on that directory into a tarfile and
|
|
deletes the directory. Finishes with a command $(POSTOP) which
|
|
defaults to a null command.
|
|
|
|
=item make dist
|
|
|
|
Defaults to $(DIST_DEFAULT) which in turn defaults to tardist.
|
|
|
|
=item make uutardist
|
|
|
|
Runs a tardist first and uuencodes the tarfile.
|
|
|
|
=item make shdist
|
|
|
|
First does a distdir. Then a command $(PREOP) which defaults to a null
|
|
command. Next it runs C<shar> on that directory into a sharfile and
|
|
deletes the intermediate directory again. Finishes with a command
|
|
$(POSTOP) which defaults to a null command. Note: For shdist to work
|
|
properly a C<shar> program that can handle directories is mandatory.
|
|
|
|
=item make zipdist
|
|
|
|
First does a distdir. Then a command $(PREOP) which defaults to a null
|
|
command. Runs C<$(ZIP) $(ZIPFLAGS)> on that directory into a
|
|
zipfile. Then deletes that directory. Finishes with a command
|
|
$(POSTOP) which defaults to a null command.
|
|
|
|
=item make ci
|
|
|
|
Does a $(CI) and a $(RCS_LABEL) on all files in the MANIFEST file.
|
|
|
|
=back
|
|
|
|
Customization of the dist targets can be done by specifying a hash
|
|
reference to the dist attribute of the WriteMakefile call. The
|
|
following parameters are recognized:
|
|
|
|
CI ('ci -u')
|
|
COMPRESS ('gzip --best')
|
|
POSTOP ('@ :')
|
|
PREOP ('@ :')
|
|
TO_UNIX (depends on the system)
|
|
RCS_LABEL ('rcs -q -Nv$(VERSION_SYM):')
|
|
SHAR ('shar')
|
|
SUFFIX ('.gz')
|
|
TAR ('tar')
|
|
TARFLAGS ('cvf')
|
|
ZIP ('zip')
|
|
ZIPFLAGS ('-r')
|
|
|
|
An example:
|
|
|
|
WriteMakefile(
|
|
...other options...
|
|
dist => {
|
|
COMPRESS => "bzip2",
|
|
SUFFIX => ".bz2"
|
|
}
|
|
);
|
|
|
|
|
|
=head2 Module Meta-Data (META and MYMETA)
|
|
|
|
Long plaguing users of MakeMaker based modules has been the problem of
|
|
getting basic information about the module out of the sources
|
|
I<without> running the F<Makefile.PL> and doing a bunch of messy
|
|
heuristics on the resulting F<Makefile>. Over the years, it has become
|
|
standard to keep this information in one or more CPAN Meta files
|
|
distributed with each distribution.
|
|
|
|
The original format of CPAN Meta files was L<YAML> and the corresponding
|
|
file was called F<META.yml>. In 2010, version 2 of the L<CPAN::Meta::Spec>
|
|
was released, which mandates JSON format for the metadata in order to
|
|
overcome certain compatibility issues between YAML serializers and to
|
|
avoid breaking older clients unable to handle a new version of the spec.
|
|
The L<CPAN::Meta> library is now standard for accessing old and new-style
|
|
Meta files.
|
|
|
|
If L<CPAN::Meta> is installed, MakeMaker will automatically generate
|
|
F<META.json> and F<META.yml> files for you and add them to your F<MANIFEST> as
|
|
part of the 'distdir' target (and thus the 'dist' target). This is intended to
|
|
seamlessly and rapidly populate CPAN with module meta-data. If you wish to
|
|
shut this feature off, set the C<NO_META> C<WriteMakefile()> flag to true.
|
|
|
|
At the 2008 QA Hackathon in Oslo, Perl module toolchain maintainers agreed
|
|
to use the CPAN Meta format to communicate post-configuration requirements
|
|
between toolchain components. These files, F<MYMETA.json> and F<MYMETA.yml>,
|
|
are generated when F<Makefile.PL> generates a F<Makefile> (if L<CPAN::Meta>
|
|
is installed). Clients like L<CPAN> or L<CPANPLUS> will read these
|
|
files to see what prerequisites must be fulfilled before building or testing
|
|
the distribution. If you wish to shut this feature off, set the C<NO_MYMETA>
|
|
C<WriteMakeFile()> flag to true.
|
|
|
|
=head2 Disabling an extension
|
|
|
|
If some events detected in F<Makefile.PL> imply that there is no way
|
|
to create the Module, but this is a normal state of things, then you
|
|
can create a F<Makefile> which does nothing, but succeeds on all the
|
|
"usual" build targets. To do so, use
|
|
|
|
use ExtUtils::MakeMaker qw(WriteEmptyMakefile);
|
|
WriteEmptyMakefile();
|
|
|
|
instead of WriteMakefile().
|
|
|
|
This may be useful if other modules expect this module to be I<built>
|
|
OK, as opposed to I<work> OK (say, this system-dependent module builds
|
|
in a subdirectory of some other distribution, or is listed as a
|
|
dependency in a CPAN::Bundle, but the functionality is supported by
|
|
different means on the current architecture).
|
|
|
|
=head2 Other Handy Functions
|
|
|
|
=over 4
|
|
|
|
=item prompt
|
|
|
|
my $value = prompt($message);
|
|
my $value = prompt($message, $default);
|
|
|
|
The C<prompt()> function provides an easy way to request user input
|
|
used to write a makefile. It displays the $message as a prompt for
|
|
input. If a $default is provided it will be used as a default. The
|
|
function returns the $value selected by the user.
|
|
|
|
If C<prompt()> detects that it is not running interactively and there
|
|
is nothing on STDIN or if the PERL_MM_USE_DEFAULT environment variable
|
|
is set to true, the $default will be used without prompting. This
|
|
prevents automated processes from blocking on user input.
|
|
|
|
If no $default is provided an empty string will be used instead.
|
|
|
|
=item os_unsupported
|
|
|
|
os_unsupported();
|
|
os_unsupported if $^O eq 'MSWin32';
|
|
|
|
The C<os_unsupported()> function provides a way to correctly exit your
|
|
C<Makefile.PL> before calling C<WriteMakefile>. It is essentially a
|
|
C<die> with the message "OS unsupported".
|
|
|
|
This is supported since 7.26
|
|
|
|
=back
|
|
|
|
=head2 Supported versions of Perl
|
|
|
|
Please note that while this module works on Perl 5.6, it is no longer
|
|
being routinely tested on 5.6 - the earliest Perl version being routinely
|
|
tested, and expressly supported, is 5.8.1. However, patches to repair
|
|
any breakage on 5.6 are still being accepted.
|
|
|
|
=head1 ENVIRONMENT
|
|
|
|
=over 4
|
|
|
|
=item PERL_MM_OPT
|
|
|
|
Command line options used by C<MakeMaker-E<gt>new()>, and thus by
|
|
C<WriteMakefile()>. The string is split as the shell would, and the result
|
|
is processed before any actual command line arguments are processed.
|
|
|
|
PERL_MM_OPT='CCFLAGS="-Wl,-rpath -Wl,/foo/bar/lib" LIBS="-lwibble -lwobble"'
|
|
|
|
=item PERL_MM_USE_DEFAULT
|
|
|
|
If set to a true value then MakeMaker's prompt function will
|
|
always return the default without waiting for user input.
|
|
|
|
=item PERL_CORE
|
|
|
|
Same as the PERL_CORE parameter. The parameter overrides this.
|
|
|
|
=back
|
|
|
|
=head1 SEE ALSO
|
|
|
|
L<Module::Build> is a pure-Perl alternative to MakeMaker which does
|
|
not rely on make or any other external utility. It is easier to
|
|
extend to suit your needs.
|
|
|
|
L<Module::Install> is a wrapper around MakeMaker which adds features
|
|
not normally available.
|
|
|
|
L<ExtUtils::ModuleMaker> and L<Module::Starter> are both modules to
|
|
help you setup your distribution.
|
|
|
|
L<CPAN::Meta> and L<CPAN::Meta::Spec> explain CPAN Meta files in detail.
|
|
|
|
L<File::ShareDir::Install> makes it easy to install static, sometimes
|
|
also referred to as 'shared' files. L<File::ShareDir> helps accessing
|
|
the shared files after installation.
|
|
|
|
L<Dist::Zilla> makes it easy for the module author to create MakeMaker-based
|
|
distributions with lots of bells and whistles.
|
|
|
|
=head1 AUTHORS
|
|
|
|
Andy Dougherty C<doughera@lafayette.edu>, Andreas KE<ouml>nig
|
|
C<andreas.koenig@mind.de>, Tim Bunce C<timb@cpan.org>. VMS
|
|
support by Charles Bailey C<bailey@newman.upenn.edu>. OS/2 support
|
|
by Ilya Zakharevich C<ilya@math.ohio-state.edu>.
|
|
|
|
Currently maintained by Michael G Schwern C<schwern@pobox.com>
|
|
|
|
Send patches and ideas to C<makemaker@perl.org>.
|
|
|
|
Send bug reports via http://rt.cpan.org/. Please send your
|
|
generated Makefile along with your report.
|
|
|
|
For more up-to-date information, see L<https://metacpan.org/release/ExtUtils-MakeMaker>.
|
|
|
|
Repository available at L<https://github.com/Perl-Toolchain-Gang/ExtUtils-MakeMaker>.
|
|
|
|
=head1 LICENSE
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the same terms as Perl itself.
|
|
|
|
See L<http://www.perl.com/perl/misc/Artistic.html>
|
|
|
|
|
|
=cut
|