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