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