[scpubgit/stemmatology.git] / TreeOfTexts / inc / Module / Install / Makefile.pm

#line 1
package Module::Install::Makefile;

use strict 'vars';
use ExtUtils::MakeMaker   ();
use Module::Install::Base ();
use Fcntl qw/:flock :seek/;

use vars qw{$VERSION @ISA $ISCORE};
BEGIN {
	$VERSION = '1.00';
	@ISA     = 'Module::Install::Base';
	$ISCORE  = 1;
}

sub Makefile { $_[0] }

my %seen = ();

sub prompt {
	shift;

	# Infinite loop protection
	my @c = caller();
	if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
		die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
	}

	# In automated testing or non-interactive session, always use defaults
	if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
		local $ENV{PERL_MM_USE_DEFAULT} = 1;
		goto &ExtUtils::MakeMaker::prompt;
	} else {
		goto &ExtUtils::MakeMaker::prompt;
	}
}

# Store a cleaned up version of the MakeMaker version,
# since we need to behave differently in a variety of
# ways based on the MM version.
my $makemaker = eval $ExtUtils::MakeMaker::VERSION;

# If we are passed a param, do a "newer than" comparison.
# Otherwise, just return the MakeMaker version.
sub makemaker {
	( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0
}

# Ripped from ExtUtils::MakeMaker 6.56, and slightly modified
# as we only need to know here whether the attribute is an array
# or a hash or something else (which may or may not be appendable).
my %makemaker_argtype = (
 C                  => 'ARRAY',
 CONFIG             => 'ARRAY',
# CONFIGURE          => 'CODE', # ignore
 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', # ignore ''
 MAN1PODS           => 'HASH',
 MAN3PODS           => 'HASH',
 META_ADD           => 'HASH',
 META_MERGE         => 'HASH',
 PL_FILES           => 'HASH',
 PM                 => 'HASH',
 PMLIBDIRS          => 'ARRAY',
 PMLIBPARENTDIRS    => 'ARRAY',
 PREREQ_PM          => 'HASH',
 CONFIGURE_REQUIRES => 'HASH',
 SKIP               => 'ARRAY',
 TYPEMAPS           => 'ARRAY',
 XS                 => 'HASH',
# VERSION            => ['version',''],  # ignore
# _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',

 # special cases where you can use makemaker_append
 CCFLAGS   => 'APPENDABLE',
 DEFINE    => 'APPENDABLE',
 INC       => 'APPENDABLE',
 LDDLFLAGS => 'APPENDABLE',
 LDFROM    => 'APPENDABLE',
);

sub makemaker_args {
	my ($self, %new_args) = @_;
	my $args = ( $self->{makemaker_args} ||= {} );
	foreach my $key (keys %new_args) {
		if ($makemaker_argtype{$key}) {
			if ($makemaker_argtype{$key} eq 'ARRAY') {
				$args->{$key} = [] unless defined $args->{$key};
				unless (ref $args->{$key} eq 'ARRAY') {
					$args->{$key} = [$args->{$key}]
				}
				push @{$args->{$key}},
					ref $new_args{$key} eq 'ARRAY'
						? @{$new_args{$key}}
						: $new_args{$key};
			}
			elsif ($makemaker_argtype{$key} eq 'HASH') {
				$args->{$key} = {} unless defined $args->{$key};
				foreach my $skey (keys %{ $new_args{$key} }) {
					$args->{$key}{$skey} = $new_args{$key}{$skey};
				}
			}
			elsif ($makemaker_argtype{$key} eq 'APPENDABLE') {
				$self->makemaker_append($key => $new_args{$key});
			}
		}
		else {
			if (defined $args->{$key}) {
				warn qq{MakeMaker attribute "$key" is overriden; use "makemaker_append" to append values\n};
			}
			$args->{$key} = $new_args{$key};
		}
	}
	return $args;
}

# For mm args that take multiple space-seperated args,
# append an argument to the current list.
sub makemaker_append {
	my $self = shift;
	my $name = shift;
	my $args = $self->makemaker_args;
	$args->{$name} = defined $args->{$name}
		? join( ' ', $args->{$name}, @_ )
		: join( ' ', @_ );
}

sub build_subdirs {
	my $self    = shift;
	my $subdirs = $self->makemaker_args->{DIR} ||= [];
	for my $subdir (@_) {
		push @$subdirs, $subdir;
	}
}

sub clean_files {
	my $self  = shift;
	my $clean = $self->makemaker_args->{clean} ||= {};
	  %$clean = (
		%$clean,
		FILES => join ' ', grep { length $_ } ($clean->{FILES} || (), @_),
	);
}

sub realclean_files {
	my $self      = shift;
	my $realclean = $self->makemaker_args->{realclean} ||= {};
	  %$realclean = (
		%$realclean,
		FILES => join ' ', grep { length $_ } ($realclean->{FILES} || (), @_),
	);
}

sub libs {
	my $self = shift;
	my $libs = ref $_[0] ? shift : [ shift ];
	$self->makemaker_args( LIBS => $libs );
}

sub inc {
	my $self = shift;
	$self->makemaker_args( INC => shift );
}

sub _wanted_t {
}

sub tests_recursive {
	my $self = shift;
	my $dir = shift || 't';
	unless ( -d $dir ) {
		die "tests_recursive dir '$dir' does not exist";
	}
	my %tests = map { $_ => 1 } split / /, ($self->tests || '');
	require File::Find;
	File::Find::find(
        sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 },
        $dir
    );
	$self->tests( join ' ', sort keys %tests );
}

sub write {
	my $self = shift;
	die "&Makefile->write() takes no arguments\n" if @_;

	# Check the current Perl version
	my $perl_version = $self->perl_version;
	if ( $perl_version ) {
		eval "use $perl_version; 1"
			or die "ERROR: perl: Version $] is installed, "
			. "but we need version >= $perl_version";
	}

	# Make sure we have a new enough MakeMaker
	require ExtUtils::MakeMaker;

	if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) {
		# MakeMaker can complain about module versions that include
		# an underscore, even though its own version may contain one!
		# Hence the funny regexp to get rid of it.  See RT #35800
		# for details.
		my $v = $ExtUtils::MakeMaker::VERSION =~ /^(\d+\.\d+)/;
		$self->build_requires(     'ExtUtils::MakeMaker' => $v );
		$self->configure_requires( 'ExtUtils::MakeMaker' => $v );
	} else {
		# Allow legacy-compatibility with 5.005 by depending on the
		# most recent EU:MM that supported 5.005.
		$self->build_requires(     'ExtUtils::MakeMaker' => 6.42 );
		$self->configure_requires( 'ExtUtils::MakeMaker' => 6.42 );
	}

	# Generate the MakeMaker params
	my $args = $self->makemaker_args;
	$args->{DISTNAME} = $self->name;
	$args->{NAME}     = $self->module_name || $self->name;
	$args->{NAME}     =~ s/-/::/g;
	$args->{VERSION}  = $self->version or die <<'EOT';
ERROR: Can't determine distribution version. Please specify it
explicitly via 'version' in Makefile.PL, or set a valid $VERSION
in a module, and provide its file path via 'version_from' (or
'all_from' if you prefer) in Makefile.PL.
EOT

	$DB::single = 1;
	if ( $self->tests ) {
		my @tests = split ' ', $self->tests;
		my %seen;
		$args->{test} = {
			TESTS => (join ' ', grep {!$seen{$_}++} @tests),
		};
    } elsif ( $Module::Install::ExtraTests::use_extratests ) {
        # Module::Install::ExtraTests doesn't set $self->tests and does its own tests via harness.
        # So, just ignore our xt tests here.
	} elsif ( -d 'xt' and ($Module::Install::AUTHOR or $ENV{RELEASE_TESTING}) ) {
		$args->{test} = {
			TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ t xt } ),
		};
	}
	if ( $] >= 5.005 ) {
		$args->{ABSTRACT} = $self->abstract;
		$args->{AUTHOR}   = join ', ', @{$self->author || []};
	}
	if ( $self->makemaker(6.10) ) {
		$args->{NO_META}   = 1;
		#$args->{NO_MYMETA} = 1;
	}
	if ( $self->makemaker(6.17) and $self->sign ) {
		$args->{SIGN} = 1;
	}
	unless ( $self->is_admin ) {
		delete $args->{SIGN};
	}
	if ( $self->makemaker(6.31) and $self->license ) {
		$args->{LICENSE} = $self->license;
	}

	my $prereq = ($args->{PREREQ_PM} ||= {});
	%$prereq = ( %$prereq,
		map { @$_ } # flatten [module => version]
		map { @$_ }
		grep $_,
		($self->requires)
	);

	# Remove any reference to perl, PREREQ_PM doesn't support it
	delete $args->{PREREQ_PM}->{perl};

	# Merge both kinds of requires into BUILD_REQUIRES
	my $build_prereq = ($args->{BUILD_REQUIRES} ||= {});
	%$build_prereq = ( %$build_prereq,
		map { @$_ } # flatten [module => version]
		map { @$_ }
		grep $_,
		($self->configure_requires, $self->build_requires)
	);

	# Remove any reference to perl, BUILD_REQUIRES doesn't support it
	delete $args->{BUILD_REQUIRES}->{perl};

	# Delete bundled dists from prereq_pm, add it to Makefile DIR
	my $subdirs = ($args->{DIR} || []);
	if ($self->bundles) {
		my %processed;
		foreach my $bundle (@{ $self->bundles }) {
			my ($mod_name, $dist_dir) = @$bundle;
			delete $prereq->{$mod_name};
			$dist_dir = File::Basename::basename($dist_dir); # dir for building this module
			if (not exists $processed{$dist_dir}) {
				if (-d $dist_dir) {
					# List as sub-directory to be processed by make
					push @$subdirs, $dist_dir;
				}
				# Else do nothing: the module is already present on the system
				$processed{$dist_dir} = undef;
			}
		}
	}

	unless ( $self->makemaker('6.55_03') ) {
		%$prereq = (%$prereq,%$build_prereq);
		delete $args->{BUILD_REQUIRES};
	}

	if ( my $perl_version = $self->perl_version ) {
		eval "use $perl_version; 1"
			or die "ERROR: perl: Version $] is installed, "
			. "but we need version >= $perl_version";

		if ( $self->makemaker(6.48) ) {
			$args->{MIN_PERL_VERSION} = $perl_version;
		}
	}

	if ($self->installdirs) {
		warn qq{old INSTALLDIRS (probably set by makemaker_args) is overriden by installdirs\n} if $args->{INSTALLDIRS};
		$args->{INSTALLDIRS} = $self->installdirs;
	}

	my %args = map {
		( $_ => $args->{$_} ) } grep {defined($args->{$_} )
	} keys %$args;

	my $user_preop = delete $args{dist}->{PREOP};
	if ( my $preop = $self->admin->preop($user_preop) ) {
		foreach my $key ( keys %$preop ) {
			$args{dist}->{$key} = $preop->{$key};
		}
	}

	my $mm = ExtUtils::MakeMaker::WriteMakefile(%args);
	$self->fix_up_makefile($mm->{FIRST_MAKEFILE} || 'Makefile');
}

sub fix_up_makefile {
	my $self          = shift;
	my $makefile_name = shift;
	my $top_class     = ref($self->_top) || '';
	my $top_version   = $self->_top->VERSION || '';

	my $preamble = $self->preamble
		? "# Preamble by $top_class $top_version\n"
			. $self->preamble
		: '';
	my $postamble = "# Postamble by $top_class $top_version\n"
		. ($self->postamble || '');

	local *MAKEFILE;
	open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!";
	eval { flock MAKEFILE, LOCK_EX };
	my $makefile = do { local $/; <MAKEFILE> };

	$makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /;
	$makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g;
	$makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g;
	$makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m;
	$makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m;

	# Module::Install will never be used to build the Core Perl
	# Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks
	# PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist
	$makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m;
	#$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m;

	# Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well.
	$makefile =~ s/(\"?)-I\$\(PERL_LIB\)\1//g;

	# XXX - This is currently unused; not sure if it breaks other MM-users
	# $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg;

	seek MAKEFILE, 0, SEEK_SET;
	truncate MAKEFILE, 0;
	print MAKEFILE  "$preamble$makefile$postamble" or die $!;
	close MAKEFILE  or die $!;

	1;
}

sub preamble {
	my ($self, $text) = @_;
	$self->{preamble} = $text . $self->{preamble} if defined $text;
	$self->{preamble};
}

sub postamble {
	my ($self, $text) = @_;
	$self->{postamble} ||= $self->admin->postamble;
	$self->{postamble} .= $text if defined $text;
	$self->{postamble}
}

1;

__END__

#line 541
Commit	Line	Data
dbcf12a6	1	#line 1
	2	package Module::Install::Makefile;
	3
	4	use strict 'vars';
	5	use ExtUtils::MakeMaker ();
	6	use Module::Install::Base ();
	7	use Fcntl qw/:flock :seek/;
	8
	9	use vars qw{$VERSION @ISA $ISCORE};
	10	BEGIN {
	11	$VERSION = '1.00';
	12	@ISA = 'Module::Install::Base';
	13	$ISCORE = 1;
	14	}
	15
	16	sub Makefile { $_[0] }
	17
	18	my %seen = ();
	19
	20	sub prompt {
	21	shift;
	22
	23	# Infinite loop protection
	24	my @c = caller();
	25	if ( ++$seen{"$c[1]\|$c[2]\|$_[0]"} > 3 ) {
	26	die "Caught an potential prompt infinite loop ($c[1]\|$c[2]\|$_[0])";
	27	}
	28
	29	# In automated testing or non-interactive session, always use defaults
	30	if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
	31	local $ENV{PERL_MM_USE_DEFAULT} = 1;
	32	goto &ExtUtils::MakeMaker::prompt;
	33	} else {
	34	goto &ExtUtils::MakeMaker::prompt;
	35	}
	36	}
	37
	38	# Store a cleaned up version of the MakeMaker version,
	39	# since we need to behave differently in a variety of
	40	# ways based on the MM version.
	41	my $makemaker = eval $ExtUtils::MakeMaker::VERSION;
	42
	43	# If we are passed a param, do a "newer than" comparison.
	44	# Otherwise, just return the MakeMaker version.
	45	sub makemaker {
	46	( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0
	47	}
	48
	49	# Ripped from ExtUtils::MakeMaker 6.56, and slightly modified
	50	# as we only need to know here whether the attribute is an array
	51	# or a hash or something else (which may or may not be appendable).
	52	my %makemaker_argtype = (
	53	C => 'ARRAY',
	54	CONFIG => 'ARRAY',
	55	# CONFIGURE => 'CODE', # ignore
	56	DIR => 'ARRAY',
	57	DL_FUNCS => 'HASH',
	58	DL_VARS => 'ARRAY',
	59	EXCLUDE_EXT => 'ARRAY',
	60	EXE_FILES => 'ARRAY',
	61	FUNCLIST => 'ARRAY',
	62	H => 'ARRAY',
	63	IMPORTS => 'HASH',
	64	INCLUDE_EXT => 'ARRAY',
65	LIBS => 'ARRAY', # ignore ''
66	MAN1PODS => 'HASH',
67	MAN3PODS => 'HASH',
68	META_ADD => 'HASH',
69	META_MERGE => 'HASH',
70	PL_FILES => 'HASH',
71	PM => 'HASH',
72	PMLIBDIRS => 'ARRAY',
73	PMLIBPARENTDIRS => 'ARRAY',
74	PREREQ_PM => 'HASH',
75	CONFIGURE_REQUIRES => 'HASH',
76	SKIP => 'ARRAY',
77	TYPEMAPS => 'ARRAY',
78	XS => 'HASH',
79	# VERSION => ['version',''], # ignore
80	# _KEEP_AFTER_FLUSH => '',
81
82	clean => 'HASH',
83	depend => 'HASH',
84	dist => 'HASH',
85	dynamic_lib=> 'HASH',
86	linkext => 'HASH',
87	macro => 'HASH',
88	postamble => 'HASH',
89	realclean => 'HASH',
90	test => 'HASH',
91	tool_autosplit => 'HASH',
92
93	# special cases where you can use makemaker_append
94	CCFLAGS => 'APPENDABLE',
95	DEFINE => 'APPENDABLE',
96	INC => 'APPENDABLE',
97	LDDLFLAGS => 'APPENDABLE',
98	LDFROM => 'APPENDABLE',
99	);
100
101	sub makemaker_args {
102	my ($self, %new_args) = @_;
103	my $args = ( $self->{makemaker_args} \|\|= {} );
104	foreach my $key (keys %new_args) {
105	if ($makemaker_argtype{$key}) {
106	if ($makemaker_argtype{$key} eq 'ARRAY') {
107	$args->{$key} = [] unless defined $args->{$key};
108	unless (ref $args->{$key} eq 'ARRAY') {
109	$args->{$key} = [$args->{$key}]
110	}
111	push @{$args->{$key}},
112	ref $new_args{$key} eq 'ARRAY'
113	? @{$new_args{$key}}
114	: $new_args{$key};
115	}
116	elsif ($makemaker_argtype{$key} eq 'HASH') {
117	$args->{$key} = {} unless defined $args->{$key};
118	foreach my $skey (keys %{ $new_args{$key} }) {
119	$args->{$key}{$skey} = $new_args{$key}{$skey};
120	}
121	}
122	elsif ($makemaker_argtype{$key} eq 'APPENDABLE') {
123	$self->makemaker_append($key => $new_args{$key});
124	}
125	}
126	else {
127	if (defined $args->{$key}) {
128	warn qq{MakeMaker attribute "$key" is overriden; use "makemaker_append" to append values\n};
129	}
130	$args->{$key} = $new_args{$key};
131	}
132	}
133	return $args;
134	}
135
136	# For mm args that take multiple space-seperated args,
137	# append an argument to the current list.
138	sub makemaker_append {
139	my $self = shift;
140	my $name = shift;
141	my $args = $self->makemaker_args;
142	$args->{$name} = defined $args->{$name}
143	? join( ' ', $args->{$name}, @_ )
144	: join( ' ', @_ );
145	}
146
147	sub build_subdirs {
148	my $self = shift;
149	my $subdirs = $self->makemaker_args->{DIR} \|\|= [];
150	for my $subdir (@_) {
151	push @$subdirs, $subdir;
152	}
153	}
154
155	sub clean_files {
156	my $self = shift;
157	my $clean = $self->makemaker_args->{clean} \|\|= {};
158	%$clean = (
159	%$clean,
160	FILES => join ' ', grep { length $_ } ($clean->{FILES} \|\| (), @_),
161	);
162	}
163
164	sub realclean_files {
165	my $self = shift;
166	my $realclean = $self->makemaker_args->{realclean} \|\|= {};
167	%$realclean = (
168	%$realclean,
169	FILES => join ' ', grep { length $_ } ($realclean->{FILES} \|\| (), @_),
170	);
171	}
172
173	sub libs {
174	my $self = shift;
175	my $libs = ref $_[0] ? shift : [ shift ];
176	$self->makemaker_args( LIBS => $libs );
177	}
178
179	sub inc {
180	my $self = shift;
181	$self->makemaker_args( INC => shift );
182	}
183
184	sub _wanted_t {
185	}
186
187	sub tests_recursive {
188	my $self = shift;
189	my $dir = shift \|\| 't';
190	unless ( -d $dir ) {
191	die "tests_recursive dir '$dir' does not exist";
192	}
193	my %tests = map { $_ => 1 } split / /, ($self->tests \|\| '');
194	require File::Find;
195	File::Find::find(
196	sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 },
197	$dir
198	);
199	$self->tests( join ' ', sort keys %tests );
200	}
201
202	sub write {
203	my $self = shift;
204	die "&Makefile->write() takes no arguments\n" if @_;
205
206	# Check the current Perl version
207	my $perl_version = $self->perl_version;
208	if ( $perl_version ) {
209	eval "use $perl_version; 1"
210	or die "ERROR: perl: Version $] is installed, "
211	. "but we need version >= $perl_version";
212	}
213
214	# Make sure we have a new enough MakeMaker
215	require ExtUtils::MakeMaker;
216
217	if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) {
218	# MakeMaker can complain about module versions that include
219	# an underscore, even though its own version may contain one!
220	# Hence the funny regexp to get rid of it. See RT #35800
221	# for details.
222	my $v = $ExtUtils::MakeMaker::VERSION =~ /^(\d+\.\d+)/;
223	$self->build_requires( 'ExtUtils::MakeMaker' => $v );
224	$self->configure_requires( 'ExtUtils::MakeMaker' => $v );
225	} else {
226	# Allow legacy-compatibility with 5.005 by depending on the
227	# most recent EU:MM that supported 5.005.
228	$self->build_requires( 'ExtUtils::MakeMaker' => 6.42 );
229	$self->configure_requires( 'ExtUtils::MakeMaker' => 6.42 );
230	}
231
232	# Generate the MakeMaker params
233	my $args = $self->makemaker_args;
234	$args->{DISTNAME} = $self->name;
235	$args->{NAME} = $self->module_name \|\| $self->name;
236	$args->{NAME} =~ s/-/::/g;
237	$args->{VERSION} = $self->version or die <<'EOT';
238	ERROR: Can't determine distribution version. Please specify it
239	explicitly via 'version' in Makefile.PL, or set a valid $VERSION
240	in a module, and provide its file path via 'version_from' (or
241	'all_from' if you prefer) in Makefile.PL.
242	EOT
243
244	$DB::single = 1;
245	if ( $self->tests ) {
246	my @tests = split ' ', $self->tests;
247	my %seen;
248	$args->{test} = {
249	TESTS => (join ' ', grep {!$seen{$_}++} @tests),
250	};
251	} elsif ( $Module::Install::ExtraTests::use_extratests ) {
252	# Module::Install::ExtraTests doesn't set $self->tests and does its own tests via harness.
253	# So, just ignore our xt tests here.
254	} elsif ( -d 'xt' and ($Module::Install::AUTHOR or $ENV{RELEASE_TESTING}) ) {
255	$args->{test} = {
256	TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ t xt } ),
257	};
258	}
259	if ( $] >= 5.005 ) {
260	$args->{ABSTRACT} = $self->abstract;
261	$args->{AUTHOR} = join ', ', @{$self->author \|\| []};
262	}
263	if ( $self->makemaker(6.10) ) {
264	$args->{NO_META} = 1;
265	#$args->{NO_MYMETA} = 1;
266	}
267	if ( $self->makemaker(6.17) and $self->sign ) {
268	$args->{SIGN} = 1;
269	}
270	unless ( $self->is_admin ) {
271	delete $args->{SIGN};
272	}
273	if ( $self->makemaker(6.31) and $self->license ) {
274	$args->{LICENSE} = $self->license;
275	}
276
277	my $prereq = ($args->{PREREQ_PM} \|\|= {});
278	%$prereq = ( %$prereq,
279	map { @$_ } # flatten [module => version]
280	map { @$_ }
281	grep $_,
282	($self->requires)
283	);
284
285	# Remove any reference to perl, PREREQ_PM doesn't support it
286	delete $args->{PREREQ_PM}->{perl};
287
288	# Merge both kinds of requires into BUILD_REQUIRES
289	my $build_prereq = ($args->{BUILD_REQUIRES} \|\|= {});
290	%$build_prereq = ( %$build_prereq,
291	map { @$_ } # flatten [module => version]
292	map { @$_ }
293	grep $_,
294	($self->configure_requires, $self->build_requires)
295	);
296
297	# Remove any reference to perl, BUILD_REQUIRES doesn't support it
298	delete $args->{BUILD_REQUIRES}->{perl};
299
300	# Delete bundled dists from prereq_pm, add it to Makefile DIR
301	my $subdirs = ($args->{DIR} \|\| []);
302	if ($self->bundles) {
303	my %processed;
304	foreach my $bundle (@{ $self->bundles }) {
305	my ($mod_name, $dist_dir) = @$bundle;
306	delete $prereq->{$mod_name};
307	$dist_dir = File::Basename::basename($dist_dir); # dir for building this module
308	if (not exists $processed{$dist_dir}) {
309	if (-d $dist_dir) {
310	# List as sub-directory to be processed by make
311	push @$subdirs, $dist_dir;
312	}
313	# Else do nothing: the module is already present on the system
314	$processed{$dist_dir} = undef;
315	}
316	}
317	}
318
319	unless ( $self->makemaker('6.55_03') ) {
320	%$prereq = (%$prereq,%$build_prereq);
321	delete $args->{BUILD_REQUIRES};
322	}
323
324	if ( my $perl_version = $self->perl_version ) {
325	eval "use $perl_version; 1"
326	or die "ERROR: perl: Version $] is installed, "
327	. "but we need version >= $perl_version";
328
329	if ( $self->makemaker(6.48) ) {
330	$args->{MIN_PERL_VERSION} = $perl_version;
331	}
332	}
333
334	if ($self->installdirs) {
335	warn qq{old INSTALLDIRS (probably set by makemaker_args) is overriden by installdirs\n} if $args->{INSTALLDIRS};
336	$args->{INSTALLDIRS} = $self->installdirs;
337	}
338
339	my %args = map {
340	( $_ => $args->{$_} ) } grep {defined($args->{$_} )
341	} keys %$args;
342
343	my $user_preop = delete $args{dist}->{PREOP};
344	if ( my $preop = $self->admin->preop($user_preop) ) {
345	foreach my $key ( keys %$preop ) {
346	$args{dist}->{$key} = $preop->{$key};
347	}
348	}
349
350	my $mm = ExtUtils::MakeMaker::WriteMakefile(%args);
351	$self->fix_up_makefile($mm->{FIRST_MAKEFILE} \|\| 'Makefile');
352	}
353
354	sub fix_up_makefile {
355	my $self = shift;
356	my $makefile_name = shift;
357	my $top_class = ref($self->_top) \|\| '';
358	my $top_version = $self->_top->VERSION \|\| '';
359
360	my $preamble = $self->preamble
361	? "# Preamble by $top_class $top_version\n"
362	. $self->preamble
363	: '';
364	my $postamble = "# Postamble by $top_class $top_version\n"
365	. ($self->postamble \|\| '');
366
367	local *MAKEFILE;
368	open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!";
369	eval { flock MAKEFILE, LOCK_EX };
370	my $makefile = do { local $/; <MAKEFILE> };
371
372	$makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /;
373	$makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g;
374	$makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g;
375	$makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m;
376	$makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m;
377
378	# Module::Install will never be used to build the Core Perl
379	# Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks
380	# PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist
381	$makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m;
382	#$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m;
383
384	# Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well.
385	$makefile =~ s/(\"?)-I\$\(PERL_LIB\)\1//g;
386
387	# XXX - This is currently unused; not sure if it breaks other MM-users
388	# $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg;
389
390	seek MAKEFILE, 0, SEEK_SET;
391	truncate MAKEFILE, 0;
392	print MAKEFILE "$preamble$makefile$postamble" or die $!;
393	close MAKEFILE or die $!;
394
395	1;
396	}
397
398	sub preamble {
399	my ($self, $text) = @_;
400	$self->{preamble} = $text . $self->{preamble} if defined $text;
401	$self->{preamble};
402	}
403
404	sub postamble {
405	my ($self, $text) = @_;
406	$self->{postamble} \|\|= $self->admin->postamble;
407	$self->{postamble} .= $text if defined $text;
408	$self->{postamble}
409	}
410
411	1;
412
413	__END__
414
415	#line 541