Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: for-distributions/trunk/bin/windows/perl/lib/ExtUtils/MM_Unix.pm@ 14489

Last change on this file since 14489 was 14489, checked in by oranfry, 17 years ago
upgrading to perl 5.8
File size: 93.8 KB

Line
1	package ExtUtils::MM_Unix;
2
3	require 5.005_03; # Maybe further back, dunno
4
5	use strict;
6
7	use Exporter ();
8	use Carp;
9	use ExtUtils::MakeMaker::Config;
10	use File::Basename qw(basename dirname);
11	use DirHandle;
12
13	use vars qw($VERSION @ISA
14	$Is_OS2 $Is_VMS $Is_Win32 $Is_Dos
15	$Is_OSF $Is_IRIX $Is_NetBSD $Is_BSD
16	$Is_SunOS4 $Is_Solaris $Is_SunOS $Is_Interix
17	$Verbose %pm
18	%Config_Override
19	);
20
21	use ExtUtils::MakeMaker qw($Verbose neatvalue);
22
23	$VERSION = '1.50';
24
25	require ExtUtils::MM_Any;
26	@ISA = qw(ExtUtils::MM_Any);
27
28	BEGIN {
29	$Is_OS2 = $^O eq 'os2';
30	$Is_Win32 = $^O eq 'MSWin32' \|\| $Config{osname} eq 'NetWare';
31	$Is_Dos = $^O eq 'dos';
32	$Is_VMS = $^O eq 'VMS';
33	$Is_OSF = $^O eq 'dec_osf';
34	$Is_IRIX = $^O eq 'irix';
35	$Is_NetBSD = $^O eq 'netbsd';
36	$Is_Interix = $^O eq 'interix';
37	$Is_SunOS4 = $^O eq 'sunos';
38	$Is_Solaris = $^O eq 'solaris';
39	$Is_SunOS = $Is_SunOS4 \|\| $Is_Solaris;
40	$Is_BSD = $^O =~ /^(?:free\|net\|open)bsd$/ or
41	$^O eq 'bsdos' or $^O eq 'interix';
42	}
43
44	BEGIN {
45	if( $Is_VMS ) {
46	# For things like vmsify()
47	require VMS::Filespec;
48	VMS::Filespec->import;
49	}
50	}
51
52
53	=head1 NAME
54
55	ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker
56
57	=head1 SYNOPSIS
58
59	C<require ExtUtils::MM_Unix;>
60
61	=head1 DESCRIPTION
62
63	The methods provided by this package are designed to be used in
64	conjunction with ExtUtils::MakeMaker. When MakeMaker writes a
65	Makefile, it creates one or more objects that inherit their methods
66	from a package C<MM>. MM itself doesn't provide any methods, but it
67	ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating
68	specific packages take the responsibility for all the methods provided
69	by MM_Unix. We are trying to reduce the number of the necessary
70	overrides by defining rather primitive operations within
71	ExtUtils::MM_Unix.
72
73	If you are going to write a platform specific MM package, please try
74	to limit the necessary overrides to primitive methods, and if it is not
75	possible to do so, let's work out how to achieve that gain.
76
77	If you are overriding any of these methods in your Makefile.PL (in the
78	MY class), please report that to the makemaker mailing list. We are
79	trying to minimize the necessary method overrides and switch to data
80	driven Makefile.PLs wherever possible. In the long run less methods
81	will be overridable via the MY class.
82
83	=head1 METHODS
84
85	The following description of methods is still under
86	development. Please refer to the code for not suitably documented
87	sections and complain loudly to the [email protected] mailing list.
88	Better yet, provide a patch.
89
90	Not all of the methods below are overridable in a
91	Makefile.PL. Overridable methods are marked as (o). All methods are
92	overridable by a platform specific MM_*.pm file.
93
94	Cross-platform methods are being moved into MM_Any. If you can't find
95	something that used to be in here, look in MM_Any.
96
97	=cut
98
99	# So we don't have to keep calling the methods over and over again,
100	# we have these globals to cache the values. Faster and shrtr.
101	my $Curdir = __PACKAGE__->curdir;
102	my $Rootdir = __PACKAGE__->rootdir;
103	my $Updir = __PACKAGE__->updir;
104
105
106	=head2 Methods
107
108	=over 4
109
110	=item os_flavor
111
112	Simply says that we're Unix.
113
114	=cut
115
116	sub os_flavor {
117	return('Unix');
118	}
119
120
121	=item c_o (o)
122
123	Defines the suffix rules to compile different flavors of C files to
124	object files.
125
126	=cut
127
128	sub c_o {
129	# --- Translation Sections ---
130
131	my($self) = shift;
132	return '' unless $self->needs_linking();
133	my(@m);
134	if (my $cpp = $Config{cpprun}) {
135	my $cpp_cmd = $self->const_cccmd;
136	$cpp_cmd =~ s/^CCCMD\s=\s\$\(CC\)/$cpp/;
137	push @m, '
138	.c.i:
139	'. $cpp_cmd . ' $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $.c > $.i
140	';
141	}
142	push @m, '
143	.c.s:
144	$(CCCMD) -S $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
145	';
146	push @m, '
147	.c$(OBJ_EXT):
148	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
149	';
150	push @m, '
151	.C$(OBJ_EXT):
152	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.C
153	' if !$Is_OS2 and !$Is_Win32 and !$Is_Dos; #Case-specific
154	push @m, '
155	.cpp$(OBJ_EXT):
156	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cpp
157
158	.cxx$(OBJ_EXT):
159	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cxx
160
161	.cc$(OBJ_EXT):
162	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.cc
163	';
164	join "", @m;
165	}
166
167	=item cflags (o)
168
169	Does very much the same as the cflags script in the perl
170	distribution. It doesn't return the whole compiler command line, but
171	initializes all of its parts. The const_cccmd method then actually
172	returns the definition of the CCCMD macro which uses these parts.
173
174	=cut
175
176	#'
177
178	sub cflags {
179	my($self,$libperl)=@_;
180	return $self->{CFLAGS} if $self->{CFLAGS};
181	return '' unless $self->needs_linking();
182
183	my($prog, $uc, $perltype, %cflags);
184	$libperl \|\|= $self->{LIBPERL_A} \|\| "libperl$self->{LIB_EXT}" ;
185	$libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
186
187	@cflags{qw(cc ccflags optimize shellflags)}
188	= @Config{qw(cc ccflags optimize shellflags)};
189	my($optdebug) = "";
190
191	$cflags{shellflags} \|\|= '';
192
193	my(%map) = (
194	D => '-DDEBUGGING',
195	E => '-DEMBED',
196	DE => '-DDEBUGGING -DEMBED',
197	M => '-DEMBED -DMULTIPLICITY',
198	DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY',
199	);
200
201	if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
202	$uc = uc($1);
203	} else {
204	$uc = ""; # avoid warning
205	}
206	$perltype = $map{$uc} ? $map{$uc} : "";
207
208	if ($uc =~ /^D/) {
209	$optdebug = "-g";
210	}
211
212
213	my($name);
214	( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
215	if ($prog = $Config{$name}) {
216	# Expand hints for this extension via the shell
217	print STDOUT "Processing $name hint:\n" if $Verbose;
218	my(@o)=`cc=\"$cflags{cc}\"
219	ccflags=\"$cflags{ccflags}\"
220	optimize=\"$cflags{optimize}\"
221	perltype=\"$cflags{perltype}\"
222	optdebug=\"$cflags{optdebug}\"
223	eval '$prog'
224	echo cc=\$cc
225	echo ccflags=\$ccflags
226	echo optimize=\$optimize
227	echo perltype=\$perltype
228	echo optdebug=\$optdebug
229	`;
230	my($line);
231	foreach $line (@o){
232	chomp $line;
233	if ($line =~ /(.?)=\s(.)\s$/){
234	$cflags{$1} = $2;
235	print STDOUT " $1 = $2\n" if $Verbose;
236	} else {
237	print STDOUT "Unrecognised result from hint: '$line'\n";
238	}
239	}
240	}
241
242	if ($optdebug) {
243	$cflags{optimize} = $optdebug;
244	}
245
246	for (qw(ccflags optimize perltype)) {
247	$cflags{$_} \|\|= '';
248	$cflags{$_} =~ s/^\s+//;
249	$cflags{$_} =~ s/\s+/ /g;
250	$cflags{$_} =~ s/\s+$//;
251	$self->{uc $_} \|\|= $cflags{$_};
252	}
253
254	if ($self->{POLLUTE}) {
255	$self->{CCFLAGS} .= ' -DPERL_POLLUTE ';
256	}
257
258	my $pollute = '';
259	if ($Config{usemymalloc} and not $Config{bincompat5005}
260	and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/
261	and $self->{PERL_MALLOC_OK}) {
262	$pollute = '$(PERL_MALLOC_DEF)';
263	}
264
265	$self->{CCFLAGS} = quote_paren($self->{CCFLAGS});
266	$self->{OPTIMIZE} = quote_paren($self->{OPTIMIZE});
267
268	return $self->{CFLAGS} = qq{
269	CCFLAGS = $self->{CCFLAGS}
270	OPTIMIZE = $self->{OPTIMIZE}
271	PERLTYPE = $self->{PERLTYPE}
272	MPOLLUTE = $pollute
273	};
274
275	}
276
277
278	=item const_cccmd (o)
279
280	Returns the full compiler call for C programs and stores the
281	definition in CONST_CCCMD.
282
283	=cut
284
285	sub const_cccmd {
286	my($self,$libperl)=@_;
287	return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
288	return '' unless $self->needs_linking();
289	return $self->{CONST_CCCMD} =
290	q{CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \\
291	$(CCFLAGS) $(OPTIMIZE) \\
292	$(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\
293	$(XS_DEFINE_VERSION)};
294	}
295
296	=item const_config (o)
297
298	Defines a couple of constants in the Makefile that are imported from
299	%Config.
300
301	=cut
302
303	sub const_config {
304	# --- Constants Sections ---
305
306	my($self) = shift;
307	my(@m,$m);
308	push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
309	push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
310	my(%once_only);
311	foreach $m (@{$self->{CONFIG}}){
312	# SITE*EXP macros are defined in &constants; avoid duplicates here
313	next if $once_only{$m};
314	$self->{uc $m} = quote_paren($self->{uc $m});
315	push @m, uc($m) , ' = ' , $self->{uc $m}, "\n";
316	$once_only{$m} = 1;
317	}
318	join('', @m);
319	}
320
321	=item const_loadlibs (o)
322
323	Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See
324	L<ExtUtils::Liblist> for details.
325
326	=cut
327
328	sub const_loadlibs {
329	my($self) = shift;
330	return "" unless $self->needs_linking;
331	my @m;
332	push @m, qq{
333	# $self->{NAME} might depend on some other libraries:
334	# See ExtUtils::Liblist for details
335	#
336	};
337	my($tmp);
338	for $tmp (qw/
339	EXTRALIBS LDLOADLIBS BSLOADLIBS
340	/) {
341	next unless defined $self->{$tmp};
342	push @m, "$tmp = $self->{$tmp}\n";
343	}
344	# don't set LD_RUN_PATH if empty
345	for $tmp (qw/
346	LD_RUN_PATH
347	/) {
348	next unless $self->{$tmp};
349	push @m, "$tmp = $self->{$tmp}\n";
350	}
351	return join "", @m;
352	}
353
354	=item constants (o)
355
356	my $make_frag = $mm->constants;
357
358	Prints out macros for lots of constants.
359
360	=cut
361
362	sub constants {
363	my($self) = @_;
364	my @m = ();
365
366	$self->{DFSEP} = '$(DIRFILESEP)'; # alias for internal use
367
368	for my $macro (qw(
369
370	AR_STATIC_ARGS DIRFILESEP DFSEP
371	NAME NAME_SYM
372	VERSION VERSION_MACRO VERSION_SYM DEFINE_VERSION
373	XS_VERSION XS_VERSION_MACRO XS_DEFINE_VERSION
374	INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB
375	INST_MAN1DIR INST_MAN3DIR
376	MAN1EXT MAN3EXT
377	INSTALLDIRS INSTALLBASE DESTDIR PREFIX
378	PERLPREFIX SITEPREFIX VENDORPREFIX
379	),
380	(map { ("INSTALL".$_,
381	"DESTINSTALL".$_)
382	} $self->installvars),
383	qw(
384	PERL_LIB
385	PERL_ARCHLIB
386	LIBPERL_A MYEXTLIB
387	FIRST_MAKEFILE MAKEFILE_OLD MAKE_APERL_FILE
388	PERLMAINCC PERL_SRC PERL_INC
389	PERL FULLPERL ABSPERL
390	PERLRUN FULLPERLRUN ABSPERLRUN
391	PERLRUNINST FULLPERLRUNINST ABSPERLRUNINST
392	PERL_CORE
393	PERM_RW PERM_RWX
394
395	) )
396	{
397	next unless defined $self->{$macro};
398
399	# pathnames can have sharp signs in them; escape them so
400	# make doesn't think it is a comment-start character.
401	$self->{$macro} =~ s/#/\\#/g;
402	push @m, "$macro = $self->{$macro}\n";
403	}
404
405	push @m, qq{
406	MAKEMAKER = $self->{MAKEMAKER}
407	MM_VERSION = $self->{MM_VERSION}
408	MM_REVISION = $self->{MM_REVISION}
409	};
410
411	push @m, q{
412	# FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle).
413	# BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle)
414	# PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
415	# DLBASE = Basename part of dynamic library. May be just equal BASEEXT.
416	};
417
418	for my $macro (qw/
419	MAKE
420	FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
421	LDFROM LINKTYPE BOOTDEP
422	/ )
423	{
424	next unless defined $self->{$macro};
425	push @m, "$macro = $self->{$macro}\n";
426	}
427
428	push @m, "
429	# Handy lists of source code files:
430	XS_FILES = ".$self->wraplist(sort keys %{$self->{XS}})."
431	C_FILES = ".$self->wraplist(@{$self->{C}})."
432	O_FILES = ".$self->wraplist(@{$self->{O_FILES}})."
433	H_FILES = ".$self->wraplist(@{$self->{H}})."
434	MAN1PODS = ".$self->wraplist(sort keys %{$self->{MAN1PODS}})."
435	MAN3PODS = ".$self->wraplist(sort keys %{$self->{MAN3PODS}})."
436	";
437
438
439	push @m, q{
440	# Where is the Config information that we are using/depend on
441	CONFIGDEP = $(PERL_ARCHLIB)$(DFSEP)Config.pm $(PERL_INC)$(DFSEP)config.h
442	};
443
444
445	push @m, qq{
446	# Where to build things
447	INST_LIBDIR = $self->{INST_LIBDIR}
448	INST_ARCHLIBDIR = $self->{INST_ARCHLIBDIR}
449
450	INST_AUTODIR = $self->{INST_AUTODIR}
451	INST_ARCHAUTODIR = $self->{INST_ARCHAUTODIR}
452
453	INST_STATIC = $self->{INST_STATIC}
454	INST_DYNAMIC = $self->{INST_DYNAMIC}
455	INST_BOOT = $self->{INST_BOOT}
456	};
457
458
459	push @m, qq{
460	# Extra linker info
461	EXPORT_LIST = $self->{EXPORT_LIST}
462	PERL_ARCHIVE = $self->{PERL_ARCHIVE}
463	PERL_ARCHIVE_AFTER = $self->{PERL_ARCHIVE_AFTER}
464	};
465
466	push @m, "
467
468	TO_INST_PM = ".$self->wraplist(sort keys %{$self->{PM}})."
469
470	PM_TO_BLIB = ".$self->wraplist(%{$self->{PM}})."
471	";
472
473	join('',@m);
474	}
475
476
477	=item depend (o)
478
479	Same as macro for the depend attribute.
480
481	=cut
482
483	sub depend {
484	my($self,%attribs) = @_;
485	my(@m,$key,$val);
486	while (($key,$val) = each %attribs){
487	last unless defined $key;
488	push @m, "$key : $val\n";
489	}
490	join "", @m;
491	}
492
493
494	=item init_DEST
495
496	$mm->init_DEST
497
498	Defines the DESTDIR and DEST* variables paralleling the INSTALL*.
499
500	=cut
501
502	sub init_DEST {
503	my $self = shift;
504
505	# Initialize DESTDIR
506	$self->{DESTDIR} \|\|= '';
507
508	# Make DEST variables.
509	foreach my $var ($self->installvars) {
510	my $destvar = 'DESTINSTALL'.$var;
511	$self->{$destvar} \|\|= '$(DESTDIR)$(INSTALL'.$var.')';
512	}
513	}
514
515
516	=item init_dist
517
518	$mm->init_dist;
519
520	Defines a lot of macros for distribution support.
521
522	macro description default
523
524	TAR tar command to use tar
525	TARFLAGS flags to pass to TAR cvf
526
527	ZIP zip command to use zip
528	ZIPFLAGS flags to pass to ZIP -r
529
530	COMPRESS compression command to gzip --best
531	use for tarfiles
532	SUFFIX suffix to put on .gz
533	compressed files
534
535	SHAR shar command to use shar
536
537	PREOP extra commands to run before
538	making the archive
539	POSTOP extra commands to run after
540	making the archive
541
542	TO_UNIX a command to convert linefeeds
543	to Unix style in your archive
544
545	CI command to checkin your ci -u
546	sources to version control
547	RCS_LABEL command to label your sources rcs -Nv$(VERSION_SYM): -q
548	just after CI is run
549
550	DIST_CP $how argument to manicopy() best
551	when the distdir is created
552
553	DIST_DEFAULT default target to use to tardist
554	create a distribution
555
556	DISTVNAME name of the resulting archive $(DISTNAME)-$(VERSION)
557	(minus suffixes)
558
559	=cut
560
561	sub init_dist {
562	my $self = shift;
563
564	$self->{TAR} \|\|= 'tar';
565	$self->{TARFLAGS} \|\|= 'cvf';
566	$self->{ZIP} \|\|= 'zip';
567	$self->{ZIPFLAGS} \|\|= '-r';
568	$self->{COMPRESS} \|\|= 'gzip --best';
569	$self->{SUFFIX} \|\|= '.gz';
570	$self->{SHAR} \|\|= 'shar';
571	$self->{PREOP} \|\|= '$(NOECHO) $(NOOP)'; # eg update MANIFEST
572	$self->{POSTOP} \|\|= '$(NOECHO) $(NOOP)'; # eg remove the distdir
573	$self->{TO_UNIX} \|\|= '$(NOECHO) $(NOOP)';
574
575	$self->{CI} \|\|= 'ci -u';
576	$self->{RCS_LABEL}\|\|= 'rcs -Nv$(VERSION_SYM): -q';
577	$self->{DIST_CP} \|\|= 'best';
578	$self->{DIST_DEFAULT} \|\|= 'tardist';
579
580	($self->{DISTNAME} = $self->{NAME}) =~ s{::}{-}g unless $self->{DISTNAME};
581	$self->{DISTVNAME} \|\|= $self->{DISTNAME}.'-'.$self->{VERSION};
582
583	}
584
585	=item dist (o)
586
587	my $dist_macros = $mm->dist(%overrides);
588
589	Generates a make fragment defining all the macros initialized in
590	init_dist.
591
592	%overrides can be used to override any of the above.
593
594	=cut
595
596	sub dist {
597	my($self, %attribs) = @_;
598
599	my $make = '';
600	foreach my $key (qw(
601	TAR TARFLAGS ZIP ZIPFLAGS COMPRESS SUFFIX SHAR
602	PREOP POSTOP TO_UNIX
603	CI RCS_LABEL DIST_CP DIST_DEFAULT
604	DISTNAME DISTVNAME
605	))
606	{
607	my $value = $attribs{$key} \|\| $self->{$key};
608	$make .= "$key = $value\n";
609	}
610
611	return $make;
612	}
613
614	=item dist_basics (o)
615
616	Defines the targets distclean, distcheck, skipcheck, manifest, veryclean.
617
618	=cut
619
620	sub dist_basics {
621	my($self) = shift;
622
623	return <<'MAKE_FRAG';
624	distclean :: realclean distcheck
625	$(NOECHO) $(NOOP)
626
627	distcheck :
628	$(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck
629
630	skipcheck :
631	$(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck
632
633	manifest :
634	$(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest
635
636	veryclean : realclean
637	$(RM_F) ~ .orig /~ /.orig
638
639	MAKE_FRAG
640
641	}
642
643	=item dist_ci (o)
644
645	Defines a check in target for RCS.
646
647	=cut
648
649	sub dist_ci {
650	my($self) = shift;
651	return q{
652	ci :
653	$(PERLRUN) "-MExtUtils::Manifest=maniread" \\
654	-e "@all = keys %{ maniread() };" \\
655	-e "print(qq{Executing $(CI) @all\n}); system(qq{$(CI) @all});" \\
656	-e "print(qq{Executing $(RCS_LABEL) ...\n}); system(qq{$(RCS_LABEL) @all});"
657	};
658	}
659
660	=item dist_core (o)
661
662	my $dist_make_fragment = $MM->dist_core;
663
664	Puts the targets necessary for 'make dist' together into one make
665	fragment.
666
667	=cut
668
669	sub dist_core {
670	my($self) = shift;
671
672	my $make_frag = '';
673	foreach my $target (qw(dist tardist uutardist tarfile zipdist zipfile
674	shdist))
675	{
676	my $method = $target.'_target';
677	$make_frag .= "\n";
678	$make_frag .= $self->$method();
679	}
680
681	return $make_frag;
682	}
683
684
685	=item B<dist_target>
686
687	my $make_frag = $MM->dist_target;
688
689	Returns the 'dist' target to make an archive for distribution. This
690	target simply checks to make sure the Makefile is up-to-date and
691	depends on $(DIST_DEFAULT).
692
693	=cut
694
695	sub dist_target {
696	my($self) = shift;
697
698	my $date_check = $self->oneliner(<<'CODE', ['-l']);
699	print 'Warning: Makefile possibly out of date with $(VERSION_FROM)'
700	if -e '$(VERSION_FROM)' and -M '$(VERSION_FROM)' < -M '$(FIRST_MAKEFILE)';
701	CODE
702
703	return sprintf <<'MAKE_FRAG', $date_check;
704	dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE)
705	$(NOECHO) %s
706	MAKE_FRAG
707	}
708
709	=item B<tardist_target>
710
711	my $make_frag = $MM->tardist_target;
712
713	Returns the 'tardist' target which is simply so 'make tardist' works.
714	The real work is done by the dynamically named tardistfile_target()
715	method, tardist should have that as a dependency.
716
717	=cut
718
719	sub tardist_target {
720	my($self) = shift;
721
722	return <<'MAKE_FRAG';
723	tardist : $(DISTVNAME).tar$(SUFFIX)
724	$(NOECHO) $(NOOP)
725	MAKE_FRAG
726	}
727
728	=item B<zipdist_target>
729
730	my $make_frag = $MM->zipdist_target;
731
732	Returns the 'zipdist' target which is simply so 'make zipdist' works.
733	The real work is done by the dynamically named zipdistfile_target()
734	method, zipdist should have that as a dependency.
735
736	=cut
737
738	sub zipdist_target {
739	my($self) = shift;
740
741	return <<'MAKE_FRAG';
742	zipdist : $(DISTVNAME).zip
743	$(NOECHO) $(NOOP)
744	MAKE_FRAG
745	}
746
747	=item B<tarfile_target>
748
749	my $make_frag = $MM->tarfile_target;
750
751	The name of this target is the name of the tarball generated by
752	tardist. This target does the actual work of turning the distdir into
753	a tarball.
754
755	=cut
756
757	sub tarfile_target {
758	my($self) = shift;
759
760	return <<'MAKE_FRAG';
761	$(DISTVNAME).tar$(SUFFIX) : distdir
762	$(PREOP)
763	$(TO_UNIX)
764	$(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
765	$(RM_RF) $(DISTVNAME)
766	$(COMPRESS) $(DISTVNAME).tar
767	$(POSTOP)
768	MAKE_FRAG
769	}
770
771	=item zipfile_target
772
773	my $make_frag = $MM->zipfile_target;
774
775	The name of this target is the name of the zip file generated by
776	zipdist. This target does the actual work of turning the distdir into
777	a zip file.
778
779	=cut
780
781	sub zipfile_target {
782	my($self) = shift;
783
784	return <<'MAKE_FRAG';
785	$(DISTVNAME).zip : distdir
786	$(PREOP)
787	$(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME)
788	$(RM_RF) $(DISTVNAME)
789	$(POSTOP)
790	MAKE_FRAG
791	}
792
793	=item uutardist_target
794
795	my $make_frag = $MM->uutardist_target;
796
797	Converts the tarfile into a uuencoded file
798
799	=cut
800
801	sub uutardist_target {
802	my($self) = shift;
803
804	return <<'MAKE_FRAG';
805	uutardist : $(DISTVNAME).tar$(SUFFIX)
806	uuencode $(DISTVNAME).tar$(SUFFIX) $(DISTVNAME).tar$(SUFFIX) > $(DISTVNAME).tar$(SUFFIX)_uu
807	MAKE_FRAG
808	}
809
810
811	=item shdist_target
812
813	my $make_frag = $MM->shdist_target;
814
815	Converts the distdir into a shell archive.
816
817	=cut
818
819	sub shdist_target {
820	my($self) = shift;
821
822	return <<'MAKE_FRAG';
823	shdist : distdir
824	$(PREOP)
825	$(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
826	$(RM_RF) $(DISTVNAME)
827	$(POSTOP)
828	MAKE_FRAG
829	}
830
831
832	=item dlsyms (o)
833
834	Used by some OS' to define DL_FUNCS and DL_VARS and write the *.exp files.
835
836	Normally just returns an empty string.
837
838	=cut
839
840	sub dlsyms {
841	return '';
842	}
843
844
845	=item dynamic_bs (o)
846
847	Defines targets for bootstrap files.
848
849	=cut
850
851	sub dynamic_bs {
852	my($self, %attribs) = @_;
853	return '
854	BOOTSTRAP =
855	' unless $self->has_link_code();
856
857	my $target = $Is_VMS ? '$(MMS$TARGET)' : '$@';
858
859	return sprintf <<'MAKE_FRAG', ($target) x 5;
860	BOOTSTRAP = $(BASEEXT).bs
861
862	# As Mkbootstrap might not write a file (if none is required)
863	# we use touch to prevent make continually trying to remake it.
864	# The DynaLoader only reads a non-empty file.
865	$(BOOTSTRAP) : $(FIRST_MAKEFILE) $(BOOTDEP) $(INST_ARCHAUTODIR)$(DFSEP).exists
866	$(NOECHO) $(ECHO) "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
867	$(NOECHO) $(PERLRUN) \
868	"-MExtUtils::Mkbootstrap" \
869	-e "Mkbootstrap('$(BASEEXT)','$(BSLOADLIBS)');"
870	$(NOECHO) $(TOUCH) %s
871	$(CHMOD) $(PERM_RW) %s
872
873	$(INST_BOOT) : $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists
874	$(NOECHO) $(RM_RF) %s
875	- $(CP) $(BOOTSTRAP) %s
876	$(CHMOD) $(PERM_RW) %s
877	MAKE_FRAG
878	}
879
880	=item dynamic_lib (o)
881
882	Defines how to produce the *.so (or equivalent) files.
883
884	=cut
885
886	sub dynamic_lib {
887	my($self, %attribs) = @_;
888	return '' unless $self->needs_linking(); #might be because of a subdir
889
890	return '' unless $self->has_link_code;
891
892	my($otherldflags) = $attribs{OTHERLDFLAGS} \|\| "";
893	my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} \|\| "";
894	my($armaybe) = $attribs{ARMAYBE} \|\| $self->{ARMAYBE} \|\| ":";
895	my($ldfrom) = '$(LDFROM)';
896	$armaybe = 'ar' if ($Is_OSF and $armaybe eq ':');
897	my(@m);
898	my $ld_opt = $Is_OS2 ? '$(OPTIMIZE) ' : ''; # Useful on other systems too?
899	my $ld_fix = $Is_OS2 ? '\|\| ( $(RM_F) $@ && sh -c false )' : '';
900	push(@m,'
901	# This section creates the dynamically loadable $(INST_DYNAMIC)
902	# from $(OBJECT) and possibly $(MYEXTLIB).
903	ARMAYBE = '.$armaybe.'
904	OTHERLDFLAGS = '.$ld_opt.$otherldflags.'
905	INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
906	INST_DYNAMIC_FIX = '.$ld_fix.'
907
908	$(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP)
909	');
910	if ($armaybe ne ':'){
911	$ldfrom = 'tmp$(LIB_EXT)';
912	push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
913	push(@m,' $(RANLIB) '."$ldfrom\n");
914	}
915	$ldfrom = "-all $ldfrom -none" if $Is_OSF;
916
917	# The IRIX linker doesn't use LD_RUN_PATH
918	my $ldrun = $Is_IRIX && $self->{LD_RUN_PATH} ?
919	qq{-rpath "$self->{LD_RUN_PATH}"} : '';
920
921	# For example in AIX the shared objects/libraries from previous builds
922	# linger quite a while in the shared dynalinker cache even when nobody
923	# is using them. This is painful if one for instance tries to restart
924	# a failed build because the link command will fail unnecessarily 'cos
925	# the shared object/library is 'busy'.
926	push(@m,' $(RM_F) $@
927	');
928
929	my $libs = '$(LDLOADLIBS)';
930
931	if (($Is_NetBSD \|\| $Is_Interix) && $Config{'useshrplib'}) {
932	# Use nothing on static perl platforms, and to the flags needed
933	# to link against the shared libperl library on shared perl
934	# platforms. We peek at lddlflags to see if we need -Wl,-R
935	# or -R to add paths to the run-time library search path.
936	if ($Config{'lddlflags'} =~ /-Wl,-R/) {
937	$libs .= ' -L$(PERL_INC) -Wl,-R$(INSTALLARCHLIB)/CORE -Wl,-R$(PERL_ARCHLIB)/CORE -lperl';
938	} elsif ($Config{'lddlflags'} =~ /-R/) {
939	$libs .= ' -L$(PERL_INC) -R$(INSTALLARCHLIB)/CORE -R$(PERL_ARCHLIB)/CORE -lperl';
940	}
941	}
942
943	my $ld_run_path_shell = "";
944	if ($self->{LD_RUN_PATH} ne "") {
945	$ld_run_path_shell = 'LD_RUN_PATH="$(LD_RUN_PATH)" ';
946	}
947
948	push @m, sprintf <<'MAKE', $ld_run_path_shell, $ldrun, $ldfrom, $libs;
949	%s$(LD) %s $(LDDLFLAGS) %s $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) \
950	$(PERL_ARCHIVE) %s $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST) \
951	$(INST_DYNAMIC_FIX)
952	MAKE
953
954	push @m, <<'MAKE';
955	$(CHMOD) $(PERM_RWX) $@
956	MAKE
957
958	return join('',@m);
959	}
960
961	=item exescan
962
963	Deprecated method. Use libscan instead.
964
965	=cut
966
967	sub exescan {
968	my($self,$path) = @_;
969	$path;
970	}
971
972	=item extliblist
973
974	Called by init_others, and calls ext ExtUtils::Liblist. See
975	L<ExtUtils::Liblist> for details.
976
977	=cut
978
979	sub extliblist {
980	my($self,$libs) = @_;
981	require ExtUtils::Liblist;
982	$self->ext($libs, $Verbose);
983	}
984
985	=item find_perl
986
987	Finds the executables PERL and FULLPERL
988
989	=cut
990
991	sub find_perl {
992	my($self, $ver, $names, $dirs, $trace) = @_;
993	my($name, $dir);
994	if ($trace >= 2){
995	print "Looking for perl $ver by these names:
996	@$names
997	in these dirs:
998	@$dirs
999	";
1000	}
1001
1002	my $stderr_duped = 0;
1003	local *STDERR_COPY;
1004	unless ($Is_BSD) {
1005	if( open(STDERR_COPY, '>&STDERR') ) {
1006	$stderr_duped = 1;
1007	}
1008	else {
1009	warn <<WARNING;
1010	find_perl() can't dup STDERR: $!
1011	You might see some garbage while we search for Perl
1012	WARNING
1013	}
1014	}
1015
1016	foreach $name (@$names){
1017	foreach $dir (@$dirs){
1018	next unless defined $dir; # $self->{PERL_SRC} may be undefined
1019	my ($abs, $val);
1020	if ($self->file_name_is_absolute($name)) { # /foo/bar
1021	$abs = $name;
1022	} elsif ($self->canonpath($name) eq
1023	$self->canonpath(basename($name))) { # foo
1024	$abs = $self->catfile($dir, $name);
1025	} else { # foo/bar
1026	$abs = $self->catfile($Curdir, $name);
1027	}
1028	print "Checking $abs\n" if ($trace >= 2);
1029	next unless $self->maybe_command($abs);
1030	print "Executing $abs\n" if ($trace >= 2);
1031
1032	my $version_check = qq{$abs -le "require $ver; print qq{VER_OK}"};
1033	# To avoid using the unportable 2>&1 to supress STDERR,
1034	# we close it before running the command.
1035	# However, thanks to a thread library bug in many BSDs
1036	# ( http://www.freebsd.org/cgi/query-pr.cgi?pr=51535 )
1037	# we cannot use the fancier more portable way in here
1038	# but instead need to use the traditional 2>&1 construct.
1039	if ($Is_BSD) {
1040	$val = `$version_check 2>&1`;
1041	} else {
1042	close STDERR if $stderr_duped;
1043	$val = `$version_check`;
1044	open STDERR, '>&STDERR_COPY' if $stderr_duped;
1045	}
1046
1047	if ($val =~ /^VER_OK/) {
1048	print "Using PERL=$abs\n" if $trace;
1049	return $abs;
1050	} elsif ($trace >= 2) {
1051	print "Result: '$val'\n";
1052	}
1053	}
1054	}
1055	print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1056	0; # false and not empty
1057	}
1058
1059
1060	=item fixin
1061
1062	$mm->fixin(@files);
1063
1064	Inserts the sharpbang or equivalent magic number to a set of @files.
1065
1066	=cut
1067
1068	sub fixin { # stolen from the pink Camel book, more or less
1069	my($self, @files) = @_;
1070
1071	my($does_shbang) = $Config{'sharpbang'} =~ /^\s*\#\!/;
1072	for my $file (@files) {
1073	my $file_new = "$file.new";
1074	my $file_bak = "$file.bak";
1075
1076	local(*FIXIN);
1077	local(*FIXOUT);
1078	open(FIXIN, $file) or croak "Can't process '$file': $!";
1079	local $/ = "\n";
1080	chomp(my $line = <FIXIN>);
1081	next unless $line =~ s/^\s\#!\s//; # Not a shbang file.
1082	# Now figure out the interpreter name.
1083	my($cmd,$arg) = split ' ', $line, 2;
1084	$cmd =~ s!^.*/!!;
1085
1086	# Now look (in reverse) for interpreter in absolute PATH (unless perl).
1087	my $interpreter;
1088	if ($cmd eq "perl") {
1089	if ($Config{startperl} =~ m,^\#!.*/perl,) {
1090	$interpreter = $Config{startperl};
1091	$interpreter =~ s,^\#!,,;
1092	} else {
1093	$interpreter = $Config{perlpath};
1094	}
1095	} else {
1096	my(@absdirs) = reverse grep {$self->file_name_is_absolute} $self->path;
1097	$interpreter = '';
1098	my($dir);
1099	foreach $dir (@absdirs) {
1100	if ($self->maybe_command($cmd)) {
1101	warn "Ignoring $interpreter in $file\n" if $Verbose && $interpreter;
1102	$interpreter = $self->catfile($dir,$cmd);
1103	}
1104	}
1105	}
1106	# Figure out how to invoke interpreter on this machine.
1107
1108	my($shb) = "";
1109	if ($interpreter) {
1110	print STDOUT "Changing sharpbang in $file to $interpreter" if $Verbose;
1111	# this is probably value-free on DOSISH platforms
1112	if ($does_shbang) {
1113	$shb .= "$Config{'sharpbang'}$interpreter";
1114	$shb .= ' ' . $arg if defined $arg;
1115	$shb .= "\n";
1116	}
1117	$shb .= qq{
1118	eval 'exec $interpreter $arg -S \$0 \${1+"\$\@"}'
1119	if 0; # not running under some shell
1120	} unless $Is_Win32; # this won't work on win32, so don't
1121	} else {
1122	warn "Can't find $cmd in PATH, $file unchanged"
1123	if $Verbose;
1124	next;
1125	}
1126
1127	unless ( open(FIXOUT,">$file_new") ) {
1128	warn "Can't create new $file: $!\n";
1129	next;
1130	}
1131
1132	# Print out the new #! line (or equivalent).
1133	local $\;
1134	undef $/;
1135	print FIXOUT $shb, <FIXIN>;
1136	close FIXIN;
1137	close FIXOUT;
1138
1139	chmod 0666, $file_bak;
1140	unlink $file_bak;
1141	unless ( _rename($file, $file_bak) ) {
1142	warn "Can't rename $file to $file_bak: $!";
1143	next;
1144	}
1145	unless ( _rename($file_new, $file) ) {
1146	warn "Can't rename $file_new to $file: $!";
1147	unless ( _rename($file_bak, $file) ) {
1148	warn "Can't rename $file_bak back to $file either: $!";
1149	warn "Leaving $file renamed as $file_bak\n";
1150	}
1151	next;
1152	}
1153	unlink $file_bak;
1154	} continue {
1155	close(FIXIN) if fileno(FIXIN);
1156	system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';;
1157	}
1158	}
1159
1160
1161	sub _rename {
1162	my($old, $new) = @_;
1163
1164	foreach my $file ($old, $new) {
1165	if( $Is_VMS and basename($file) !~ /\./ ) {
1166	# rename() in 5.8.0 on VMS will not rename a file if it
1167	# does not contain a dot yet it returns success.
1168	$file = "$file.";
1169	}
1170	}
1171
1172	return rename($old, $new);
1173	}
1174
1175
1176	=item force (o)
1177
1178	Writes an empty FORCE: target.
1179
1180	=cut
1181
1182	sub force {
1183	my($self) = shift;
1184	'# Phony target to force checking subdirectories.
1185	FORCE:
1186	$(NOECHO) $(NOOP)
1187	';
1188	}
1189
1190	=item guess_name
1191
1192	Guess the name of this package by examining the working directory's
1193	name. MakeMaker calls this only if the developer has not supplied a
1194	NAME attribute.
1195
1196	=cut
1197
1198	# ';
1199
1200	sub guess_name {
1201	my($self) = @_;
1202	use Cwd 'cwd';
1203	my $name = basename(cwd());
1204	$name =~ s\|[\-_][\d\.\-]+\z\|\|; # this is new with MM 5.00, we
1205	# strip minus or underline
1206	# followed by a float or some such
1207	print "Warning: Guessing NAME [$name] from current directory name.\n";
1208	$name;
1209	}
1210
1211	=item has_link_code
1212
1213	Returns true if C, XS, MYEXTLIB or similar objects exist within this
1214	object that need a compiler. Does not descend into subdirectories as
1215	needs_linking() does.
1216
1217	=cut
1218
1219	sub has_link_code {
1220	my($self) = shift;
1221	return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
1222	if ($self->{OBJECT} or @{$self->{C} \|\| []} or $self->{MYEXTLIB}){
1223	$self->{HAS_LINK_CODE} = 1;
1224	return 1;
1225	}
1226	return $self->{HAS_LINK_CODE} = 0;
1227	}
1228
1229
1230	=item init_dirscan
1231
1232	Scans the directory structure and initializes DIR, XS, XS_FILES, PM,
1233	C, C_FILES, O_FILES, H, H_FILES, PL_FILES, MAN*PODS, EXE_FILES.
1234
1235	Called by init_main.
1236
1237	=cut
1238
1239	sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc)
1240	my($self) = @_;
1241	my($name, %dir, %xs, %c, %h, %pl_files, %manifypods);
1242	my %pm;
1243
1244	my %ignore = map {( $_ => 1 )} qw(Makefile.PL Build.PL test.pl t);
1245
1246	# ignore the distdir
1247	$Is_VMS ? $ignore{"$self->{DISTVNAME}.dir"} = 1
1248	: $ignore{$self->{DISTVNAME}} = 1;
1249
1250	@ignore{map lc, keys %ignore} = values %ignore if $Is_VMS;
1251
1252	foreach $name ($self->lsdir($Curdir)){
1253	next if $name =~ /\#/;
1254	next if $name eq $Curdir or $name eq $Updir or $ignore{$name};
1255	next unless $self->libscan($name);
1256	if (-d $name){
1257	next if -l $name; # We do not support symlinks at all
1258	next if $self->{NORECURS};
1259	$dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL"));
1260	} elsif ($name =~ /\.xs\z/){
1261	my($c); ($c = $name) =~ s/\.xs\z/.c/;
1262	$xs{$name} = $c;
1263	$c{$c} = 1;
1264	} elsif ($name =~ /\.c(pp\|xx\|c)?\z/i){ # .c .C .cpp .cxx .cc
1265	$c{$name} = 1
1266	unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1267	} elsif ($name =~ /\.h\z/i){
1268	$h{$name} = 1;
1269	} elsif ($name =~ /\.PL\z/) {
1270	($pl_files{$name} = $name) =~ s/\.PL\z// ;
1271	} elsif (($Is_VMS \|\| $Is_Dos) && $name =~ /[._]pl$/i) {
1272	# case-insensitive filesystem, one dot per name, so foo.h.PL
1273	# under Unix appears as foo.h_pl under VMS or fooh.pl on Dos
1274	local($/); open(PL,$name); my $txt = <PL>; close PL;
1275	if ($txt =~ /Extracting \S+ \(with variable substitutions/) {
1276	($pl_files{$name} = $name) =~ s/[._]pl\z//i ;
1277	}
1278	else {
1279	$pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
1280	}
1281	} elsif ($name =~ /\.(p[ml]\|pod)\z/){
1282	$pm{$name} = $self->catfile($self->{INST_LIBDIR},$name);
1283	}
1284	}
1285
1286	# Some larger extensions often wish to install a number of *.pm/pl
1287	# files into the library in various locations.
1288
1289	# The attribute PMLIBDIRS holds an array reference which lists
1290	# subdirectories which we should search for library files to
1291	# install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We
1292	# recursively search through the named directories (skipping any
1293	# which don't exist or contain Makefile.PL files).
1294
1295	# For each .pm or .pl file found $self->libscan() is called with
1296	# the default installation path in $_[1]. The return value of
1297	# libscan defines the actual installation location. The default
1298	# libscan function simply returns the path. The file is skipped
1299	# if libscan returns false.
1300
1301	# The default installation location passed to libscan in $_[1] is:
1302	#
1303	# ./.pm => $(INST_LIBDIR)/.pm
1304	# ./xyz/... => $(INST_LIBDIR)/xyz/...
1305	# ./lib/... => $(INST_LIB)/...
1306	#
1307	# In this way the 'lib' directory is seen as the root of the actual
1308	# perl library whereas the others are relative to INST_LIBDIR
1309	# (which includes PARENT_NAME). This is a subtle distinction but one
1310	# that's important for nested modules.
1311
1312	unless( $self->{PMLIBDIRS} ) {
1313	if( $Is_VMS ) {
1314	# Avoid logical name vs directory collisions
1315	$self->{PMLIBDIRS} = ['./lib', "./$self->{BASEEXT}"];
1316	}
1317	else {
1318	$self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}];
1319	}
1320	}
1321
1322	#only existing directories that aren't in $dir are allowed
1323
1324	# Avoid $_ wherever possible:
1325	# @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1326	my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1327	my ($pmlibdir);
1328	@{$self->{PMLIBDIRS}} = ();
1329	foreach $pmlibdir (@pmlibdirs) {
1330	-d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1331	}
1332
1333	if (@{$self->{PMLIBDIRS}}){
1334	print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1335	if ($Verbose >= 2);
1336	require File::Find;
1337	File::Find::find(sub {
1338	if (-d $_){
1339	unless ($self->libscan($_)){
1340	$File::Find::prune = 1;
1341	}
1342	return;
1343	}
1344	return if /\#/;
1345	return if /~$/; # emacs temp files
1346	return if /,v$/; # RCS files
1347
1348	my $path = $File::Find::name;
1349	my $prefix = $self->{INST_LIBDIR};
1350	my $striplibpath;
1351
1352	$prefix = $self->{INST_LIB}
1353	if ($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i;
1354
1355	my($inst) = $self->catfile($prefix,$striplibpath);
1356	local($_) = $inst; # for backwards compatibility
1357	$inst = $self->libscan($inst);
1358	print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1359	return unless $inst;
1360	$pm{$path} = $inst;
1361	}, @{$self->{PMLIBDIRS}});
1362	}
1363
1364	$self->{PM} \|\|= \%pm;
1365	$self->{PL_FILES} \|\|= \%pl_files;
1366
1367	$self->{DIR} \|\|= [sort keys %dir];
1368
1369	$self->{XS} \|\|= \%xs;
1370	$self->{C} \|\|= [sort keys %c];
1371	my @o_files = @{$self->{C}};
1372	$self->{O_FILES} = [grep s/\.c(pp\|xx\|c)?\z/$self->{OBJ_EXT}/i, @o_files];
1373
1374	$self->{H} \|\|= [sort keys %h];
1375
1376	# Set up names of manual pages to generate from pods
1377	my %pods;
1378	foreach my $man (qw(MAN1 MAN3)) {
1379	unless ($self->{"${man}PODS"}) {
1380	$self->{"${man}PODS"} = {};
1381	$pods{$man} = 1 unless
1382	$self->{"INSTALL${man}DIR"} =~ /^(none\|\s*)$/;
1383	}
1384	}
1385
1386	if ($pods{MAN1}) {
1387	if ( exists $self->{EXE_FILES} ) {
1388	foreach $name (@{$self->{EXE_FILES}}) {
1389	local *FH;
1390	my($ispod)=0;
1391	if (open(FH,"<$name")) {
1392	while (<FH>) {
1393	if (/^=(?:head\d+\|item\|pod)\b/) {
1394	$ispod=1;
1395	last;
1396	}
1397	}
1398	close FH;
1399	} else {
1400	# If it doesn't exist yet, we assume, it has pods in it
1401	$ispod = 1;
1402	}
1403	next unless $ispod;
1404	if ($pods{MAN1}) {
1405	$self->{MAN1PODS}->{$name} =
1406	$self->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1407	}
1408	}
1409	}
1410	}
1411	if ($pods{MAN3}) {
1412	my %manifypods = (); # we collect the keys first, i.e. the files
1413	# we have to convert to pod
1414	foreach $name (keys %{$self->{PM}}) {
1415	if ($name =~ /\.pod\z/ ) {
1416	$manifypods{$name} = $self->{PM}{$name};
1417	} elsif ($name =~ /\.p[ml]\z/ ) {
1418	local *FH;
1419	my($ispod)=0;
1420	if (open(FH,"<$name")) {
1421	while (<FH>) {
1422	if (/^=head1\s+\w+/) {
1423	$ispod=1;
1424	last;
1425	}
1426	}
1427	close FH;
1428	} else {
1429	$ispod = 1;
1430	}
1431	if( $ispod ) {
1432	$manifypods{$name} = $self->{PM}{$name};
1433	}
1434	}
1435	}
1436
1437	# Remove "Configure.pm" and similar, if it's not the only pod listed
1438	# To force inclusion, just name it "Configure.pod", or override
1439	# MAN3PODS
1440	foreach $name (keys %manifypods) {
1441	if ($self->{PERL_CORE} and $name =~ /(config\|setup).*\.pm/is) {
1442	delete $manifypods{$name};
1443	next;
1444	}
1445	my($manpagename) = $name;
1446	$manpagename =~ s/\.p(od\|m\|l)\z//;
1447	# everything below lib is ok
1448	unless($manpagename =~ s!^\W*lib\W+!!s) {
1449	$manpagename = $self->catfile(
1450	split(/::/,$self->{PARENT_NAME}),$manpagename
1451	);
1452	}
1453	if ($pods{MAN3}) {
1454	$manpagename = $self->replace_manpage_separator($manpagename);
1455	$self->{MAN3PODS}->{$name} =
1456	$self->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1457	}
1458	}
1459	}
1460	}
1461
1462	=item init_DIRFILESEP
1463
1464	Using / for Unix. Called by init_main.
1465
1466	=cut
1467
1468	sub init_DIRFILESEP {
1469	my($self) = shift;
1470
1471	$self->{DIRFILESEP} = '/';
1472	}
1473
1474
1475	=item init_main
1476
1477	Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE,
1478	EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*,
1479	INSTALL*, INSTALLDIRS, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME,
1480	OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB,
1481	PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION,
1482	VERSION_SYM, XS_VERSION.
1483
1484	=cut
1485
1486	sub init_main {
1487	my($self) = @_;
1488
1489	# --- Initialize Module Name and Paths
1490
1491	# NAME = Foo::Bar::Oracle
1492	# FULLEXT = Foo/Bar/Oracle
1493	# BASEEXT = Oracle
1494	# PARENT_NAME = Foo::Bar
1495	### Only UNIX:
1496	### ($self->{FULLEXT} =
1497	### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1498	$self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME});
1499
1500
1501	# Copied from DynaLoader:
1502
1503	my(@modparts) = split(/::/,$self->{NAME});
1504	my($modfname) = $modparts[-1];
1505
1506	# Some systems have restrictions on files names for DLL's etc.
1507	# mod2fname returns appropriate file base name (typically truncated)
1508	# It may also edit @modparts if required.
1509	if (defined &DynaLoader::mod2fname) {
1510	$modfname = &DynaLoader::mod2fname(\@modparts);
1511	}
1512
1513	($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1514	$self->{PARENT_NAME} \|\|= '';
1515
1516	if (defined &DynaLoader::mod2fname) {
1517	# As of 5.001m, dl_os2 appends '_'
1518	$self->{DLBASE} = $modfname;
1519	} else {
1520	$self->{DLBASE} = '$(BASEEXT)';
1521	}
1522
1523
1524	# --- Initialize PERL_LIB, PERL_SRC
1525
1526	# Real information: where did we get these two from? ...
1527	my $inc_config_dir = dirname($INC{'Config.pm'});
1528	my $inc_carp_dir = dirname($INC{'Carp.pm'});
1529
1530	unless ($self->{PERL_SRC}){
1531	my($dir);
1532	foreach $dir ($Updir,
1533	$self->catdir($Updir,$Updir),
1534	$self->catdir($Updir,$Updir,$Updir),
1535	$self->catdir($Updir,$Updir,$Updir,$Updir),
1536	$self->catdir($Updir,$Updir,$Updir,$Updir,$Updir))
1537	{
1538	if (
1539	-f $self->catfile($dir,"config_h.SH")
1540	&&
1541	-f $self->catfile($dir,"perl.h")
1542	&&
1543	-f $self->catfile($dir,"lib","Exporter.pm")
1544	) {
1545	$self->{PERL_SRC}=$dir ;
1546	last;
1547	}
1548	}
1549	}
1550
1551	warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if
1552	$self->{PERL_CORE} and !$self->{PERL_SRC};
1553
1554	if ($self->{PERL_SRC}){
1555	$self->{PERL_LIB} \|\|= $self->catdir("$self->{PERL_SRC}","lib");
1556
1557	if (defined $Cross::platform) {
1558	$self->{PERL_ARCHLIB} =
1559	$self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform);
1560	$self->{PERL_INC} =
1561	$self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform,
1562	$Is_Win32?("CORE"):());
1563	}
1564	else {
1565	$self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1566	$self->{PERL_INC} = ($Is_Win32) ?
1567	$self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1568	}
1569
1570	# catch a situation that has occurred a few times in the past:
1571	unless (
1572	-s $self->catfile($self->{PERL_SRC},'cflags')
1573	or
1574	$Is_VMS
1575	&&
1576	-s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1577	or
1578	$Is_Win32
1579	){
1580	warn qq{
1581	You cannot build extensions below the perl source tree after executing
1582	a 'make clean' in the perl source tree.
1583
1584	To rebuild extensions distributed with the perl source you should
1585	simply Configure (to include those extensions) and then build perl as
1586	normal. After installing perl the source tree can be deleted. It is
1587	not needed for building extensions by running 'perl Makefile.PL'
1588	usually without extra arguments.
1589
1590	It is recommended that you unpack and build additional extensions away
1591	from the perl source tree.
1592	};
1593	}
1594	} else {
1595	# we should also consider $ENV{PERL5LIB} here
1596	my $old = $self->{PERL_LIB} \|\| $self->{PERL_ARCHLIB} \|\| $self->{PERL_INC};
1597	$self->{PERL_LIB} \|\|= $Config{privlibexp};
1598	$self->{PERL_ARCHLIB} \|\|= $Config{archlibexp};
1599	$self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1600	my $perl_h;
1601
1602	if (not -f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h"))
1603	and not $old){
1604	# Maybe somebody tries to build an extension with an
1605	# uninstalled Perl outside of Perl build tree
1606	my $found;
1607	for my $dir (@INC) {
1608	$found = $dir, last if -e $self->catdir($dir, "Config.pm");
1609	}
1610	if ($found) {
1611	my $inc = dirname $found;
1612	if (-e $self->catdir($inc, "perl.h")) {
1613	$self->{PERL_LIB} = $found;
1614	$self->{PERL_ARCHLIB} = $found;
1615	$self->{PERL_INC} = $inc;
1616	$self->{UNINSTALLED_PERL} = 1;
1617	print STDOUT <<EOP;
1618	... Detected uninstalled Perl. Trying to continue.
1619	EOP
1620	}
1621	}
1622	}
1623	}
1624
1625	# We get SITELIBEXP and SITEARCHEXP directly via
1626	# Get_from_Config. When we are running standard modules, these
1627	# won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1628	# set it to "site". I prefer that INSTALLDIRS be set from outside
1629	# MakeMaker.
1630	$self->{INSTALLDIRS} \|\|= "site";
1631
1632	$self->{MAN1EXT} \|\|= $Config{man1ext};
1633	$self->{MAN3EXT} \|\|= $Config{man3ext};
1634
1635	# Get some stuff out of %Config if we haven't yet done so
1636	print STDOUT "CONFIG must be an array ref\n"
1637	if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1638	$self->{CONFIG} = [] unless (ref $self->{CONFIG});
1639	push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1640	push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags};
1641	my(%once_only);
1642	foreach my $m (@{$self->{CONFIG}}){
1643	next if $once_only{$m};
1644	print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1645	unless exists $Config{$m};
1646	$self->{uc $m} \|\|= $Config{$m};
1647	$once_only{$m} = 1;
1648	}
1649
1650	# This is too dangerous:
1651	# if ($^O eq "next") {
1652	# $self->{AR} = "libtool";
1653	# $self->{AR_STATIC_ARGS} = "-o";
1654	# }
1655	# But I leave it as a placeholder
1656
1657	$self->{AR_STATIC_ARGS} \|\|= "cr";
1658
1659	# These should never be needed
1660	$self->{OBJ_EXT} \|\|= '.o';
1661	$self->{LIB_EXT} \|\|= '.a';
1662
1663	$self->{MAP_TARGET} \|\|= "perl";
1664
1665	$self->{LIBPERL_A} \|\|= "libperl$self->{LIB_EXT}";
1666
1667	# make a simple check if we find Exporter
1668	warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1669	(Exporter.pm not found)"
1670	unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") \|\|
1671	$self->{NAME} eq "ExtUtils::MakeMaker";
1672	}
1673
1674	=item init_others
1675
1676	Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH, LD,
1677	OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, SHELL, NOOP,
1678	FIRST_MAKEFILE, MAKEFILE_OLD, NOECHO, RM_F, RM_RF, TEST_F,
1679	TOUCH, CP, MV, CHMOD, UMASK_NULL, ECHO, ECHO_N
1680
1681	=cut
1682
1683	sub init_others { # --- Initialize Other Attributes
1684	my($self) = shift;
1685
1686	$self->{LD} \|\|= 'ld';
1687
1688	# Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1689	# Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1690	# undefined. In any case we turn it into an anon array:
1691
1692	# May check $Config{libs} too, thus not empty.
1693	$self->{LIBS} = [$self->{LIBS}] unless ref $self->{LIBS};
1694
1695	$self->{LIBS} = [''] unless @{$self->{LIBS}} && defined $self->{LIBS}[0];
1696	$self->{LD_RUN_PATH} = "";
1697	my($libs);
1698	foreach $libs ( @{$self->{LIBS}} ){
1699	$libs =~ s/^\s(.\S)\s*$/$1/; # remove leading and trailing whitespace
1700	my(@libs) = $self->extliblist($libs);
1701	if ($libs[0] or $libs[1] or $libs[2]){
1702	# LD_RUN_PATH now computed by ExtUtils::Liblist
1703	($self->{EXTRALIBS}, $self->{BSLOADLIBS},
1704	$self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1705	last;
1706	}
1707	}
1708
1709	if ( $self->{OBJECT} ) {
1710	$self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1711	} else {
1712	# init_dirscan should have found out, if we have C files
1713	$self->{OBJECT} = "";
1714	$self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}\|\|[]};
1715	}
1716	$self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1717	$self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1718	$self->{PERLMAINCC} \|\|= '$(CC)';
1719	$self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1720
1721	# Sanity check: don't define LINKTYPE = dynamic if we're skipping
1722	# the 'dynamic' section of MM. We don't have this problem with
1723	# 'static', since we either must use it (%Config says we can't
1724	# use dynamic loading) or the caller asked for it explicitly.
1725	if (!$self->{LINKTYPE}) {
1726	$self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1727	? 'static'
1728	: ($Config{usedl} ? 'dynamic' : 'static');
1729	};
1730
1731	$self->{NOOP} \|\|= '$(SHELL) -c true';
1732	$self->{NOECHO} = '@' unless defined $self->{NOECHO};
1733
1734	$self->{FIRST_MAKEFILE} \|\|= $self->{MAKEFILE} \|\| 'Makefile';
1735	$self->{MAKEFILE} \|\|= $self->{FIRST_MAKEFILE};
1736	$self->{MAKEFILE_OLD} \|\|= $self->{MAKEFILE}.'.old';
1737	$self->{MAKE_APERL_FILE} \|\|= $self->{MAKEFILE}.'.aperl';
1738
1739	# Some makes require a wrapper around macros passed in on the command
1740	# line.
1741	$self->{MACROSTART} \|\|= '';
1742	$self->{MACROEND} \|\|= '';
1743
1744	# Not everybody uses -f to indicate "use this Makefile instead"
1745	$self->{USEMAKEFILE} \|\|= '-f';
1746
1747	$self->{SHELL} \|\|= $Config{sh} \|\| '/bin/sh';
1748
1749	$self->{ECHO} \|\|= 'echo';
1750	$self->{ECHO_N} \|\|= 'echo -n';
1751	$self->{RM_F} \|\|= "rm -f";
1752	$self->{RM_RF} \|\|= "rm -rf";
1753	$self->{TOUCH} \|\|= "touch";
1754	$self->{TEST_F} \|\|= "test -f";
1755	$self->{CP} \|\|= "cp";
1756	$self->{MV} \|\|= "mv";
1757	$self->{CHMOD} \|\|= "chmod";
1758	$self->{MKPATH} \|\|= '$(ABSPERLRUN) "-MExtUtils::Command" -e mkpath';
1759	$self->{EQUALIZE_TIMESTAMP} \|\|=
1760	'$(ABSPERLRUN) "-MExtUtils::Command" -e eqtime';
1761
1762	$self->{UNINST} \|\|= 0;
1763	$self->{VERBINST} \|\|= 0;
1764	$self->{MOD_INSTALL} \|\|=
1765	$self->oneliner(<<'CODE', ['-MExtUtils::Install']);
1766	install({@ARGV}, '$(VERBINST)', 0, '$(UNINST)');
1767	CODE
1768	$self->{DOC_INSTALL} \|\|=
1769	'$(ABSPERLRUN) "-MExtUtils::Command::MM" -e perllocal_install';
1770	$self->{UNINSTALL} \|\|=
1771	'$(ABSPERLRUN) "-MExtUtils::Command::MM" -e uninstall';
1772	$self->{WARN_IF_OLD_PACKLIST} \|\|=
1773	'$(ABSPERLRUN) "-MExtUtils::Command::MM" -e warn_if_old_packlist';
1774	$self->{FIXIN} \|\|=
1775	q{$(PERLRUN) "-MExtUtils::MY" -e "MY->fixin(shift)"};
1776
1777	$self->{UMASK_NULL} \|\|= "umask 0";
1778	$self->{DEV_NULL} \|\|= "> /dev/null 2>&1";
1779
1780	return 1;
1781	}
1782
1783
1784	=item init_linker
1785
1786	Unix has no need of special linker flags.
1787
1788	=cut
1789
1790	sub init_linker {
1791	my($self) = shift;
1792	$self->{PERL_ARCHIVE} \|\|= '';
1793	$self->{PERL_ARCHIVE_AFTER} \|\|= '';
1794	$self->{EXPORT_LIST} \|\|= '';
1795	}
1796
1797
1798	=begin _protected
1799
1800	=item init_lib2arch
1801
1802	$mm->init_lib2arch
1803
1804	=end _protected
1805
1806	=cut
1807
1808	sub init_lib2arch {
1809	my($self) = shift;
1810
1811	# The user who requests an installation directory explicitly
1812	# should not have to tell us an architecture installation directory
1813	# as well. We look if a directory exists that is named after the
1814	# architecture. If not we take it as a sign that it should be the
1815	# same as the requested installation directory. Otherwise we take
1816	# the found one.
1817	for my $libpair ({l=>"privlib", a=>"archlib"},
1818	{l=>"sitelib", a=>"sitearch"},
1819	{l=>"vendorlib", a=>"vendorarch"},
1820	)
1821	{
1822	my $lib = "install$libpair->{l}";
1823	my $Lib = uc $lib;
1824	my $Arch = uc "install$libpair->{a}";
1825	if( $self->{$Lib} && ! $self->{$Arch} ){
1826	my($ilib) = $Config{$lib};
1827
1828	$self->prefixify($Arch,$ilib,$self->{$Lib});
1829
1830	unless (-d $self->{$Arch}) {
1831	print STDOUT "Directory $self->{$Arch} not found\n"
1832	if $Verbose;
1833	$self->{$Arch} = $self->{$Lib};
1834	}
1835	print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
1836	}
1837	}
1838	}
1839
1840
1841	=item init_PERL
1842
1843	$mm->init_PERL;
1844
1845	Called by init_main. Sets up ABSPERL, PERL, FULLPERL and all the
1846	PERLRUN permutations.
1847
1848	PERL is allowed to be miniperl
1849	FULLPERL must be a complete perl
1850
1851	ABSPERL is PERL converted to an absolute path
1852
1853	*PERLRUN contains everything necessary to run perl, find it's
1854	libraries, etc...
1855
1856	PERLRUNINST is PERLRUN + everything necessary to find the
1857	modules being built.
1858
1859	=cut
1860
1861	sub init_PERL {
1862	my($self) = shift;
1863
1864	my @defpath = ();
1865	foreach my $component ($self->{PERL_SRC}, $self->path(),
1866	$Config{binexp})
1867	{
1868	push @defpath, $component if defined $component;
1869	}
1870
1871	# Build up a set of file names (not command names).
1872	my $thisperl = $self->canonpath($^X);
1873	$thisperl .= $Config{exe_ext} unless
1874	# VMS might have a file version # at the end
1875	$Is_VMS ? $thisperl =~ m/$Config{exe_ext}(;\d+)?$/i
1876	: $thisperl =~ m/$Config{exe_ext}$/i;
1877
1878	# We need a relative path to perl when in the core.
1879	$thisperl = $self->abs2rel($thisperl) if $self->{PERL_CORE};
1880
1881	my @perls = ($thisperl);
1882	push @perls, map { "$_$Config{exe_ext}" }
1883	('perl', 'perl5', "perl$Config{version}");
1884
1885	# miniperl has priority over all but the cannonical perl when in the
1886	# core. Otherwise its a last resort.
1887	my $miniperl = "miniperl$Config{exe_ext}";
1888	if( $self->{PERL_CORE} ) {
1889	splice @perls, 1, 0, $miniperl;
1890	}
1891	else {
1892	push @perls, $miniperl;
1893	}
1894
1895	$self->{PERL} \|\|=
1896	$self->find_perl(5.0, \@perls, \@defpath, $Verbose );
1897	# don't check if perl is executable, maybe they have decided to
1898	# supply switches with perl
1899
1900	# When built for debugging, VMS doesn't create perl.exe but ndbgperl.exe.
1901	my $perl_name = 'perl';
1902	$perl_name = 'ndbgperl' if $Is_VMS &&
1903	defined $Config{usevmsdebug} && $Config{usevmsdebug} eq 'define';
1904
1905	# XXX This logic is flawed. If "miniperl" is anywhere in the path
1906	# it will get confused. It should be fixed to work only on the filename.
1907	# Define 'FULLPERL' to be a non-miniperl (used in test: target)
1908	($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/$perl_name/i
1909	unless $self->{FULLPERL};
1910
1911	# Little hack to get around VMS's find_perl putting "MCR" in front
1912	# sometimes.
1913	$self->{ABSPERL} = $self->{PERL};
1914	my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
1915	if( $self->file_name_is_absolute($self->{ABSPERL}) ) {
1916	$self->{ABSPERL} = '$(PERL)';
1917	}
1918	else {
1919	$self->{ABSPERL} = $self->rel2abs($self->{ABSPERL});
1920	$self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
1921	}
1922
1923	# Are we building the core?
1924	$self->{PERL_CORE} = $ENV{PERL_CORE} unless exists $self->{PERL_CORE};
1925	$self->{PERL_CORE} = 0 unless defined $self->{PERL_CORE};
1926
1927	# How do we run perl?
1928	foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
1929	my $run = $perl.'RUN';
1930
1931	$self->{$run} = "\$($perl)";
1932
1933	# Make sure perl can find itself before it's installed.
1934	$self->{$run} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"}
1935	if $self->{UNINSTALLED_PERL} \|\| $self->{PERL_CORE};
1936
1937	$self->{$perl.'RUNINST'} =
1938	sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
1939	}
1940
1941	return 1;
1942	}
1943
1944
1945	=item init_platform
1946
1947	=item platform_constants
1948
1949	Add MM_Unix_VERSION.
1950
1951	=cut
1952
1953	sub init_platform {
1954	my($self) = shift;
1955
1956	$self->{MM_Unix_VERSION} = $VERSION;
1957	$self->{PERL_MALLOC_DEF} = '-DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc '.
1958	'-Dfree=Perl_mfree -Drealloc=Perl_realloc '.
1959	'-Dcalloc=Perl_calloc';
1960
1961	}
1962
1963	sub platform_constants {
1964	my($self) = shift;
1965	my $make_frag = '';
1966
1967	foreach my $macro (qw(MM_Unix_VERSION PERL_MALLOC_DEF))
1968	{
1969	next unless defined $self->{$macro};
1970	$make_frag .= "$macro = $self->{$macro}\n";
1971	}
1972
1973	return $make_frag;
1974	}
1975
1976
1977	=item init_PERM
1978
1979	$mm->init_PERM
1980
1981	Called by init_main. Initializes PERL_*
1982
1983	=cut
1984
1985	sub init_PERM {
1986	my($self) = shift;
1987
1988	$self->{PERM_RW} = 644 unless defined $self->{PERM_RW};
1989	$self->{PERM_RWX} = 755 unless defined $self->{PERM_RWX};
1990
1991	return 1;
1992	}
1993
1994
1995	=item init_xs
1996
1997	$mm->init_xs
1998
1999	Sets up macros having to do with XS code. Currently just INST_STATIC,
2000	INST_DYNAMIC and INST_BOOT.
2001
2002	=cut
2003
2004	sub init_xs {
2005	my $self = shift;
2006
2007	if ($self->has_link_code()) {
2008	$self->{INST_STATIC} =
2009	$self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT)$(LIB_EXT)');
2010	$self->{INST_DYNAMIC} =
2011	$self->catfile('$(INST_ARCHAUTODIR)', '$(DLBASE).$(DLEXT)');
2012	$self->{INST_BOOT} =
2013	$self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT).bs');
2014	} else {
2015	$self->{INST_STATIC} = '';
2016	$self->{INST_DYNAMIC} = '';
2017	$self->{INST_BOOT} = '';
2018	}
2019	}
2020
2021	=item install (o)
2022
2023	Defines the install target.
2024
2025	=cut
2026
2027	sub install {
2028	my($self, %attribs) = @_;
2029	my(@m);
2030
2031	push @m, q{
2032	install :: all pure_install doc_install
2033	$(NOECHO) $(NOOP)
2034
2035	install_perl :: all pure_perl_install doc_perl_install
2036	$(NOECHO) $(NOOP)
2037
2038	install_site :: all pure_site_install doc_site_install
2039	$(NOECHO) $(NOOP)
2040
2041	install_vendor :: all pure_vendor_install doc_vendor_install
2042	$(NOECHO) $(NOOP)
2043
2044	pure_install :: pure_$(INSTALLDIRS)_install
2045	$(NOECHO) $(NOOP)
2046
2047	doc_install :: doc_$(INSTALLDIRS)_install
2048	$(NOECHO) $(NOOP)
2049
2050	pure__install : pure_site_install
2051	$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2052
2053	doc__install : doc_site_install
2054	$(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2055
2056	pure_perl_install ::
2057	$(NOECHO) $(MOD_INSTALL) \
2058	read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2059	write }.$self->catfile('$(DESTINSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2060	$(INST_LIB) $(DESTINSTALLPRIVLIB) \
2061	$(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \
2062	$(INST_BIN) $(DESTINSTALLBIN) \
2063	$(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2064	$(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \
2065	$(INST_MAN3DIR) $(DESTINSTALLMAN3DIR)
2066	$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2067	}.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2068
2069
2070	pure_site_install ::
2071	$(NOECHO) $(MOD_INSTALL) \
2072	read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2073	write }.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2074	$(INST_LIB) $(DESTINSTALLSITELIB) \
2075	$(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \
2076	$(INST_BIN) $(DESTINSTALLSITEBIN) \
2077	$(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2078	$(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \
2079	$(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR)
2080	$(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2081	}.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2082
2083	pure_vendor_install ::
2084	$(NOECHO) $(MOD_INSTALL) \
2085	read }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2086	write }.$self->catfile('$(DESTINSTALLVENDORARCH)','auto','$(FULLEXT)','.packlist').q{ \
2087	$(INST_LIB) $(DESTINSTALLVENDORLIB) \
2088	$(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \
2089	$(INST_BIN) $(DESTINSTALLVENDORBIN) \
2090	$(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2091	$(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \
2092	$(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR)
2093
2094	doc_perl_install ::
2095	$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2096	-$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2097	-$(NOECHO) $(DOC_INSTALL) \
2098	"Module" "$(NAME)" \
2099	"installed into" "$(INSTALLPRIVLIB)" \
2100	LINKTYPE "$(LINKTYPE)" \
2101	VERSION "$(VERSION)" \
2102	EXE_FILES "$(EXE_FILES)" \
2103	>> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2104
2105	doc_site_install ::
2106	$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2107	-$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2108	-$(NOECHO) $(DOC_INSTALL) \
2109	"Module" "$(NAME)" \
2110	"installed into" "$(INSTALLSITELIB)" \
2111	LINKTYPE "$(LINKTYPE)" \
2112	VERSION "$(VERSION)" \
2113	EXE_FILES "$(EXE_FILES)" \
2114	>> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2115
2116	doc_vendor_install ::
2117	$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2118	-$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2119	-$(NOECHO) $(DOC_INSTALL) \
2120	"Module" "$(NAME)" \
2121	"installed into" "$(INSTALLVENDORLIB)" \
2122	LINKTYPE "$(LINKTYPE)" \
2123	VERSION "$(VERSION)" \
2124	EXE_FILES "$(EXE_FILES)" \
2125	>> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2126
2127	};
2128
2129	push @m, q{
2130	uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2131	$(NOECHO) $(NOOP)
2132
2133	uninstall_from_perldirs ::
2134	$(NOECHO) $(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2135
2136	uninstall_from_sitedirs ::
2137	$(NOECHO) $(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2138
2139	uninstall_from_vendordirs ::
2140	$(NOECHO) $(UNINSTALL) }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2141	};
2142
2143	join("",@m);
2144	}
2145
2146	=item installbin (o)
2147
2148	Defines targets to make and to install EXE_FILES.
2149
2150	=cut
2151
2152	sub installbin {
2153	my($self) = shift;
2154
2155	return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2156	my @exefiles = @{$self->{EXE_FILES}};
2157	return "" unless @exefiles;
2158
2159	@exefiles = map vmsify($_), @exefiles if $Is_VMS;
2160
2161	my %fromto;
2162	for my $from (@exefiles) {
2163	my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2164
2165	local($_) = $path; # for backwards compatibility
2166	my $to = $self->libscan($path);
2167	print "libscan($from) => '$to'\n" if ($Verbose >=2);
2168
2169	$to = vmsify($to) if $Is_VMS;
2170	$fromto{$from} = $to;
2171	}
2172	my @to = values %fromto;
2173
2174	my @m;
2175	push(@m, qq{
2176	EXE_FILES = @exefiles
2177
2178	pure_all :: @to
2179	\$(NOECHO) \$(NOOP)
2180
2181	realclean ::
2182	});
2183
2184	# realclean can get rather large.
2185	push @m, map "\t$_\n", $self->split_command('$(RM_F)', @to);
2186	push @m, "\n";
2187
2188
2189	# A target for each exe file.
2190	while (my($from,$to) = each %fromto) {
2191	last unless defined $from;
2192
2193	push @m, sprintf <<'MAKE', $to, $from, $to, $from, $to, $to, $to;
2194	%s : %s $(FIRST_MAKEFILE) $(INST_SCRIPT)$(DFSEP).exists $(INST_BIN)$(DFSEP).exists
2195	$(NOECHO) $(RM_F) %s
2196	$(CP) %s %s
2197	$(FIXIN) %s
2198	-$(NOECHO) $(CHMOD) $(PERM_RWX) %s
2199
2200	MAKE
2201
2202	}
2203
2204	join "", @m;
2205	}
2206
2207
2208	=item linkext (o)
2209
2210	Defines the linkext target which in turn defines the LINKTYPE.
2211
2212	=cut
2213
2214	sub linkext {
2215	my($self, %attribs) = @_;
2216	# LINKTYPE => static or dynamic or ''
2217	my($linktype) = defined $attribs{LINKTYPE} ?
2218	$attribs{LINKTYPE} : '$(LINKTYPE)';
2219	"
2220	linkext :: $linktype
2221	\$(NOECHO) \$(NOOP)
2222	";
2223	}
2224
2225	=item lsdir
2226
2227	Takes as arguments a directory name and a regular expression. Returns
2228	all entries in the directory that match the regular expression.
2229
2230	=cut
2231
2232	sub lsdir {
2233	my($self) = shift;
2234	my($dir, $regex) = @_;
2235	my(@ls);
2236	my $dh = new DirHandle;
2237	$dh->open($dir \|\| ".") or return ();
2238	@ls = $dh->read;
2239	$dh->close;
2240	@ls = grep(/$regex/, @ls) if $regex;
2241	@ls;
2242	}
2243
2244	=item macro (o)
2245
2246	Simple subroutine to insert the macros defined by the macro attribute
2247	into the Makefile.
2248
2249	=cut
2250
2251	sub macro {
2252	my($self,%attribs) = @_;
2253	my(@m,$key,$val);
2254	while (($key,$val) = each %attribs){
2255	last unless defined $key;
2256	push @m, "$key = $val\n";
2257	}
2258	join "", @m;
2259	}
2260
2261	=item makeaperl (o)
2262
2263	Called by staticmake. Defines how to write the Makefile to produce a
2264	static new perl.
2265
2266	By default the Makefile produced includes all the static extensions in
2267	the perl library. (Purified versions of library files, e.g.,
2268	DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2269
2270	=cut
2271
2272	sub makeaperl {
2273	my($self, %attribs) = @_;
2274	my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2275	@attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2276	my(@m);
2277	push @m, "
2278	# --- MakeMaker makeaperl section ---
2279	MAP_TARGET = $target
2280	FULLPERL = $self->{FULLPERL}
2281	";
2282	return join '', @m if $self->{PARENT};
2283
2284	my($dir) = join ":", @{$self->{DIR}};
2285
2286	unless ($self->{MAKEAPERL}) {
2287	push @m, q{
2288	$(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2289	$(MAKE) $(USEMAKEFILE) $(MAKE_APERL_FILE) $@
2290
2291	$(MAKE_APERL_FILE) : $(FIRST_MAKEFILE) pm_to_blib
2292	$(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2293	$(NOECHO) $(PERLRUNINST) \
2294	Makefile.PL DIR=}, $dir, q{ \
2295	MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2296	MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2297
2298	foreach (@ARGV){
2299	if( /\s/ ){
2300	s/=(.*)/='$1'/;
2301	}
2302	push @m, " \\\n\t\t$_";
2303	}
2304	# push @m, map( " \\\n\t\t$_", @ARGV );
2305	push @m, "\n";
2306
2307	return join '', @m;
2308	}
2309
2310
2311
2312	my($cccmd, $linkcmd, $lperl);
2313
2314
2315	$cccmd = $self->const_cccmd($libperl);
2316	$cccmd =~ s/^CCCMD\s=\s//;
2317	$cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
2318	$cccmd .= " $Config{cccdlflags}"
2319	if ($Config{useshrplib} eq 'true');
2320	$cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2321
2322	# The front matter of the linkcommand...
2323	$linkcmd = join ' ', "\$(CC)",
2324	grep($_, @Config{qw(ldflags ccdlflags)});
2325	$linkcmd =~ s/\s+/ /g;
2326	$linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2327
2328	# Which *.a files could we make use of...
2329	my %static;
2330	require File::Find;
2331	File::Find::find(sub {
2332	return unless m/\Q$self->{LIB_EXT}\E$/;
2333
2334	# Skip perl's libraries.
2335	return if m/^libperl/ or m/^perl\Q$self->{LIB_EXT}\E$/;
2336
2337	# Skip purified versions of libraries
2338	# (e.g., DynaLoader_pure_p1_c0_032.a)
2339	return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2340
2341	if( exists $self->{INCLUDE_EXT} ){
2342	my $found = 0;
2343	my $incl;
2344	my $xx;
2345
2346	($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2347	$xx =~ s,/?$_,,;
2348	$xx =~ s,/,::,g;
2349
2350	# Throw away anything not explicitly marked for inclusion.
2351	# DynaLoader is implied.
2352	foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2353	if( $xx eq $incl ){
2354	$found++;
2355	last;
2356	}
2357	}
2358	return unless $found;
2359	}
2360	elsif( exists $self->{EXCLUDE_EXT} ){
2361	my $excl;
2362	my $xx;
2363
2364	($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2365	$xx =~ s,/?$_,,;
2366	$xx =~ s,/,::,g;
2367
2368	# Throw away anything explicitly marked for exclusion
2369	foreach $excl (@{$self->{EXCLUDE_EXT}}){
2370	return if( $xx eq $excl );
2371	}
2372	}
2373
2374	# don't include the installed version of this extension. I
2375	# leave this line here, although it is not necessary anymore:
2376	# I patched minimod.PL instead, so that Miniperl.pm won't
2377	# enclude duplicates
2378
2379	# Once the patch to minimod.PL is in the distribution, I can
2380	# drop it
2381	return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2382	use Cwd 'cwd';
2383	$static{cwd() . "/" . $_}++;
2384	}, grep( -d $_, @{$searchdirs \|\| []}) );
2385
2386	# We trust that what has been handed in as argument, will be buildable
2387	$static = [] unless $static;
2388	@static{@{$static}} = (1) x @{$static};
2389
2390	$extra = [] unless $extra && ref $extra eq 'ARRAY';
2391	for (sort keys %static) {
2392	next unless /\Q$self->{LIB_EXT}\E\z/;
2393	$_ = dirname($_) . "/extralibs.ld";
2394	push @$extra, $_;
2395	}
2396
2397	grep(s/^(.*)/"-I$1"/, @{$perlinc \|\| []});
2398
2399	$target \|\|= "perl";
2400	$tmp \|\|= ".";
2401
2402	# MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2403	# regenerate the Makefiles, MAP_STATIC and the dependencies for
2404	# extralibs.all are computed correctly
2405	push @m, "
2406	MAP_LINKCMD = $linkcmd
2407	MAP_PERLINC = @{$perlinc \|\| []}
2408	MAP_STATIC = ",
2409	join(" \\\n\t", reverse sort keys %static), "
2410
2411	MAP_PRELIBS = $Config{perllibs} $Config{cryptlib}
2412	";
2413
2414	if (defined $libperl) {
2415	($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2416	}
2417	unless ($libperl && -f $lperl) { # Ilya's code...
2418	my $dir = $self->{PERL_SRC} \|\| "$self->{PERL_ARCHLIB}/CORE";
2419	$dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2420	$libperl \|\|= "libperl$self->{LIB_EXT}";
2421	$libperl = "$dir/$libperl";
2422	$lperl \|\|= "libperl$self->{LIB_EXT}";
2423	$lperl = "$dir/$lperl";
2424
2425	if (! -f $libperl and ! -f $lperl) {
2426	# We did not find a static libperl. Maybe there is a shared one?
2427	if ($Is_SunOS) {
2428	$lperl = $libperl = "$dir/$Config{libperl}";
2429	# SUNOS ld does not take the full path to a shared library
2430	$libperl = '' if $Is_SunOS4;
2431	}
2432	}
2433
2434	print STDOUT "Warning: $libperl not found
2435	If you're going to build a static perl binary, make sure perl is installed
2436	otherwise ignore this warning\n"
2437	unless (-f $lperl \|\| defined($self->{PERL_SRC}));
2438	}
2439
2440	# SUNOS ld does not take the full path to a shared library
2441	my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
2442
2443	push @m, "
2444	MAP_LIBPERL = $libperl
2445	LLIBPERL = $llibperl
2446	";
2447
2448	push @m, '
2449	$(INST_ARCHAUTODIR)/extralibs.all : $(INST_ARCHAUTODIR)$(DFSEP).exists '.join(" \\\n\t", @$extra).'
2450	$(NOECHO) $(RM_F) $@
2451	$(NOECHO) $(TOUCH) $@
2452	';
2453
2454	my $catfile;
2455	foreach $catfile (@$extra){
2456	push @m, "\tcat $catfile >> \$\@\n";
2457	}
2458
2459	push @m, "
2460	\$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2461	\$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2462	\$(NOECHO) \$(ECHO) 'To install the new \"\$(MAP_TARGET)\" binary, call'
2463	\$(NOECHO) \$(ECHO) ' \$(MAKE) \$(USEMAKEFILE) $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2464	\$(NOECHO) \$(ECHO) 'To remove the intermediate files say'
2465	\$(NOECHO) \$(ECHO) ' \$(MAKE) \$(USEMAKEFILE) $makefilename map_clean'
2466
2467	$tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2468	";
2469	push @m, "\t".$self->cd($tmp, qq[$cccmd "-I\$(PERL_INC)" perlmain.c])."\n";
2470
2471	push @m, qq{
2472	$tmp/perlmain.c: $makefilename}, q{
2473	$(NOECHO) $(ECHO) Writing $@
2474	$(NOECHO) $(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\
2475	-e "writemain(grep s#.*/auto/##s, split(q\| \|, q\|$(MAP_STATIC)\|))" > $@t && $(MV) $@t $@
2476
2477	};
2478	push @m, "\t", q{$(NOECHO) $(PERL) $(INSTALLSCRIPT)/fixpmain
2479	} if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2480
2481
2482	push @m, q{
2483	doc_inst_perl:
2484	$(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2485	-$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2486	-$(NOECHO) $(DOC_INSTALL) \
2487	"Perl binary" "$(MAP_TARGET)" \
2488	MAP_STATIC "$(MAP_STATIC)" \
2489	MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2490	MAP_LIBPERL "$(MAP_LIBPERL)" \
2491	>> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2492
2493	};
2494
2495	push @m, q{
2496	inst_perl: pure_inst_perl doc_inst_perl
2497
2498	pure_inst_perl: $(MAP_TARGET)
2499	}.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{
2500
2501	clean :: map_clean
2502
2503	map_clean :
2504	}.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2505	};
2506
2507	join '', @m;
2508	}
2509
2510	=item makefile (o)
2511
2512	Defines how to rewrite the Makefile.
2513
2514	=cut
2515
2516	sub makefile {
2517	my($self) = shift;
2518	my $m;
2519	# We do not know what target was originally specified so we
2520	# must force a manual rerun to be sure. But as it should only
2521	# happen very rarely it is not a significant problem.
2522	$m = '
2523	$(OBJECT) : $(FIRST_MAKEFILE)
2524
2525	' if $self->{OBJECT};
2526
2527	my $newer_than_target = $Is_VMS ? '$(MMS$SOURCE_LIST)' : '$?';
2528	my $mpl_args = join " ", map qq["$_"], @ARGV;
2529
2530	$m .= sprintf <<'MAKE_FRAG', $newer_than_target, $mpl_args;
2531	# We take a very conservative approach here, but it's worth it.
2532	# We move Makefile to Makefile.old here to avoid gnu make looping.
2533	$(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP)
2534	$(NOECHO) $(ECHO) "Makefile out-of-date with respect to %s"
2535	$(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..."
2536	-$(NOECHO) $(RM_F) $(MAKEFILE_OLD)
2537	-$(NOECHO) $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD)
2538	- $(MAKE) $(USEMAKEFILE) $(MAKEFILE_OLD) clean $(DEV_NULL)
2539	$(PERLRUN) Makefile.PL %s
2540	$(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <=="
2541	$(NOECHO) $(ECHO) "==> Please rerun the $(MAKE) command. <=="
2542	false
2543
2544	MAKE_FRAG
2545
2546	return $m;
2547	}
2548
2549
2550	=item maybe_command
2551
2552	Returns true, if the argument is likely to be a command.
2553
2554	=cut
2555
2556	sub maybe_command {
2557	my($self,$file) = @_;
2558	return $file if -x $file && ! -d $file;
2559	return;
2560	}
2561
2562
2563	=item needs_linking (o)
2564
2565	Does this module need linking? Looks into subdirectory objects (see
2566	also has_link_code())
2567
2568	=cut
2569
2570	sub needs_linking {
2571	my($self) = shift;
2572	my($child,$caller);
2573	$caller = (caller(0))[3];
2574	confess("needs_linking called too early") if
2575	$caller =~ /^ExtUtils::MakeMaker::/;
2576	return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2577	if ($self->has_link_code or $self->{MAKEAPERL}){
2578	$self->{NEEDS_LINKING} = 1;
2579	return 1;
2580	}
2581	foreach $child (keys %{$self->{CHILDREN}}) {
2582	if ($self->{CHILDREN}->{$child}->needs_linking) {
2583	$self->{NEEDS_LINKING} = 1;
2584	return 1;
2585	}
2586	}
2587	return $self->{NEEDS_LINKING} = 0;
2588	}
2589
2590	=item nicetext
2591
2592	misnamed method (will have to be changed). The MM_Unix method just
2593	returns the argument without further processing.
2594
2595	On VMS used to insure that colons marking targets are preceded by
2596	space - most Unix Makes don't need this, but it's necessary under VMS
2597	to distinguish the target delimiter from a colon appearing as part of
2598	a filespec.
2599
2600	=cut
2601
2602	sub nicetext {
2603	my($self,$text) = @_;
2604	$text;
2605	}
2606
2607	=item parse_abstract
2608
2609	parse a file and return what you think is the ABSTRACT
2610
2611	=cut
2612
2613	sub parse_abstract {
2614	my($self,$parsefile) = @_;
2615	my $result;
2616	local *FH;
2617	local $/ = "\n";
2618	open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2619	my $inpod = 0;
2620	my $package = $self->{DISTNAME};
2621	$package =~ s/-/::/g;
2622	while (<FH>) {
2623	$inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2624	next if !$inpod;
2625	chop;
2626	next unless /^($package\s-\s)(.*)/;
2627	$result = $2;
2628	last;
2629	}
2630	close FH;
2631	return $result;
2632	}
2633
2634	=item parse_version
2635
2636	parse a file and return what you think is $VERSION in this file set to.
2637	It will return the string "undef" if it can't figure out what $VERSION
2638	is. $VERSION should be for all to see, so our $VERSION or plain $VERSION
2639	are okay, but my $VERSION is not.
2640
2641	=cut
2642
2643	sub parse_version {
2644	my($self,$parsefile) = @_;
2645	my $result;
2646	local *FH;
2647	local $/ = "\n";
2648	local $_;
2649	open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2650	my $inpod = 0;
2651	while (<FH>) {
2652	$inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2653	next if $inpod \|\| /^\s*#/;
2654	chop;
2655	next unless /(?<!\\)([\$])(([\w\:\'])\bVERSION)\b.*\=/;
2656	my $eval = qq{
2657	package ExtUtils::MakeMaker::_version;
2658	no strict;
2659
2660	local $1$2;
2661	\$$2=undef; do {
2662	$_
2663	}; \$$2
2664	};
2665	local $^W = 0;
2666	$result = eval($eval);
2667	warn "Could not eval '$eval' in $parsefile: $@" if $@;
2668	last;
2669	}
2670	close FH;
2671
2672	$result = "undef" unless defined $result;
2673	return $result;
2674	}
2675
2676
2677	=item pasthru (o)
2678
2679	Defines the string that is passed to recursive make calls in
2680	subdirectories.
2681
2682	=cut
2683
2684	sub pasthru {
2685	my($self) = shift;
2686	my(@m,$key);
2687
2688	my(@pasthru);
2689	my($sep) = $Is_VMS ? ',' : '';
2690	$sep .= "\\\n\t";
2691
2692	foreach $key (qw(LIB LIBPERL_A LINKTYPE OPTIMIZE
2693	PREFIX INSTALLBASE)
2694	)
2695	{
2696	next unless defined $self->{$key};
2697	push @pasthru, "$key=\"\$($key)\"";
2698	}
2699
2700	foreach $key (qw(DEFINE INC)) {
2701	next unless defined $self->{$key};
2702	push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
2703	}
2704
2705	push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2706	join "", @m;
2707	}
2708
2709	=item perl_script
2710
2711	Takes one argument, a file name, and returns the file name, if the
2712	argument is likely to be a perl script. On MM_Unix this is true for
2713	any ordinary, readable file.
2714
2715	=cut
2716
2717	sub perl_script {
2718	my($self,$file) = @_;
2719	return $file if -r $file && -f _;
2720	return;
2721	}
2722
2723	=item perldepend (o)
2724
2725	Defines the dependency from all *.h files that come with the perl
2726	distribution.
2727
2728	=cut
2729
2730	sub perldepend {
2731	my($self) = shift;
2732	my(@m);
2733
2734	my $make_config = $self->cd('$(PERL_SRC)', '$(MAKE) lib/Config.pm');
2735
2736	push @m, sprintf <<'MAKE_FRAG', $make_config if $self->{PERL_SRC};
2737	# Check for unpropogated config.sh changes. Should never happen.
2738	# We do NOT just update config.h because that is not sufficient.
2739	# An out of date config.h is not fatal but complains loudly!
2740	$(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2741	-$(NOECHO) $(ECHO) "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2742
2743	$(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2744	$(NOECHO) $(ECHO) "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2745	%s
2746	MAKE_FRAG
2747
2748	return join "", @m unless $self->needs_linking;
2749
2750	push @m, q{
2751	PERL_HDRS = \
2752	$(PERL_INC)/EXTERN.h \
2753	$(PERL_INC)/INTERN.h \
2754	$(PERL_INC)/XSUB.h \
2755	$(PERL_INC)/av.h \
2756	$(PERL_INC)/cc_runtime.h \
2757	$(PERL_INC)/config.h \
2758	$(PERL_INC)/cop.h \
2759	$(PERL_INC)/cv.h \
2760	$(PERL_INC)/dosish.h \
2761	$(PERL_INC)/embed.h \
2762	$(PERL_INC)/embedvar.h \
2763	$(PERL_INC)/fakethr.h \
2764	$(PERL_INC)/form.h \
2765	$(PERL_INC)/gv.h \
2766	$(PERL_INC)/handy.h \
2767	$(PERL_INC)/hv.h \
2768	$(PERL_INC)/intrpvar.h \
2769	$(PERL_INC)/iperlsys.h \
2770	$(PERL_INC)/keywords.h \
2771	$(PERL_INC)/mg.h \
2772	$(PERL_INC)/nostdio.h \
2773	$(PERL_INC)/op.h \
2774	$(PERL_INC)/opcode.h \
2775	$(PERL_INC)/patchlevel.h \
2776	$(PERL_INC)/perl.h \
2777	$(PERL_INC)/perlio.h \
2778	$(PERL_INC)/perlsdio.h \
2779	$(PERL_INC)/perlsfio.h \
2780	$(PERL_INC)/perlvars.h \
2781	$(PERL_INC)/perly.h \
2782	$(PERL_INC)/pp.h \
2783	$(PERL_INC)/pp_proto.h \
2784	$(PERL_INC)/proto.h \
2785	$(PERL_INC)/regcomp.h \
2786	$(PERL_INC)/regexp.h \
2787	$(PERL_INC)/regnodes.h \
2788	$(PERL_INC)/scope.h \
2789	$(PERL_INC)/sv.h \
2790	$(PERL_INC)/thrdvar.h \
2791	$(PERL_INC)/thread.h \
2792	$(PERL_INC)/unixish.h \
2793	$(PERL_INC)/util.h
2794
2795	$(OBJECT) : $(PERL_HDRS)
2796	} if $self->{OBJECT};
2797
2798	push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}};
2799
2800	join "\n", @m;
2801	}
2802
2803
2804	=item perm_rw (o)
2805
2806	Returns the attribute C<PERM_RW> or the string C<644>.
2807	Used as the string that is passed
2808	to the C<chmod> command to set the permissions for read/writeable files.
2809	MakeMaker chooses C<644> because it has turned out in the past that
2810	relying on the umask provokes hard-to-track bug reports.
2811	When the return value is used by the perl function C<chmod>, it is
2812	interpreted as an octal value.
2813
2814	=cut
2815
2816	sub perm_rw {
2817	return shift->{PERM_RW};
2818	}
2819
2820	=item perm_rwx (o)
2821
2822	Returns the attribute C<PERM_RWX> or the string C<755>,
2823	i.e. the string that is passed
2824	to the C<chmod> command to set the permissions for executable files.
2825	See also perl_rw.
2826
2827	=cut
2828
2829	sub perm_rwx {
2830	return shift->{PERM_RWX};
2831	}
2832
2833	=item pm_to_blib
2834
2835	Defines target that copies all files in the hash PM to their
2836	destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
2837
2838	=cut
2839
2840	sub pm_to_blib {
2841	my $self = shift;
2842	my($autodir) = $self->catdir('$(INST_LIB)','auto');
2843	my $r = q{
2844	pm_to_blib : $(TO_INST_PM)
2845	};
2846
2847	my $pm_to_blib = $self->oneliner(<<CODE, ['-MExtUtils::Install']);
2848	pm_to_blib({\@ARGV}, '$autodir', '\$(PM_FILTER)')
2849	CODE
2850
2851	my @cmds = $self->split_command($pm_to_blib, %{$self->{PM}});
2852
2853	$r .= join '', map { "\t\$(NOECHO) $_\n" } @cmds;
2854	$r .= qq{\t\$(NOECHO) \$(TOUCH) pm_to_blib\n};
2855
2856	return $r;
2857	}
2858
2859	=item post_constants (o)
2860
2861	Returns an empty string per default. Dedicated to overrides from
2862	within Makefile.PL after all constants have been defined.
2863
2864	=cut
2865
2866	sub post_constants{
2867	"";
2868	}
2869
2870	=item post_initialize (o)
2871
2872	Returns an empty string per default. Used in Makefile.PLs to add some
2873	chunk of text to the Makefile after the object is initialized.
2874
2875	=cut
2876
2877	sub post_initialize {
2878	"";
2879	}
2880
2881	=item postamble (o)
2882
2883	Returns an empty string. Can be used in Makefile.PLs to write some
2884	text to the Makefile at the end.
2885
2886	=cut
2887
2888	sub postamble {
2889	"";
2890	}
2891
2892	=item ppd
2893
2894	Defines target that creates a PPD (Perl Package Description) file
2895	for a binary distribution.
2896
2897	=cut
2898
2899	sub ppd {
2900	my($self) = @_;
2901
2902	if ($self->{ABSTRACT_FROM}){
2903	$self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2904	carp "WARNING: Setting ABSTRACT via file ".
2905	"'$self->{ABSTRACT_FROM}' failed\n";
2906	}
2907
2908	my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3];
2909
2910	my $abstract = $self->{ABSTRACT} \|\| '';
2911	$abstract =~ s/\n/\\n/sg;
2912	$abstract =~ s/</</g;
2913	$abstract =~ s/>/>/g;
2914
2915	my $author = $self->{AUTHOR} \|\| '';
2916	$author =~ s/</</g;
2917	$author =~ s/>/>/g;
2918
2919	my $ppd_xml = sprintf <<'PPD_HTML', $pack_ver, $abstract, $author;
2920	<SOFTPKG NAME="$(DISTNAME)" VERSION="%s">
2921	<TITLE>$(DISTNAME)</TITLE>
2922	<ABSTRACT>%s</ABSTRACT>
2923	<AUTHOR>%s</AUTHOR>
2924	PPD_HTML
2925
2926	$ppd_xml .= " <IMPLEMENTATION>\n";
2927	foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
2928	my $pre_req = $prereq;
2929	$pre_req =~ s/::/-/g;
2930	my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}),
2931	(0) x 4) [0 .. 3];
2932	$ppd_xml .= sprintf <<'PPD_OUT', $pre_req, $dep_ver;
2933	<DEPENDENCY NAME="%s" VERSION="%s" />
2934	PPD_OUT
2935
2936	}
2937
2938	$ppd_xml .= sprintf <<'PPD_OUT', $Config{archname};
2939	<OS NAME="$(OSNAME)" />
2940	<ARCHITECTURE NAME="%s" />
2941	PPD_OUT
2942
2943	if ($self->{PPM_INSTALL_SCRIPT}) {
2944	if ($self->{PPM_INSTALL_EXEC}) {
2945	$ppd_xml .= sprintf qq{ <INSTALL EXEC="%s">%s</INSTALL>\n},
2946	$self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
2947	}
2948	else {
2949	$ppd_xml .= sprintf qq{ <INSTALL>%s</INSTALL>\n},
2950	$self->{PPM_INSTALL_SCRIPT};
2951	}
2952	}
2953
2954	my ($bin_location) = $self->{BINARY_LOCATION} \|\| '';
2955	$bin_location =~ s/\\/\\\\/g;
2956
2957	$ppd_xml .= sprintf <<'PPD_XML', $bin_location;
2958	<CODEBASE HREF="%s" />
2959	</IMPLEMENTATION>
2960	</SOFTPKG>
2961	PPD_XML
2962
2963	my @ppd_cmds = $self->echo($ppd_xml, '$(DISTNAME).ppd');
2964
2965	return sprintf <<'PPD_OUT', join "\n\t", @ppd_cmds;
2966	# Creates a PPD (Perl Package Description) for a binary distribution.
2967	ppd:
2968	%s
2969	PPD_OUT
2970
2971	}
2972
2973	=item prefixify
2974
2975	$MM->prefixify($var, $prefix, $new_prefix, $default);
2976
2977	Using either $MM->{uc $var} \|\| $Config{lc $var}, it will attempt to
2978	replace it's $prefix with a $new_prefix.
2979
2980	Should the $prefix fail to match I<AND> a PREFIX was given as an
2981	argument to WriteMakefile() it will set it to the $new_prefix +
2982	$default. This is for systems whose file layouts don't neatly fit into
2983	our ideas of prefixes.
2984
2985	This is for heuristics which attempt to create directory structures
2986	that mirror those of the installed perl.
2987
2988	For example:
2989
2990	$MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');
2991
2992	this will attempt to remove '/usr' from the front of the
2993	$MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
2994	if necessary) and replace it with '/home/foo'. If this fails it will
2995	simply use '/home/foo/man/man1'.
2996
2997	=cut
2998
2999	sub prefixify {
3000	my($self,$var,$sprefix,$rprefix,$default) = @_;
3001
3002	my $path = $self->{uc $var} \|\|
3003	$Config_Override{lc $var} \|\| $Config{lc $var} \|\| '';
3004
3005	$rprefix .= '/' if $sprefix =~ m\|/$\|;
3006
3007	print STDERR " prefixify $var => $path\n" if $Verbose >= 2;
3008	print STDERR " from $sprefix to $rprefix\n" if $Verbose >= 2;
3009
3010	if( $self->{ARGS}{PREFIX} && $self->file_name_is_absolute($path) &&
3011	$path !~ s{^\Q$sprefix\E\b}{$rprefix}s )
3012	{
3013
3014	print STDERR " cannot prefix, using default.\n" if $Verbose >= 2;
3015	print STDERR " no default!\n" if !$default && $Verbose >= 2;
3016
3017	$path = $self->catdir($rprefix, $default) if $default;
3018	}
3019
3020	print " now $path\n" if $Verbose >= 2;
3021	return $self->{uc $var} = $path;
3022	}
3023
3024
3025	=item processPL (o)
3026
3027	Defines targets to run *.PL files.
3028
3029	=cut
3030
3031	sub processPL {
3032	my $self = shift;
3033	my $pl_files = $self->{PL_FILES};
3034
3035	return "" unless $pl_files;
3036
3037	my $m = '';
3038	foreach my $plfile (sort keys %$pl_files) {
3039	my $list = ref($pl_files->{$plfile})
3040	? $pl_files->{$plfile}
3041	: [$pl_files->{$plfile}];
3042
3043	foreach my $target (@$list) {
3044	if( $Is_VMS ) {
3045	$plfile = vmsify($plfile);
3046	$target = vmsify($target);
3047	}
3048
3049	# Normally a .PL file runs AFTER pm_to_blib so it can have
3050	# blib in its @INC and load the just built modules. BUT if
3051	# the generated module is something in $(TO_INST_PM) which
3052	# pm_to_blib depends on then it can't depend on pm_to_blib
3053	# else we have a dependency loop.
3054	my $pm_dep;
3055	my $perlrun;
3056	if( defined $self->{PM}{$target} ) {
3057	$pm_dep = '';
3058	$perlrun = 'PERLRUN';
3059	}
3060	else {
3061	$pm_dep = 'pm_to_blib';
3062	$perlrun = 'PERLRUNINST';
3063	}
3064
3065	$m .= <<MAKE_FRAG;
3066
3067	all :: $target
3068	\$(NOECHO) \$(NOOP)
3069
3070	$target :: $plfile $pm_dep
3071	\$($perlrun) $plfile $target
3072	MAKE_FRAG
3073
3074	}
3075	}
3076
3077	return $m;
3078	}
3079
3080	=item quote_paren
3081
3082	Backslashes parentheses C<()> in command line arguments.
3083	Doesn't handle recursive Makefile C<$(...)> constructs,
3084	but handles simple ones.
3085
3086	=cut
3087
3088	sub quote_paren {
3089	my $arg = shift;
3090	$arg =~ s{\$\((.+?)\)}{\$\\\\($1\\\\)}g; # protect $(...)
3091	$arg =~ s{(?<!\\)([()])}{\\$1}g; # quote unprotected
3092	$arg =~ s{\$\\\\\((.+?)\\\\\)}{\$($1)}g; # unprotect $(...)
3093	return $arg;
3094	}
3095
3096	=item replace_manpage_separator
3097
3098	my $man_name = $MM->replace_manpage_separator($file_path);
3099
3100	Takes the name of a package, which may be a nested package, in the
3101	form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
3102	safe for a man page file name. Returns the replacement.
3103
3104	=cut
3105
3106	sub replace_manpage_separator {
3107	my($self,$man) = @_;
3108
3109	$man =~ s,/+,::,g;
3110	return $man;
3111	}
3112
3113
3114	=item cd
3115
3116	=cut
3117
3118	sub cd {
3119	my($self, $dir, @cmds) = @_;
3120
3121	# No leading tab and no trailing newline makes for easier embedding
3122	my $make_frag = join "\n\t", map { "cd $dir && $_" } @cmds;
3123
3124	return $make_frag;
3125	}
3126
3127	=item oneliner
3128
3129	=cut
3130
3131	sub oneliner {
3132	my($self, $cmd, $switches) = @_;
3133	$switches = [] unless defined $switches;
3134
3135	# Strip leading and trailing newlines
3136	$cmd =~ s{^\n+}{};
3137	$cmd =~ s{\n+$}{};
3138
3139	my @cmds = split /\n/, $cmd;
3140	$cmd = join " \n\t -e ", map $self->quote_literal($_), @cmds;
3141	$cmd = $self->escape_newlines($cmd);
3142
3143	$switches = join ' ', @$switches;
3144
3145	return qq{\$(ABSPERLRUN) $switches -e $cmd};
3146	}
3147
3148
3149	=item quote_literal
3150
3151	=cut
3152
3153	sub quote_literal {
3154	my($self, $text) = @_;
3155
3156	# I think all we have to quote is single quotes and I think
3157	# this is a safe way to do it.
3158	$text =~ s{'}{'\\''}g;
3159
3160	return "'$text'";
3161	}
3162
3163
3164	=item escape_newlines
3165
3166	=cut
3167
3168	sub escape_newlines {
3169	my($self, $text) = @_;
3170
3171	$text =~ s{\n}{\\\n}g;
3172
3173	return $text;
3174	}
3175
3176
3177	=item max_exec_len
3178
3179	Using POSIX::ARG_MAX. Otherwise falling back to 4096.
3180
3181	=cut
3182
3183	sub max_exec_len {
3184	my $self = shift;
3185
3186	if (!defined $self->{_MAX_EXEC_LEN}) {
3187	if (my $arg_max = eval { require POSIX; &POSIX::ARG_MAX }) {
3188	$self->{_MAX_EXEC_LEN} = $arg_max;
3189	}
3190	else { # POSIX minimum exec size
3191	$self->{_MAX_EXEC_LEN} = 4096;
3192	}
3193	}
3194
3195	return $self->{_MAX_EXEC_LEN};
3196	}
3197
3198
3199	=item static (o)
3200
3201	Defines the static target.
3202
3203	=cut
3204
3205	sub static {
3206	# --- Static Loading Sections ---
3207
3208	my($self) = shift;
3209	'
3210	## $(INST_PM) has been moved to the all: target.
3211	## It remains here for awhile to allow for old usage: "make static"
3212	static :: $(FIRST_MAKEFILE) $(INST_STATIC)
3213	$(NOECHO) $(NOOP)
3214	';
3215	}
3216
3217	=item static_lib (o)
3218
3219	Defines how to produce the *.a (or equivalent) files.
3220
3221	=cut
3222
3223	sub static_lib {
3224	my($self) = @_;
3225	return '' unless $self->has_link_code;
3226
3227	my(@m);
3228	push(@m, <<'END');
3229
3230	$(INST_STATIC) : $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DFSEP).exists
3231	$(RM_RF) $@
3232	END
3233
3234	# If this extension has its own library (eg SDBM_File)
3235	# then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3236	push(@m, <<'MAKE_FRAG') if $self->{MYEXTLIB};
3237	$(CP) $(MYEXTLIB) $@
3238	MAKE_FRAG
3239
3240	my $ar;
3241	if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3242	# Prefer the absolute pathed ar if available so that PATH
3243	# doesn't confuse us. Perl itself is built with the full_ar.
3244	$ar = 'FULL_AR';
3245	} else {
3246	$ar = 'AR';
3247	}
3248	push @m, sprintf <<'MAKE_FRAG', $ar;
3249	$(%s) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
3250	$(CHMOD) $(PERM_RWX) $@
3251	$(NOECHO) $(ECHO) "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3252	MAKE_FRAG
3253
3254	# Old mechanism - still available:
3255	push @m, <<'MAKE_FRAG' if $self->{PERL_SRC} && $self->{EXTRALIBS};
3256	$(NOECHO) $(ECHO) "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3257	MAKE_FRAG
3258
3259	join('', @m);
3260	}
3261
3262	=item staticmake (o)
3263
3264	Calls makeaperl.
3265
3266	=cut
3267
3268	sub staticmake {
3269	my($self, %attribs) = @_;
3270	my(@static);
3271
3272	my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB});
3273
3274	# And as it's not yet built, we add the current extension
3275	# but only if it has some C code (or XS code, which implies C code)
3276	if (@{$self->{C}}) {
3277	@static = $self->catfile($self->{INST_ARCHLIB},
3278	"auto",
3279	$self->{FULLEXT},
3280	"$self->{BASEEXT}$self->{LIB_EXT}"
3281	);
3282	}
3283
3284	# Either we determine now, which libraries we will produce in the
3285	# subdirectories or we do it at runtime of the make.
3286
3287	# We could ask all subdir objects, but I cannot imagine, why it
3288	# would be necessary.
3289
3290	# Instead we determine all libraries for the new perl at
3291	# runtime.
3292	my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3293
3294	$self->makeaperl(MAKE => $self->{MAKEFILE},
3295	DIRS => \@searchdirs,
3296	STAT => \@static,
3297	INCL => \@perlinc,
3298	TARGET => $self->{MAP_TARGET},
3299	TMP => "",
3300	LIBPERL => $self->{LIBPERL_A}
3301	);
3302	}
3303
3304	=item subdir_x (o)
3305
3306	Helper subroutine for subdirs
3307
3308	=cut
3309
3310	sub subdir_x {
3311	my($self, $subdir) = @_;
3312
3313	my $subdir_cmd = $self->cd($subdir,
3314	'$(MAKE) $(USEMAKEFILE) $(FIRST_MAKEFILE) all $(PASTHRU)'
3315	);
3316	return sprintf <<'EOT', $subdir_cmd;
3317
3318	subdirs ::
3319	$(NOECHO) %s
3320	EOT
3321
3322	}
3323
3324	=item subdirs (o)
3325
3326	Defines targets to process subdirectories.
3327
3328	=cut
3329
3330	sub subdirs {
3331	# --- Sub-directory Sections ---
3332	my($self) = shift;
3333	my(@m,$dir);
3334	# This method provides a mechanism to automatically deal with
3335	# subdirectories containing further Makefile.PL scripts.
3336	# It calls the subdir_x() method for each subdirectory.
3337	foreach $dir (@{$self->{DIR}}){
3338	push(@m, $self->subdir_x($dir));
3339	#### print "Including $dir subdirectory\n";
3340	}
3341	if (@m){
3342	unshift(@m, "
3343	# The default clean, realclean and test targets in this Makefile
3344	# have automatically been given entries for each subdir.
3345
3346	");
3347	} else {
3348	push(@m, "\n# none")
3349	}
3350	join('',@m);
3351	}
3352
3353	=item test (o)
3354
3355	Defines the test targets.
3356
3357	=cut
3358
3359	sub test {
3360	# --- Test and Installation Sections ---
3361
3362	my($self, %attribs) = @_;
3363	my $tests = $attribs{TESTS} \|\| '';
3364	if (!$tests && -d 't') {
3365	$tests = $self->find_tests;
3366	}
3367	# note: 'test.pl' name is also hardcoded in init_dirscan()
3368	my(@m);
3369	push(@m,"
3370	TEST_VERBOSE=0
3371	TEST_TYPE=test_\$(LINKTYPE)
3372	TEST_FILE = test.pl
3373	TEST_FILES = $tests
3374	TESTDB_SW = -d
3375
3376	testdb :: testdb_\$(LINKTYPE)
3377
3378	test :: \$(TEST_TYPE)
3379	");
3380
3381	foreach my $dir (@{ $self->{DIR} }) {
3382	my $test = $self->oneliner(sprintf <<'CODE', $dir);
3383	chdir '%s';
3384	system '$(MAKE) test $(PASTHRU)'
3385	if -f '$(FIRST_MAKEFILE)';
3386	CODE
3387
3388	push(@m, "\t\$(NOECHO) $test\n");
3389	}
3390
3391	push(@m, "\t\$(NOECHO) \$(ECHO) 'No tests defined for \$(NAME) extension.'\n")
3392	unless $tests or -f "test.pl" or @{$self->{DIR}};
3393	push(@m, "\n");
3394
3395	push(@m, "test_dynamic :: pure_all\n");
3396	push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)'))
3397	if $tests;
3398	push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)'))
3399	if -f "test.pl";
3400	push(@m, "\n");
3401
3402	push(@m, "testdb_dynamic :: pure_all\n");
3403	push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)',
3404	'$(TEST_FILE)'));
3405	push(@m, "\n");
3406
3407	# Occasionally we may face this degenerate target:
3408	push @m, "test_ : test_dynamic\n\n";
3409
3410	if ($self->needs_linking()) {
3411	push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3412	push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3413	push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3414	push(@m, "\n");
3415	push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3416	push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3417	push(@m, "\n");
3418	} else {
3419	push @m, "test_static :: test_dynamic\n";
3420	push @m, "testdb_static :: testdb_dynamic\n";
3421	}
3422	join("", @m);
3423	}
3424
3425	=item test_via_harness (override)
3426
3427	For some reason which I forget, Unix machines like to have
3428	PERL_DL_NONLAZY set for tests.
3429
3430	=cut
3431
3432	sub test_via_harness {
3433	my($self, $perl, $tests) = @_;
3434	return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
3435	}
3436
3437	=item test_via_script (override)
3438
3439	Again, the PERL_DL_NONLAZY thing.
3440
3441	=cut
3442
3443	sub test_via_script {
3444	my($self, $perl, $script) = @_;
3445	return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
3446	}
3447
3448
3449	=item tools_other (o)
3450
3451	my $make_frag = $MM->tools_other;
3452
3453	Returns a make fragment containing definitions for the macros init_others()
3454	initializes.
3455
3456	=cut
3457
3458	sub tools_other {
3459	my($self) = shift;
3460	my @m;
3461
3462	# We set PM_FILTER as late as possible so it can see all the earlier
3463	# on macro-order sensitive makes such as nmake.
3464	for my $tool (qw{ SHELL CHMOD CP MV NOOP NOECHO RM_F RM_RF TEST_F TOUCH
3465	UMASK_NULL DEV_NULL MKPATH EQUALIZE_TIMESTAMP
3466	ECHO ECHO_N
3467	UNINST VERBINST
3468	MOD_INSTALL DOC_INSTALL UNINSTALL
3469	WARN_IF_OLD_PACKLIST
3470	MACROSTART MACROEND
3471	USEMAKEFILE
3472	PM_FILTER
3473	FIXIN
3474	} )
3475	{
3476	next unless defined $self->{$tool};
3477	push @m, "$tool = $self->{$tool}\n";
3478	}
3479
3480	return join "", @m;
3481	}
3482
3483	=item tool_xsubpp (o)
3484
3485	Determines typemaps, xsubpp version, prototype behaviour.
3486
3487	=cut
3488
3489	sub tool_xsubpp {
3490	my($self) = shift;
3491	return "" unless $self->needs_linking;
3492
3493	my $xsdir;
3494	my @xsubpp_dirs = @INC;
3495
3496	# Make sure we pick up the new xsubpp if we're building perl.
3497	unshift @xsubpp_dirs, $self->{PERL_LIB} if $self->{PERL_CORE};
3498
3499	foreach my $dir (@xsubpp_dirs) {
3500	$xsdir = $self->catdir($dir, 'ExtUtils');
3501	if( -r $self->catfile($xsdir, "xsubpp") ) {
3502	last;
3503	}
3504	}
3505
3506	my $tmdir = File::Spec->catdir($self->{PERL_LIB},"ExtUtils");
3507	my(@tmdeps) = $self->catfile($tmdir,'typemap');
3508	if( $self->{TYPEMAPS} ){
3509	my $typemap;
3510	foreach $typemap (@{$self->{TYPEMAPS}}){
3511	if( ! -f $typemap ){
3512	warn "Typemap $typemap not found.\n";
3513	}
3514	else{
3515	push(@tmdeps, $typemap);
3516	}
3517	}
3518	}
3519	push(@tmdeps, "typemap") if -f "typemap";
3520	my(@tmargs) = map("-typemap $_", @tmdeps);
3521	if( exists $self->{XSOPT} ){
3522	unshift( @tmargs, $self->{XSOPT} );
3523	}
3524
3525	if ($Is_VMS &&
3526	$Config{'ldflags'} &&
3527	$Config{'ldflags'} =~ m!/Debug!i &&
3528	(!exists($self->{XSOPT}) \|\| $self->{XSOPT} !~ /linenumbers/)
3529	)
3530	{
3531	unshift(@tmargs,'-nolinenumbers');
3532	}
3533
3534
3535	$self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3536
3537	return qq{
3538	XSUBPPDIR = $xsdir
3539	XSUBPP = \$(XSUBPPDIR)\$(DFSEP)xsubpp
3540	XSUBPPRUN = \$(PERLRUN) \$(XSUBPP)
3541	XSPROTOARG = $self->{XSPROTOARG}
3542	XSUBPPDEPS = @tmdeps \$(XSUBPP)
3543	XSUBPPARGS = @tmargs
3544	XSUBPP_EXTRA_ARGS =
3545	};
3546	};
3547
3548
3549	=item all_target
3550
3551	Build man pages, too
3552
3553	=cut
3554
3555	sub all_target {
3556	my $self = shift;
3557
3558	return <<'MAKE_EXT';
3559	all :: pure_all manifypods
3560	$(NOECHO) $(NOOP)
3561	MAKE_EXT
3562	}
3563
3564	=item top_targets (o)
3565
3566	Defines the targets all, subdirs, config, and O_FILES
3567
3568	=cut
3569
3570	sub top_targets {
3571	# --- Target Sections ---
3572
3573	my($self) = shift;
3574	my(@m);
3575
3576	push @m, $self->all_target, "\n" unless $self->{SKIPHASH}{'all'};
3577
3578	push @m, '
3579	pure_all :: config pm_to_blib subdirs linkext
3580	$(NOECHO) $(NOOP)
3581
3582	subdirs :: $(MYEXTLIB)
3583	$(NOECHO) $(NOOP)
3584
3585	config :: $(FIRST_MAKEFILE) blibdirs
3586	$(NOECHO) $(NOOP)
3587	';
3588
3589	push @m, '
3590	$(O_FILES): $(H_FILES)
3591	' if @{$self->{O_FILES} \|\| []} && @{$self->{H} \|\| []};
3592
3593	push @m, q{
3594	help :
3595	perldoc ExtUtils::MakeMaker
3596	};
3597
3598	join('',@m);
3599	}
3600
3601	=item writedoc
3602
3603	Obsolete, deprecated method. Not used since Version 5.21.
3604
3605	=cut
3606
3607	sub writedoc {
3608	# --- perllocal.pod section ---
3609	my($self,$what,$name,@attribs)=@_;
3610	my $time = localtime;
3611	print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3612	print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3613	print "\n\n=back\n\n";
3614	}
3615
3616	=item xs_c (o)
3617
3618	Defines the suffix rules to compile XS files to C.
3619
3620	=cut
3621
3622	sub xs_c {
3623	my($self) = shift;
3624	return '' unless $self->needs_linking();
3625	'
3626	.xs.c:
3627	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $.xs > $.xsc && $(MV) $.xsc $.c
3628	';
3629	}
3630
3631	=item xs_cpp (o)
3632
3633	Defines the suffix rules to compile XS files to C++.
3634
3635	=cut
3636
3637	sub xs_cpp {
3638	my($self) = shift;
3639	return '' unless $self->needs_linking();
3640	'
3641	.xs.cpp:
3642	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $.xs > $.xsc && $(MV) $.xsc $.cpp
3643	';
3644	}
3645
3646	=item xs_o (o)
3647
3648	Defines suffix rules to go from XS to object files directly. This is
3649	only intended for broken make implementations.
3650
3651	=cut
3652
3653	sub xs_o { # many makes are too dumb to use xs_c then c_o
3654	my($self) = shift;
3655	return '' unless $self->needs_linking();
3656	'
3657	.xs$(OBJ_EXT):
3658	$(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $.xs > $.xsc && $(MV) $.xsc $.c
3659	$(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
3660	';
3661	}
3662
3663
3664	1;
3665
3666	=back
3667
3668	=head1 SEE ALSO
3669
3670	L<ExtUtils::MakeMaker>
3671
3672	=cut
3673
3674	__END__

Note: See TracBrowser for help on using the repository browser.

Download in other formats: