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