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