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