This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
12ee1d6f08951ef5c69babd101c726cd8c235d22
[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,
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 LD is initialized in init_linker()
1895
1896 =cut
1897
1898 sub init_others {       # --- Initialize Other Attributes
1899     my($self) = shift;
1900
1901
1902
1903     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1904     # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1905     # undefined. In any case we turn it into an anon array:
1906
1907     # May check $Config{libs} too, thus not empty.
1908     $self->{LIBS} = [$self->{LIBS}] unless ref $self->{LIBS};
1909
1910     $self->{LIBS} = [''] unless @{$self->{LIBS}} && defined $self->{LIBS}[0];
1911     $self->{LD_RUN_PATH} = "";
1912     my($libs);
1913     foreach $libs ( @{$self->{LIBS}} ){
1914         $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1915         my(@libs) = $self->extliblist($libs);
1916         if ($libs[0] or $libs[1] or $libs[2]){
1917             # LD_RUN_PATH now computed by ExtUtils::Liblist
1918             ($self->{EXTRALIBS},  $self->{BSLOADLIBS}, 
1919              $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1920             last;
1921         }
1922     }
1923
1924     if ( $self->{OBJECT} ) {
1925         $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1926     } else {
1927         # init_dirscan should have found out, if we have C files
1928         $self->{OBJECT} = "";
1929         $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1930     }
1931     $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1932     $self->{BOOTDEP}  = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1933     $self->{PERLMAINCC} ||= '$(CC)';
1934     $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1935
1936     # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1937     # the 'dynamic' section of MM.  We don't have this problem with
1938     # 'static', since we either must use it (%Config says we can't
1939     # use dynamic loading) or the caller asked for it explicitly.
1940     if (!$self->{LINKTYPE}) {
1941        $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1942                         ? 'static'
1943                         : ($Config{usedl} ? 'dynamic' : 'static');
1944     };
1945
1946     $self->{NOOP}               ||= '$(SHELL) -c true';
1947     $self->{NOECHO}             = '@' unless defined $self->{NOECHO};
1948
1949     $self->{MAKEFILE}           ||= 'Makefile';
1950     $self->{FIRST_MAKEFILE}     ||= $self->{MAKEFILE};
1951     $self->{MAKEFILE_OLD}       ||= '$(FIRST_MAKEFILE).old';
1952     $self->{MAKE_APERL_FILE}    ||= '$(FIRST_MAKEFILE).aperl';
1953
1954     $self->{SHELL}              ||= $Config{sh} || '/bin/sh';
1955
1956     $self->{ECHO}       ||= 'echo';
1957     $self->{ECHO_N}     ||= 'echo -n';
1958     $self->{RM_F}       ||= "rm -f";
1959     $self->{RM_RF}      ||= "rm -rf";
1960     $self->{TOUCH}      ||= "touch";
1961     $self->{TEST_F}     ||= "test -f";
1962     $self->{CP}         ||= "cp";
1963     $self->{MV}         ||= "mv";
1964     $self->{CHMOD}      ||= "chmod";
1965     $self->{MKPATH}     ||= '$(PERLRUN) "-MExtUtils::Command" -e mkpath';
1966     $self->{EQUALIZE_TIMESTAMP} ||= 
1967       '$(PERLRUN) "-MExtUtils::Command" -e eqtime';
1968
1969     $self->{UNINST}     ||= 0;
1970     $self->{VERBINST}   ||= 0;
1971     $self->{MOD_INSTALL} ||= 
1972       $self->oneliner(<<'CODE', ['-MExtUtils::Install']);
1973 install({@ARGV}, '$(VERBINST)', 0, '$(UNINST)');
1974 CODE
1975     $self->{DOC_INSTALL} ||= 
1976       '$(PERLRUN) "-MExtUtils::Command::MM" -e perllocal_install';
1977     $self->{UNINSTALL}   ||= 
1978       '$(PERLRUN) "-MExtUtils::Command::MM" -e uninstall';
1979     $self->{WARN_IF_OLD_PACKLIST} ||= 
1980       '$(PERLRUN) "-MExtUtils::Command::MM" -e warn_if_old_packlist';
1981
1982     $self->{UMASK_NULL}         ||= "umask 0";
1983     $self->{DEV_NULL}           ||= "> /dev/null 2>&1";
1984
1985     return 1;
1986 }
1987
1988 =item init_INST
1989
1990     $mm->init_INST;
1991
1992 Called by init_main.  Sets up all INST_* variables except those related
1993 to XS code.  Those are handled in init_xs.
1994
1995 =cut
1996
1997 sub init_INST {
1998     my($self) = shift;
1999
2000     $self->{INST_ARCHLIB} ||= $self->catdir($Curdir,"blib","arch");
2001     $self->{INST_BIN}     ||= $self->catdir($Curdir,'blib','bin');
2002
2003     # INST_LIB typically pre-set if building an extension after
2004     # perl has been built and installed. Setting INST_LIB allows
2005     # you to build directly into, say $Config{privlibexp}.
2006     unless ($self->{INST_LIB}){
2007         if ($self->{PERL_CORE}) {
2008             if (defined $Cross::platform) {
2009                 $self->{INST_LIB} = $self->{INST_ARCHLIB} = 
2010                   $self->catdir($self->{PERL_LIB},"..","xlib",
2011                                      $Cross::platform);
2012             }
2013             else {
2014                 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
2015             }
2016         } else {
2017             $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib");
2018         }
2019     }
2020
2021     my @parentdir = split(/::/, $self->{PARENT_NAME});
2022     $self->{INST_LIBDIR}      = $self->catdir('$(INST_LIB)',     @parentdir);
2023     $self->{INST_ARCHLIBDIR}  = $self->catdir('$(INST_ARCHLIB)', @parentdir);
2024     $self->{INST_AUTODIR}     = $self->catdir('$(INST_LIB)', 'auto', 
2025                                               '$(FULLEXT)');
2026     $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)', 'auto',
2027                                               '$(FULLEXT)');
2028
2029     $self->{INST_SCRIPT}  ||= $self->catdir($Curdir,'blib','script');
2030
2031     $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1');
2032     $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3');
2033
2034     return 1;
2035 }
2036
2037 =item init_INSTALL
2038
2039     $mm->init_INSTALL;
2040
2041 Called by init_main.  Sets up all INSTALL_* variables (except
2042 INSTALLDIRS) and *PREFIX.
2043
2044 =cut
2045
2046 sub init_INSTALL {
2047     my($self) = shift;
2048
2049     $self->init_lib2arch;
2050
2051     # Initialize installvendorman*dir if necessary
2052     foreach my $num (1, 3) {
2053         my $k = 'installvendorman'.$num.'dir';
2054
2055         unless ($Config{$k}) {
2056             $Config_Override{$k} = $Config{usevendorprefix} ?
2057                   $self->catdir($Config{vendorprefixexp}, 'man', "man$num") :
2058                   '';
2059         }
2060     }
2061
2062     my $iprefix = $Config{installprefixexp} || $Config{installprefix} || 
2063                   $Config{prefixexp}        || $Config{prefix} || '';
2064     my $vprefix = $Config{usevendorprefix}  ? $Config{vendorprefixexp} : '';
2065     my $sprefix = $Config{siteprefixexp}    || '';
2066
2067     # 5.005_03 doesn't have a siteprefix.
2068     $sprefix = $iprefix unless $sprefix;
2069
2070     # There are often no Config.pm defaults for these, but we can make
2071     # it up.
2072     unless( $Config{installsiteman1dir} ) {
2073         $Config_Override{installsiteman1dir} = 
2074           $self->catdir($sprefix, 'man', 'man1');
2075     }
2076
2077     unless( $Config{installsiteman3dir} ) {
2078         $Config_Override{installsiteman3dir} = 
2079           $self->catdir($sprefix, 'man', 'man3');
2080     }
2081
2082     unless( $Config{installsitebin} ) {
2083         $Config_Override{installsitebin} =
2084           $self->catdir($sprefix, 'bin');
2085     }
2086
2087     $self->{PREFIX}       ||= '';
2088
2089     if( $self->{PREFIX} ) {
2090         @{$self}{qw(PERLPREFIX SITEPREFIX VENDORPREFIX)} =
2091           ('$(PREFIX)') x 3;
2092     }
2093     else {
2094         $self->{PERLPREFIX}   ||= $iprefix;
2095         $self->{SITEPREFIX}   ||= $sprefix;
2096         $self->{VENDORPREFIX} ||= $vprefix;
2097     }
2098
2099     my $arch    = $Config{archname};
2100     my $version = $Config{version};
2101
2102     # default style
2103     my $libstyle = $Config{installstyle} || 'lib/perl5';
2104     my $manstyle = '';
2105
2106     if( $self->{LIBSTYLE} ) {
2107         $libstyle = $self->{LIBSTYLE};
2108         $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
2109     }
2110
2111     # Some systems, like VOS, set installman*dir to '' if they can't
2112     # read man pages.
2113     for my $num (1, 3) {
2114         $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none'
2115           unless $Config{'installman'.$num.'dir'};
2116     }
2117
2118     my %bin_layouts = 
2119     (
2120         bin         => { s => $iprefix,
2121                          t => 'perl',
2122                          d => 'bin' },
2123         vendorbin   => { s => $vprefix,
2124                          t => 'vendor',
2125                          d => 'bin' },
2126         sitebin     => { s => $sprefix,
2127                          t => 'site',
2128                          d => 'bin' },
2129         script      => { s => $iprefix,
2130                          t => 'perl',
2131                          d => 'bin' },
2132     );
2133     
2134     my %man_layouts =
2135     (
2136         man1dir         => { s => $iprefix,
2137                              t => 'perl',
2138                              d => 'man/man1',
2139                              style => $manstyle, },
2140         siteman1dir     => { s => $sprefix,
2141                              t => 'site',
2142                              d => 'man/man1',
2143                              style => $manstyle, },
2144         vendorman1dir   => { s => $vprefix,
2145                              t => 'vendor',
2146                              d => 'man/man1',
2147                              style => $manstyle, },
2148
2149         man3dir         => { s => $iprefix,
2150                              t => 'perl',
2151                              d => 'man/man3',
2152                              style => $manstyle, },
2153         siteman3dir     => { s => $sprefix,
2154                              t => 'site',
2155                              d => 'man/man3',
2156                              style => $manstyle, },
2157         vendorman3dir   => { s => $vprefix,
2158                              t => 'vendor',
2159                              d => 'man/man3',
2160                              style => $manstyle, },
2161     );
2162
2163     my %lib_layouts =
2164     (
2165         privlib     => { s => $iprefix,
2166                          t => 'perl',
2167                          d => '',
2168                          style => $libstyle, },
2169         vendorlib   => { s => $vprefix,
2170                          t => 'vendor',
2171                          d => '',
2172                          style => $libstyle, },
2173         sitelib     => { s => $sprefix,
2174                          t => 'site',
2175                          d => 'site_perl',
2176                          style => $libstyle, },
2177         
2178         archlib     => { s => $iprefix,
2179                          t => 'perl',
2180                          d => "$version/$arch",
2181                          style => $libstyle },
2182         vendorarch  => { s => $vprefix,
2183                          t => 'vendor',
2184                          d => "$version/$arch",
2185                          style => $libstyle },
2186         sitearch    => { s => $sprefix,
2187                          t => 'site',
2188                          d => "site_perl/$version/$arch",
2189                          style => $libstyle },
2190     );
2191
2192
2193     # Special case for LIB.
2194     if( $self->{LIB} ) {
2195         foreach my $var (keys %lib_layouts) {
2196             my $Installvar = uc "install$var";
2197
2198             if( $var =~ /arch/ ) {
2199                 $self->{$Installvar} ||= 
2200                   $self->catdir($self->{LIB}, $Config{archname});
2201             }
2202             else {
2203                 $self->{$Installvar} ||= $self->{LIB};
2204             }
2205         }
2206     }
2207
2208     my %type2prefix = ( perl    => 'PERLPREFIX',
2209                         site    => 'SITEPREFIX',
2210                         vendor  => 'VENDORPREFIX'
2211                       );
2212
2213     my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
2214     while( my($var, $layout) = each(%layouts) ) {
2215         my($s, $t, $d, $style) = @{$layout}{qw(s t d style)};
2216         my $r = '$('.$type2prefix{$t}.')';
2217
2218         print STDERR "Prefixing $var\n" if $Verbose >= 2;
2219
2220         my $installvar = "install$var";
2221         my $Installvar = uc $installvar;
2222         next if $self->{$Installvar};
2223
2224         $d = "$style/$d" if $style;
2225         $self->prefixify($installvar, $s, $r, $d);
2226
2227         print STDERR "  $Installvar == $self->{$Installvar}\n" 
2228           if $Verbose >= 2;
2229     }
2230
2231     # Generate these if they weren't figured out.
2232     $self->{VENDORARCHEXP} ||= $self->{INSTALLVENDORARCH};
2233     $self->{VENDORLIBEXP}  ||= $self->{INSTALLVENDORLIB};
2234
2235     return 1;
2236 }
2237
2238 =item init_linker
2239
2240 Unix has no need of special linker flags.
2241
2242 However this does initialize the default linker if it has not already been set. It uses
2243 the value from Config and then falls back to 'ld'
2244
2245 =cut
2246
2247 sub init_linker {
2248     my($self) = shift;
2249     $self->{LD} ||= $Config{ld} || 'ld';
2250     $self->{PERL_ARCHIVE} ||= '';
2251     $self->{PERL_ARCHIVE_AFTER} ||= '';
2252     $self->{EXPORT_LIST}  ||= '';
2253 }
2254
2255
2256 =begin _protected
2257
2258 =item init_lib2arch
2259
2260     $mm->init_lib2arch
2261
2262 =end _protected
2263
2264 =cut
2265
2266 sub init_lib2arch {
2267     my($self) = shift;
2268
2269     # The user who requests an installation directory explicitly
2270     # should not have to tell us an architecture installation directory
2271     # as well. We look if a directory exists that is named after the
2272     # architecture. If not we take it as a sign that it should be the
2273     # same as the requested installation directory. Otherwise we take
2274     # the found one.
2275     for my $libpair ({l=>"privlib",   a=>"archlib"}, 
2276                      {l=>"sitelib",   a=>"sitearch"},
2277                      {l=>"vendorlib", a=>"vendorarch"},
2278                     )
2279     {
2280         my $lib = "install$libpair->{l}";
2281         my $Lib = uc $lib;
2282         my $Arch = uc "install$libpair->{a}";
2283         if( $self->{$Lib} && ! $self->{$Arch} ){
2284             my($ilib) = $Config{$lib};
2285
2286             $self->prefixify($Arch,$ilib,$self->{$Lib});
2287
2288             unless (-d $self->{$Arch}) {
2289                 print STDOUT "Directory $self->{$Arch} not found\n" 
2290                   if $Verbose;
2291                 $self->{$Arch} = $self->{$Lib};
2292             }
2293             print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
2294         }
2295     }
2296 }
2297
2298
2299 =item init_PERL
2300
2301     $mm->init_PERL;
2302
2303 Called by init_main.  Sets up ABSPERL, PERL, FULLPERL and all the
2304 *PERLRUN* permutations.
2305
2306     PERL is allowed to be miniperl
2307     FULLPERL must be a complete perl
2308
2309     ABSPERL is PERL converted to an absolute path
2310
2311     *PERLRUN contains everything necessary to run perl, find it's
2312          libraries, etc...
2313
2314     *PERLRUNINST is *PERLRUN + everything necessary to find the
2315          modules being built.
2316
2317 =cut
2318
2319 sub init_PERL {
2320     my($self) = shift;
2321
2322     my @defpath = ();
2323     foreach my $component ($self->{PERL_SRC}, $self->path(), 
2324                            $Config{binexp}) 
2325     {
2326         push @defpath, $component if defined $component;
2327     }
2328
2329     # Build up a set of file names (not command names).
2330     my $thisperl = $self->canonpath($^X);
2331     $thisperl .= $Config{exe_ext} unless 
2332                 # VMS might have a file version # at the end
2333       $Is_VMS ? $thisperl =~ m/$Config{exe_ext}(;\d+)?$/i
2334               : $thisperl =~ m/$Config{exe_ext}$/i;
2335
2336     # We need a relative path to perl when in the core.
2337     $thisperl = $self->abs2rel($thisperl) if $self->{PERL_CORE};
2338
2339     my @perls = ($thisperl);
2340     push @perls, map { "$_$Config{exe_ext}" }
2341                      ('perl', 'perl5', "perl$Config{version}");
2342
2343     # miniperl has priority over all but the cannonical perl when in the
2344     # core.  Otherwise its a last resort.
2345     my $miniperl = "miniperl$Config{exe_ext}";
2346     if( $self->{PERL_CORE} ) {
2347         splice @perls, 1, 0, $miniperl;
2348     }
2349     else {
2350         push @perls, $miniperl;
2351     }
2352
2353     $self->{PERL} ||=
2354         $self->find_perl(5.0, \@perls, \@defpath, $Verbose );
2355     # don't check if perl is executable, maybe they have decided to
2356     # supply switches with perl
2357
2358     # When built for debugging, VMS doesn't create perl.exe but ndbgperl.exe.
2359     my $perl_name = 'perl';
2360     $perl_name = 'ndbgperl' if $Is_VMS && 
2361       defined $Config{usevmsdebug} && $Config{usevmsdebug} eq 'define';
2362
2363     # XXX This logic is flawed.  If "miniperl" is anywhere in the path
2364     # it will get confused.  It should be fixed to work only on the filename.
2365     # Define 'FULLPERL' to be a non-miniperl (used in test: target)
2366     ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/$perl_name/i
2367         unless $self->{FULLPERL};
2368
2369     # Little hack to get around VMS's find_perl putting "MCR" in front
2370     # sometimes.
2371     $self->{ABSPERL} = $self->{PERL};
2372     my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
2373     if( $self->file_name_is_absolute($self->{ABSPERL}) ) {
2374         $self->{ABSPERL} = '$(PERL)';
2375     }
2376     else {
2377         $self->{ABSPERL} = $self->rel2abs($self->{ABSPERL});
2378         $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
2379     }
2380
2381     # Are we building the core?
2382     $self->{PERL_CORE} = 0 unless exists $self->{PERL_CORE};
2383
2384     # How do we run perl?
2385     foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
2386         my $run  = $perl.'RUN';
2387
2388         $self->{$run}  = "\$($perl)";
2389
2390         # Make sure perl can find itself before it's installed.
2391         $self->{$run} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"} 
2392           if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE};
2393
2394         $self->{$perl.'RUNINST'} = 
2395           sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
2396     }
2397
2398     return 1;
2399 }
2400
2401
2402 =item init_platform (o)
2403
2404 Add MM_Unix_VERSION.
2405
2406 =item platform_constants (o)
2407
2408 =cut
2409
2410 sub init_platform {
2411     my($self) = shift;
2412
2413     $self->{MM_Unix_VERSION} = $VERSION;
2414     $self->{PERL_MALLOC_DEF} = '-DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc '.
2415                                '-Dfree=Perl_mfree -Drealloc=Perl_realloc '.
2416                                '-Dcalloc=Perl_calloc';
2417
2418 }
2419
2420 sub platform_constants {
2421     my($self) = shift;
2422     my $make_frag = '';
2423
2424     foreach my $macro (qw(MM_Unix_VERSION PERL_MALLOC_DEF))
2425     {
2426         next unless defined $self->{$macro};
2427         $make_frag .= "$macro = $self->{$macro}\n";
2428     }
2429
2430     return $make_frag;
2431 }
2432
2433
2434 =item init_PERM
2435
2436   $mm->init_PERM
2437
2438 Called by init_main.  Initializes PERL_*
2439
2440 =cut
2441
2442 sub init_PERM {
2443     my($self) = shift;
2444
2445     $self->{PERM_RW}  = 644  unless defined $self->{PERM_RW};
2446     $self->{PERM_RWX} = 755  unless defined $self->{PERM_RWX};
2447
2448     return 1;
2449 }
2450
2451
2452 =item init_xs
2453
2454     $mm->init_xs
2455
2456 Sets up macros having to do with XS code.  Currently just INST_STATIC,
2457 INST_DYNAMIC and INST_BOOT.
2458
2459 =cut
2460
2461 sub init_xs {
2462     my $self = shift;
2463
2464     if ($self->has_link_code()) {
2465         $self->{INST_STATIC}  = 
2466           $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT)$(LIB_EXT)');
2467         $self->{INST_DYNAMIC} = 
2468           $self->catfile('$(INST_ARCHAUTODIR)', '$(DLBASE).$(DLEXT)');
2469         $self->{INST_BOOT}    = 
2470           $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT).bs');
2471     } else {
2472         $self->{INST_STATIC}  = '';
2473         $self->{INST_DYNAMIC} = '';
2474         $self->{INST_BOOT}    = '';
2475     }
2476 }    
2477
2478 =item install (o)
2479
2480 Defines the install target.
2481
2482 =cut
2483
2484 sub install {
2485     my($self, %attribs) = @_;
2486     my(@m);
2487
2488     push @m, q{
2489 install :: all pure_install doc_install
2490
2491 install_perl :: all pure_perl_install doc_perl_install
2492
2493 install_site :: all pure_site_install doc_site_install
2494
2495 install_vendor :: all pure_vendor_install doc_vendor_install
2496
2497 pure_install :: pure_$(INSTALLDIRS)_install
2498
2499 doc_install :: doc_$(INSTALLDIRS)_install
2500
2501 pure__install : pure_site_install
2502         $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2503
2504 doc__install : doc_site_install
2505         $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2506
2507 pure_perl_install ::
2508         $(NOECHO) $(MOD_INSTALL) \
2509                 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2510                 write }.$self->catfile('$(DESTINSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2511                 $(INST_LIB) $(DESTINSTALLPRIVLIB) \
2512                 $(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \
2513                 $(INST_BIN) $(DESTINSTALLBIN) \
2514                 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2515                 $(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \
2516                 $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR)
2517         $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2518                 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2519
2520
2521 pure_site_install ::
2522         $(NOECHO) $(MOD_INSTALL) \
2523                 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2524                 write }.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2525                 $(INST_LIB) $(DESTINSTALLSITELIB) \
2526                 $(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \
2527                 $(INST_BIN) $(DESTINSTALLSITEBIN) \
2528                 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2529                 $(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \
2530                 $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR)
2531         $(NOECHO) $(WARN_IF_OLD_PACKLIST) \
2532                 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2533
2534 pure_vendor_install ::
2535         $(NOECHO) $(MOD_INSTALL) \
2536                 read }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2537                 write }.$self->catfile('$(DESTINSTALLVENDORARCH)','auto','$(FULLEXT)','.packlist').q{ \
2538                 $(INST_LIB) $(DESTINSTALLVENDORLIB) \
2539                 $(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \
2540                 $(INST_BIN) $(DESTINSTALLVENDORBIN) \
2541                 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \
2542                 $(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \
2543                 $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR)
2544
2545 doc_perl_install ::
2546         $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2547         -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2548         -$(NOECHO) $(DOC_INSTALL) \
2549                 "Module" "$(NAME)" \
2550                 "installed into" "$(INSTALLPRIVLIB)" \
2551                 LINKTYPE "$(LINKTYPE)" \
2552                 VERSION "$(VERSION)" \
2553                 EXE_FILES "$(EXE_FILES)" \
2554                 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2555
2556 doc_site_install ::
2557         $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2558         -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2559         -$(NOECHO) $(DOC_INSTALL) \
2560                 "Module" "$(NAME)" \
2561                 "installed into" "$(INSTALLSITELIB)" \
2562                 LINKTYPE "$(LINKTYPE)" \
2563                 VERSION "$(VERSION)" \
2564                 EXE_FILES "$(EXE_FILES)" \
2565                 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2566
2567 doc_vendor_install ::
2568         $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2569         -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2570         -$(NOECHO) $(DOC_INSTALL) \
2571                 "Module" "$(NAME)" \
2572                 "installed into" "$(INSTALLVENDORLIB)" \
2573                 LINKTYPE "$(LINKTYPE)" \
2574                 VERSION "$(VERSION)" \
2575                 EXE_FILES "$(EXE_FILES)" \
2576                 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2577
2578 };
2579
2580     push @m, q{
2581 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2582
2583 uninstall_from_perldirs ::
2584         $(NOECHO) $(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2585
2586 uninstall_from_sitedirs ::
2587         $(NOECHO) $(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2588
2589 uninstall_from_vendordirs ::
2590         $(NOECHO) $(UNINSTALL) }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2591 };
2592
2593     join("",@m);
2594 }
2595
2596 =item installbin (o)
2597
2598 Defines targets to make and to install EXE_FILES.
2599
2600 =cut
2601
2602 sub installbin {
2603     my($self) = shift;
2604     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2605     return "" unless @{$self->{EXE_FILES}};
2606     my(@m, $from, $to, %fromto, @to);
2607     push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2608     for $from (@{$self->{EXE_FILES}}) {
2609         my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2610         local($_) = $path; # for backwards compatibility
2611         $to = $self->libscan($path);
2612         print "libscan($from) => '$to'\n" if ($Verbose >=2);
2613         $fromto{$from}=$to;
2614     }
2615     @to   = values %fromto;
2616
2617     my $fixin;
2618     if( $Is_Win32 ) {
2619         $fixin = $self->{PERL_CORE} ? '$(PERLRUN) ../../win32/bin/pl2bat.pl'
2620                                     : 'pl2bat.bat';
2621     }
2622     else {
2623         $fixin = q{$(PERLRUN) "-MExtUtils::MY" -e "MY->fixin(shift)"};
2624     }
2625
2626     push(@m, qq{
2627 EXE_FILES = @{$self->{EXE_FILES}}
2628
2629 FIXIN = $fixin
2630
2631 pure_all :: @to
2632         \$(NOECHO) \$(NOOP)
2633
2634 realclean ::
2635         \$(RM_F) @to
2636 });
2637
2638     while (($from,$to) = each %fromto) {
2639         last unless defined $from;
2640         my $todir = dirname($to);
2641         push @m, "
2642 $to: $from \$(FIRST_MAKEFILE) " . $self->catdir($todir,'.exists') . "
2643         \$(NOECHO) \$(RM_F) $to
2644         \$(CP) $from $to
2645         \$(FIXIN) $to
2646         -\$(NOECHO) \$(CHMOD) \$(PERM_RWX) $to
2647 ";
2648     }
2649     join "", @m;
2650 }
2651
2652
2653 =item linkext (o)
2654
2655 Defines the linkext target which in turn defines the LINKTYPE.
2656
2657 =cut
2658
2659 sub linkext {
2660     my($self, %attribs) = @_;
2661     # LINKTYPE => static or dynamic or ''
2662     my($linktype) = defined $attribs{LINKTYPE} ?
2663       $attribs{LINKTYPE} : '$(LINKTYPE)';
2664     "
2665 linkext :: $linktype
2666         \$(NOECHO) \$(NOOP)
2667 ";
2668 }
2669
2670 =item lsdir
2671
2672 Takes as arguments a directory name and a regular expression. Returns
2673 all entries in the directory that match the regular expression.
2674
2675 =cut
2676
2677 sub lsdir {
2678     my($self) = shift;
2679     my($dir, $regex) = @_;
2680     my(@ls);
2681     my $dh = new DirHandle;
2682     $dh->open($dir || ".") or return ();
2683     @ls = $dh->read;
2684     $dh->close;
2685     @ls = grep(/$regex/, @ls) if $regex;
2686     @ls;
2687 }
2688
2689 =item macro (o)
2690
2691 Simple subroutine to insert the macros defined by the macro attribute
2692 into the Makefile.
2693
2694 =cut
2695
2696 sub macro {
2697     my($self,%attribs) = @_;
2698     my(@m,$key,$val);
2699     while (($key,$val) = each %attribs){
2700         last unless defined $key;
2701         push @m, "$key = $val\n";
2702     }
2703     join "", @m;
2704 }
2705
2706 =item makeaperl (o)
2707
2708 Called by staticmake. Defines how to write the Makefile to produce a
2709 static new perl.
2710
2711 By default the Makefile produced includes all the static extensions in
2712 the perl library. (Purified versions of library files, e.g.,
2713 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2714
2715 =cut
2716
2717 sub makeaperl {
2718     my($self, %attribs) = @_;
2719     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2720         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2721     my(@m);
2722     push @m, "
2723 # --- MakeMaker makeaperl section ---
2724 MAP_TARGET    = $target
2725 FULLPERL      = $self->{FULLPERL}
2726 ";
2727     return join '', @m if $self->{PARENT};
2728
2729     my($dir) = join ":", @{$self->{DIR}};
2730
2731     unless ($self->{MAKEAPERL}) {
2732         push @m, q{
2733 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2734         $(MAKE) -f $(MAKE_APERL_FILE) $@
2735
2736 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2737         $(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2738         $(NOECHO) $(PERLRUNINST) \
2739                 Makefile.PL DIR=}, $dir, q{ \
2740                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2741                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2742
2743         foreach (@ARGV){
2744                 if( /\s/ ){
2745                         s/=(.*)/='$1'/;
2746                 }
2747                 push @m, " \\\n\t\t$_";
2748         }
2749 #       push @m, map( " \\\n\t\t$_", @ARGV );
2750         push @m, "\n";
2751
2752         return join '', @m;
2753     }
2754
2755
2756
2757     my($cccmd, $linkcmd, $lperl);
2758
2759
2760     $cccmd = $self->const_cccmd($libperl);
2761     $cccmd =~ s/^CCCMD\s*=\s*//;
2762     $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
2763     $cccmd .= " $Config{cccdlflags}"
2764         if ($Config{useshrplib} eq 'true');
2765     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2766
2767     # The front matter of the linkcommand...
2768     $linkcmd = join ' ', "\$(CC)",
2769             grep($_, @Config{qw(ldflags ccdlflags)});
2770     $linkcmd =~ s/\s+/ /g;
2771     $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2772
2773     # Which *.a files could we make use of...
2774     local(%static);
2775     require File::Find;
2776     File::Find::find(sub {
2777         return unless m/\Q$self->{LIB_EXT}\E$/;
2778         return if m/^libperl/;
2779         # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2780         return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2781
2782         if( exists $self->{INCLUDE_EXT} ){
2783                 my $found = 0;
2784                 my $incl;
2785                 my $xx;
2786
2787                 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2788                 $xx =~ s,/?$_,,;
2789                 $xx =~ s,/,::,g;
2790
2791                 # Throw away anything not explicitly marked for inclusion.
2792                 # DynaLoader is implied.
2793                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2794                         if( $xx eq $incl ){
2795                                 $found++;
2796                                 last;
2797                         }
2798                 }
2799                 return unless $found;
2800         }
2801         elsif( exists $self->{EXCLUDE_EXT} ){
2802                 my $excl;
2803                 my $xx;
2804
2805                 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2806                 $xx =~ s,/?$_,,;
2807                 $xx =~ s,/,::,g;
2808
2809                 # Throw away anything explicitly marked for exclusion
2810                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2811                         return if( $xx eq $excl );
2812                 }
2813         }
2814
2815         # don't include the installed version of this extension. I
2816         # leave this line here, although it is not necessary anymore:
2817         # I patched minimod.PL instead, so that Miniperl.pm won't
2818         # enclude duplicates
2819
2820         # Once the patch to minimod.PL is in the distribution, I can
2821         # drop it
2822         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2823         use Cwd 'cwd';
2824         $static{cwd() . "/" . $_}++;
2825     }, grep( -d $_, @{$searchdirs || []}) );
2826
2827     # We trust that what has been handed in as argument, will be buildable
2828     $static = [] unless $static;
2829     @static{@{$static}} = (1) x @{$static};
2830
2831     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2832     for (sort keys %static) {
2833         next unless /\Q$self->{LIB_EXT}\E\z/;
2834         $_ = dirname($_) . "/extralibs.ld";
2835         push @$extra, $_;
2836     }
2837
2838     grep(s/^(.*)/"-I$1"/, @{$perlinc || []});
2839
2840     $target ||= "perl";
2841     $tmp    ||= ".";
2842
2843 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2844 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2845 # extralibs.all are computed correctly
2846     push @m, "
2847 MAP_LINKCMD   = $linkcmd
2848 MAP_PERLINC   = @{$perlinc || []}
2849 MAP_STATIC    = ",
2850 join(" \\\n\t", reverse sort keys %static), "
2851
2852 MAP_PRELIBS   = $Config{perllibs} $Config{cryptlib}
2853 ";
2854
2855     if (defined $libperl) {
2856         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2857     }
2858     unless ($libperl && -f $lperl) { # Ilya's code...
2859         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2860         $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2861         $libperl ||= "libperl$self->{LIB_EXT}";
2862         $libperl   = "$dir/$libperl";
2863         $lperl   ||= "libperl$self->{LIB_EXT}";
2864         $lperl     = "$dir/$lperl";
2865
2866         if (! -f $libperl and ! -f $lperl) {
2867           # We did not find a static libperl. Maybe there is a shared one?
2868           if ($Is_SunOS) {
2869             $lperl  = $libperl = "$dir/$Config{libperl}";
2870             # SUNOS ld does not take the full path to a shared library
2871             $libperl = '' if $Is_SunOS4;
2872           }
2873         }
2874
2875         print STDOUT "Warning: $libperl not found
2876     If you're going to build a static perl binary, make sure perl is installed
2877     otherwise ignore this warning\n"
2878                 unless (-f $lperl || defined($self->{PERL_SRC}));
2879     }
2880
2881     # SUNOS ld does not take the full path to a shared library
2882     my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
2883
2884     push @m, "
2885 MAP_LIBPERL = $libperl
2886 LLIBPERL    = $llibperl
2887 ";
2888
2889     push @m, "
2890 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)\$(DIRFILESEP).exists ".join(" \\\n\t", @$extra).'
2891         $(NOECHO) $(RM_F)  $@
2892         $(NOECHO) $(TOUCH) $@
2893 ';
2894
2895     my $catfile;
2896     foreach $catfile (@$extra){
2897         push @m, "\tcat $catfile >> \$\@\n";
2898     }
2899
2900 push @m, "
2901 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2902         \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2903         \$(NOECHO) \$(ECHO) 'To install the new \"\$(MAP_TARGET)\" binary, call'
2904         \$(NOECHO) \$(ECHO) '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2905         \$(NOECHO) \$(ECHO) 'To remove the intermediate files say'
2906         \$(NOECHO) \$(ECHO) '    make -f $makefilename map_clean'
2907
2908 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2909 ";
2910     push @m, qq{\tcd $tmp && $cccmd "-I\$(PERL_INC)" perlmain.c\n};
2911
2912     push @m, qq{
2913 $tmp/perlmain.c: $makefilename}, q{
2914         $(NOECHO) $(ECHO) Writing $@
2915         $(NOECHO) $(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\
2916                 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2917
2918 };
2919     push @m, "\t", q{$(NOECHO) $(PERL) $(INSTALLSCRIPT)/fixpmain
2920 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2921
2922
2923     push @m, q{
2924 doc_inst_perl:
2925         $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod
2926         -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB)
2927         -$(NOECHO) $(DOC_INSTALL) \
2928                 "Perl binary" "$(MAP_TARGET)" \
2929                 MAP_STATIC "$(MAP_STATIC)" \
2930                 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2931                 MAP_LIBPERL "$(MAP_LIBPERL)" \
2932                 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{
2933
2934 };
2935
2936     push @m, q{
2937 inst_perl: pure_inst_perl doc_inst_perl
2938
2939 pure_inst_perl: $(MAP_TARGET)
2940         }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{
2941
2942 clean :: map_clean
2943
2944 map_clean :
2945         }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2946 };
2947
2948     join '', @m;
2949 }
2950
2951 =item makefile (o)
2952
2953 Defines how to rewrite the Makefile.
2954
2955 =cut
2956
2957 sub makefile {
2958     my($self) = shift;
2959     my @m;
2960     # We do not know what target was originally specified so we
2961     # must force a manual rerun to be sure. But as it should only
2962     # happen very rarely it is not a significant problem.
2963     push @m, '
2964 $(OBJECT) : $(FIRST_MAKEFILE)
2965 ' if $self->{OBJECT};
2966
2967     push @m, q{
2968 # We take a very conservative approach here, but it's worth it.
2969 # We move Makefile to Makefile.old here to avoid gnu make looping.
2970 $(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP)
2971         $(NOECHO) $(ECHO) "Makefile out-of-date with respect to $?"
2972         $(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..."
2973         $(NOECHO) $(RM_F) $(MAKEFILE_OLD)
2974         $(NOECHO) $(MV)   $(FIRST_MAKEFILE) $(MAKEFILE_OLD)
2975         -$(MAKE) -f $(MAKEFILE_OLD) clean $(DEV_NULL) || $(NOOP)
2976         $(PERLRUN) Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2977         $(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <=="
2978         $(NOECHO) $(ECHO) "==> Please rerun the make command.  <=="
2979         false
2980
2981 };
2982
2983     join "", @m;
2984 }
2985
2986
2987 =item maybe_command
2988
2989 Returns true, if the argument is likely to be a command.
2990
2991 =cut
2992
2993 sub maybe_command {
2994     my($self,$file) = @_;
2995     return $file if -x $file && ! -d $file;
2996     return;
2997 }
2998
2999
3000 =item needs_linking (o)
3001
3002 Does this module need linking? Looks into subdirectory objects (see
3003 also has_link_code())
3004
3005 =cut
3006
3007 sub needs_linking {
3008     my($self) = shift;
3009     my($child,$caller);
3010     $caller = (caller(0))[3];
3011     confess("needs_linking called too early") if 
3012       $caller =~ /^ExtUtils::MakeMaker::/;
3013     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
3014     if ($self->has_link_code or $self->{MAKEAPERL}){
3015         $self->{NEEDS_LINKING} = 1;
3016         return 1;
3017     }
3018     foreach $child (keys %{$self->{CHILDREN}}) {
3019         if ($self->{CHILDREN}->{$child}->needs_linking) {
3020             $self->{NEEDS_LINKING} = 1;
3021             return 1;
3022         }
3023     }
3024     return $self->{NEEDS_LINKING} = 0;
3025 }
3026
3027 =item nicetext
3028
3029 misnamed method (will have to be changed). The MM_Unix method just
3030 returns the argument without further processing.
3031
3032 On VMS used to insure that colons marking targets are preceded by
3033 space - most Unix Makes don't need this, but it's necessary under VMS
3034 to distinguish the target delimiter from a colon appearing as part of
3035 a filespec.
3036
3037 =cut
3038
3039 sub nicetext {
3040     my($self,$text) = @_;
3041     $text;
3042 }
3043
3044 =item parse_abstract
3045
3046 parse a file and return what you think is the ABSTRACT
3047
3048 =cut
3049
3050 sub parse_abstract {
3051     my($self,$parsefile) = @_;
3052     my $result;
3053     local *FH;
3054     local $/ = "\n";
3055     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
3056     my $inpod = 0;
3057     my $package = $self->{DISTNAME};
3058     $package =~ s/-/::/g;
3059     while (<FH>) {
3060         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
3061         next if !$inpod;
3062         chop;
3063         next unless /^($package\s-\s)(.*)/;
3064         $result = $2;
3065         last;
3066     }
3067     close FH;
3068     return $result;
3069 }
3070
3071 =item parse_version
3072
3073 parse a file and return what you think is $VERSION in this file set to.
3074 It will return the string "undef" if it can't figure out what $VERSION
3075 is. $VERSION should be for all to see, so our $VERSION or plain $VERSION
3076 are okay, but my $VERSION is not.
3077
3078 =cut
3079
3080 sub parse_version {
3081     my($self,$parsefile) = @_;
3082     my $result;
3083     local *FH;
3084     local $/ = "\n";
3085     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
3086     my $inpod = 0;
3087     while (<FH>) {
3088         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
3089         next if $inpod || /^\s*#/;
3090         chop;
3091         next unless /(?<!\\)([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
3092         my $eval = qq{
3093             package ExtUtils::MakeMaker::_version;
3094             no strict;
3095
3096             local $1$2;
3097             \$$2=undef; do {
3098                 $_
3099             }; \$$2
3100         };
3101         local $^W = 0;
3102         $result = eval($eval);
3103         warn "Could not eval '$eval' in $parsefile: $@" if $@;
3104         last;
3105     }
3106     close FH;
3107
3108     $result = "undef" unless defined $result;
3109     return $result;
3110 }
3111
3112
3113 =item pasthru (o)
3114
3115 Defines the string that is passed to recursive make calls in
3116 subdirectories.
3117
3118 =cut
3119
3120 sub pasthru {
3121     my($self) = shift;
3122     my(@m,$key);
3123
3124     my(@pasthru);
3125     my($sep) = $Is_VMS ? ',' : '';
3126     $sep .= "\\\n\t";
3127
3128     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
3129         push @pasthru, "$key=\"\$($key)\"";
3130     }
3131
3132     foreach $key (qw(DEFINE INC)) {
3133         push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
3134     }
3135
3136     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
3137     join "", @m;
3138 }
3139
3140 =item perl_script
3141
3142 Takes one argument, a file name, and returns the file name, if the
3143 argument is likely to be a perl script. On MM_Unix this is true for
3144 any ordinary, readable file.
3145
3146 =cut
3147
3148 sub perl_script {
3149     my($self,$file) = @_;
3150     return $file if -r $file && -f _;
3151     return;
3152 }
3153
3154 =item perldepend (o)
3155
3156 Defines the dependency from all *.h files that come with the perl
3157 distribution.
3158
3159 =cut
3160
3161 sub perldepend {
3162     my($self) = shift;
3163     my(@m);
3164     push @m, q{
3165 # Check for unpropogated config.sh changes. Should never happen.
3166 # We do NOT just update config.h because that is not sufficient.
3167 # An out of date config.h is not fatal but complains loudly!
3168 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
3169         -$(NOECHO) $(ECHO) "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
3170
3171 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
3172         $(NOECHO) $(ECHO) "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
3173         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
3174 } if $self->{PERL_SRC};
3175
3176     return join "", @m unless $self->needs_linking;
3177
3178     push @m, q{
3179 PERL_HDRS = \
3180         $(PERL_INC)/EXTERN.h            \
3181         $(PERL_INC)/INTERN.h            \
3182         $(PERL_INC)/XSUB.h              \
3183         $(PERL_INC)/av.h                \
3184         $(PERL_INC)/cc_runtime.h        \
3185         $(PERL_INC)/config.h            \
3186         $(PERL_INC)/cop.h               \
3187         $(PERL_INC)/cv.h                \
3188         $(PERL_INC)/dosish.h            \
3189         $(PERL_INC)/embed.h             \
3190         $(PERL_INC)/embedvar.h          \
3191         $(PERL_INC)/fakethr.h           \
3192         $(PERL_INC)/form.h              \
3193         $(PERL_INC)/gv.h                \
3194         $(PERL_INC)/handy.h             \
3195         $(PERL_INC)/hv.h                \
3196         $(PERL_INC)/intrpvar.h          \
3197         $(PERL_INC)/iperlsys.h          \
3198         $(PERL_INC)/keywords.h          \
3199         $(PERL_INC)/mg.h                \
3200         $(PERL_INC)/nostdio.h           \
3201         $(PERL_INC)/op.h                \
3202         $(PERL_INC)/opcode.h            \
3203         $(PERL_INC)/patchlevel.h        \
3204         $(PERL_INC)/perl.h              \
3205         $(PERL_INC)/perlio.h            \
3206         $(PERL_INC)/perlsdio.h          \
3207         $(PERL_INC)/perlsfio.h          \
3208         $(PERL_INC)/perlvars.h          \
3209         $(PERL_INC)/perly.h             \
3210         $(PERL_INC)/pp.h                \
3211         $(PERL_INC)/pp_proto.h          \
3212         $(PERL_INC)/proto.h             \
3213         $(PERL_INC)/regcomp.h           \
3214         $(PERL_INC)/regexp.h            \
3215         $(PERL_INC)/regnodes.h          \
3216         $(PERL_INC)/scope.h             \
3217         $(PERL_INC)/sv.h                \
3218         $(PERL_INC)/thrdvar.h           \
3219         $(PERL_INC)/thread.h            \
3220         $(PERL_INC)/unixish.h           \
3221         $(PERL_INC)/util.h
3222
3223 $(OBJECT) : $(PERL_HDRS)
3224 } if $self->{OBJECT};
3225
3226     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
3227
3228     join "\n", @m;
3229 }
3230
3231
3232 =item perm_rw (o)
3233
3234 Returns the attribute C<PERM_RW> or the string C<644>.
3235 Used as the string that is passed
3236 to the C<chmod> command to set the permissions for read/writeable files.
3237 MakeMaker chooses C<644> because it has turned out in the past that
3238 relying on the umask provokes hard-to-track bug reports.
3239 When the return value is used by the perl function C<chmod>, it is
3240 interpreted as an octal value.
3241
3242 =cut
3243
3244 sub perm_rw {
3245     return shift->{PERM_RW};
3246 }
3247
3248 =item perm_rwx (o)
3249
3250 Returns the attribute C<PERM_RWX> or the string C<755>,
3251 i.e. the string that is passed
3252 to the C<chmod> command to set the permissions for executable files.
3253 See also perl_rw.
3254
3255 =cut
3256
3257 sub perm_rwx {
3258     return shift->{PERM_RWX};
3259 }
3260
3261 =item pm_to_blib
3262
3263 Defines target that copies all files in the hash PM to their
3264 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3265
3266 =cut
3267
3268 sub pm_to_blib {
3269     my $self = shift;
3270     my($autodir) = $self->catdir('$(INST_LIB)','auto');
3271     my $r = q{
3272 pm_to_blib: $(TO_INST_PM)
3273 };
3274
3275     my $pm_to_blib = $self->oneliner(<<CODE, ['-MExtUtils::Install']);
3276 pm_to_blib({\@ARGV}, '$autodir', '\$(PM_FILTER)')
3277 CODE
3278
3279     my @cmds = $self->split_command($pm_to_blib, %{$self->{PM}});
3280
3281     $r .= join '', map { "\t\$(NOECHO) $_\n" } @cmds;
3282     $r .= q{    $(NOECHO) $(TOUCH) $@};
3283
3284     return $r;
3285 }
3286
3287 =item post_constants (o)
3288
3289 Returns an empty string per default. Dedicated to overrides from
3290 within Makefile.PL after all constants have been defined.
3291
3292 =cut
3293
3294 sub post_constants{
3295     "";
3296 }
3297
3298 =item post_initialize (o)
3299
3300 Returns an empty string per default. Used in Makefile.PLs to add some
3301 chunk of text to the Makefile after the object is initialized.
3302
3303 =cut
3304
3305 sub post_initialize {
3306     "";
3307 }
3308
3309 =item postamble (o)
3310
3311 Returns an empty string. Can be used in Makefile.PLs to write some
3312 text to the Makefile at the end.
3313
3314 =cut
3315
3316 sub postamble {
3317     "";
3318 }
3319
3320 =item ppd
3321
3322 Defines target that creates a PPD (Perl Package Description) file
3323 for a binary distribution.
3324
3325 =cut
3326
3327 sub ppd {
3328     my($self) = @_;
3329
3330     if ($self->{ABSTRACT_FROM}){
3331         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
3332             carp "WARNING: Setting ABSTRACT via file ".
3333                  "'$self->{ABSTRACT_FROM}' failed\n";
3334     }
3335
3336     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3];
3337
3338     my $abstract = $self->{ABSTRACT} || '';
3339     $abstract =~ s/\n/\\n/sg;
3340     $abstract =~ s/</&lt;/g;
3341     $abstract =~ s/>/&gt;/g;
3342
3343     my $author = $self->{AUTHOR} || '';
3344     $author =~ s/</&lt;/g;
3345     $author =~ s/>/&gt;/g;
3346
3347     my $ppd_xml = sprintf <<'PPD_HTML', $pack_ver, $abstract, $author;
3348 <SOFTPKG NAME="$(DISTNAME)" VERSION="%s">
3349     <TITLE>$(DISTNAME)</TITLE>
3350     <ABSTRACT>%s</ABSTRACT>
3351     <AUTHOR>%s</AUTHOR>
3352 PPD_HTML
3353
3354     $ppd_xml .= "    <IMPLEMENTATION>\n";
3355     foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
3356         my $pre_req = $prereq;
3357         $pre_req =~ s/::/-/g;
3358         my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}), 
3359                                   (0) x 4) [0 .. 3];
3360         $ppd_xml .= sprintf <<'PPD_OUT', $pre_req, $dep_ver;
3361         <DEPENDENCY NAME="%s" VERSION="%s" />
3362 PPD_OUT
3363
3364     }
3365
3366     $ppd_xml .= sprintf <<'PPD_OUT', $Config{archname};
3367         <OS NAME="$(OSNAME)" />
3368         <ARCHITECTURE NAME="%s" />
3369 PPD_OUT
3370
3371     if ($self->{PPM_INSTALL_SCRIPT}) {
3372         if ($self->{PPM_INSTALL_EXEC}) {
3373             $ppd_xml .= sprintf qq{        <INSTALL EXEC="%s">%s</INSTALL>\n},
3374                   $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
3375         }
3376         else {
3377             $ppd_xml .= sprintf qq{        <INSTALL>%s</INSTALL>\n}, 
3378                   $self->{PPM_INSTALL_SCRIPT};
3379         }
3380     }
3381
3382     my ($bin_location) = $self->{BINARY_LOCATION} || '';
3383     $bin_location =~ s/\\/\\\\/g;
3384
3385     $ppd_xml .= sprintf <<'PPD_XML', $bin_location;
3386         <CODEBASE HREF="%s" />
3387     </IMPLEMENTATION>
3388 </SOFTPKG>
3389 PPD_XML
3390
3391     my @ppd_cmds = $self->echo($ppd_xml, '$(DISTNAME).ppd');
3392
3393     return sprintf <<'PPD_OUT', join "\n\t", @ppd_cmds;
3394 # Creates a PPD (Perl Package Description) for a binary distribution.
3395 ppd:
3396         %s
3397 PPD_OUT
3398
3399 }
3400
3401 =item prefixify
3402
3403   $MM->prefixify($var, $prefix, $new_prefix, $default);
3404
3405 Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to
3406 replace it's $prefix with a $new_prefix.  
3407
3408 Should the $prefix fail to match I<AND> a PREFIX was given as an
3409 argument to WriteMakefile() it will set it to the $new_prefix +
3410 $default.  This is for systems whose file layouts don't neatly fit into
3411 our ideas of prefixes.
3412
3413 This is for heuristics which attempt to create directory structures
3414 that mirror those of the installed perl.
3415
3416 For example:
3417
3418     $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');
3419
3420 this will attempt to remove '/usr' from the front of the
3421 $MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
3422 if necessary) and replace it with '/home/foo'.  If this fails it will
3423 simply use '/home/foo/man/man1'.
3424
3425 =cut
3426
3427 sub prefixify {
3428     my($self,$var,$sprefix,$rprefix,$default) = @_;
3429
3430     my $path = $self->{uc $var} || 
3431                $Config_Override{lc $var} || $Config{lc $var} || '';
3432
3433     $rprefix .= '/' if $sprefix =~ m|/$|;
3434
3435     print STDERR "  prefixify $var => $path\n" if $Verbose >= 2;
3436     print STDERR "    from $sprefix to $rprefix\n" if $Verbose >= 2;
3437
3438     if( $path !~ s{^\Q$sprefix\E\b}{$rprefix}s && $self->{ARGS}{PREFIX} ) {
3439
3440         print STDERR "    cannot prefix, using default.\n" if $Verbose >= 2;
3441         print STDERR "    no default!\n" if !$default && $Verbose >= 2;
3442
3443         $path = $self->catdir($rprefix, $default) if $default;
3444     }
3445
3446     print "    now $path\n" if $Verbose >= 2;
3447     return $self->{uc $var} = $path;
3448 }
3449
3450
3451 =item processPL (o)
3452
3453 Defines targets to run *.PL files.
3454
3455 =cut
3456
3457 sub processPL {
3458     my($self) = shift;
3459     return "" unless $self->{PL_FILES};
3460     my(@m, $plfile);
3461     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3462         my $list = ref($self->{PL_FILES}->{$plfile})
3463                 ? $self->{PL_FILES}->{$plfile}
3464                 : [$self->{PL_FILES}->{$plfile}];
3465         my $target;
3466         foreach $target (@$list) {
3467         push @m, "
3468 all :: $target
3469         \$(NOECHO) \$(NOOP)
3470
3471 $target :: $plfile
3472         \$(PERLRUNINST) $plfile $target
3473 ";
3474         }
3475     }
3476     join "", @m;
3477 }
3478
3479 =item quote_paren
3480
3481 Backslashes parentheses C<()> in command line arguments.
3482 Doesn't handle recursive Makefile C<$(...)> constructs,
3483 but handles simple ones.
3484
3485 =cut
3486
3487 sub quote_paren {
3488     my $arg = shift;
3489     $arg =~ s/\$\((.+?)\)/\$\\\\($1\\\\)/g;     # protect $(...)
3490     $arg =~ s/(?<!\\)([()])/\\$1/g;             # quote unprotected
3491     $arg =~ s/\$\\\\\((.+?)\\\\\)/\$($1)/g;     # unprotect $(...)
3492     return $arg;
3493 }
3494
3495 =item realclean (o)
3496
3497 Defines the realclean target.
3498
3499 =cut
3500
3501 sub realclean {
3502     my($self, %attribs) = @_;
3503     my(@m);
3504
3505     push(@m,'
3506 # Delete temporary files (via clean) and also delete installed files
3507 realclean purge ::  clean realclean_subdirs
3508         $(RM_RF) $(INST_AUTODIR) $(INST_ARCHAUTODIR)
3509         $(RM_RF) $(DISTVNAME)
3510 ');
3511
3512     if( $self->has_link_code ){
3513         push(@m, "      \$(RM_F) \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3514         push(@m, "      \$(RM_F) \$(INST_STATIC)\n");
3515     }
3516
3517     my @files = values %{$self->{PM}};
3518     push @files, $attribs{FILES} if $attribs{FILES};
3519     push @files, '$(FIRST_MAKEFILE)', '$(MAKEFILE_OLD)';
3520
3521     # Occasionally files are repeated several times from different sources
3522     { my(%f) = map { ($_,1) } @files; @files = keys %f; }
3523
3524     # Issue a several little RM_F commands rather than risk creating a
3525     # very long command line (useful for extensions such as Encode
3526     # that have many files).
3527     my $line = "";
3528     foreach my $file (@files) {
3529         if (length($line) + length($file) > 200) {
3530             push @m, "\t\$(RM_F) $line\n";
3531             $line = $file;
3532         }
3533         else {
3534             $line .= " $file"; 
3535         }
3536     }
3537     push @m, "\t\$(RM_F) $line\n" if $line;
3538     push(@m, "\t$attribs{POSTOP}\n")      if $attribs{POSTOP};
3539
3540     join("", @m);
3541 }
3542
3543
3544 =item realclean_subdirs_target
3545
3546   my $make_frag = $MM->realclean_subdirs_target;
3547
3548 Returns the realclean_subdirs target.  This is used by the realclean
3549 target to call realclean on any subdirectories which contain Makefiles.
3550
3551 =cut
3552
3553 sub realclean_subdirs_target {
3554     my $self = shift;
3555
3556     return <<'NOOP_FRAG' unless @{$self->{DIR}};
3557 realclean_subdirs :
3558         $(NOECHO) $(NOOP)
3559 NOOP_FRAG
3560
3561     my $rclean = "realclean_subdirs :\n";
3562
3563     foreach my $dir (@{$self->{DIR}}){
3564         $rclean .= sprintf <<'RCLEAN', $dir, $dir;
3565         -cd %s && $(TEST_F) $(MAKEFILE_OLD) && $(MAKE) -f $(MAKEFILE_OLD) realclean
3566         -cd %s && $(TEST_F) $(FIRST_MAKEFILE) && $(MAKE) realclean
3567 RCLEAN
3568
3569     }
3570
3571     return $rclean;
3572 }
3573
3574
3575 =item replace_manpage_separator
3576
3577   my $man_name = $MM->replace_manpage_separator($file_path);
3578
3579 Takes the name of a package, which may be a nested package, in the
3580 form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
3581 safe for a man page file name.  Returns the replacement.
3582
3583 =cut
3584
3585 sub replace_manpage_separator {
3586     my($self,$man) = @_;
3587
3588     $man =~ s,/+,::,g;
3589     return $man;
3590 }
3591
3592
3593 =item oneliner (o)
3594
3595 =cut
3596
3597 sub oneliner {
3598     my($self, $cmd, $switches) = @_;
3599     $switches = [] unless defined $switches;
3600
3601     # Strip leading and trailing newlines
3602     $cmd =~ s{^\n+}{};
3603     $cmd =~ s{\n+$}{};
3604
3605     my @cmds = split /\n/, $cmd;
3606     $cmd = join " \n\t-e ", map $self->quote_literal($_), @cmds;
3607     $cmd = $self->escape_newlines($cmd);
3608
3609     $switches = join ' ', @$switches;
3610
3611     return qq{\$(PERLRUN) $switches -e $cmd};   
3612 }
3613
3614
3615 =item quote_literal
3616
3617 =cut
3618
3619 sub quote_literal {
3620     my($self, $text) = @_;
3621
3622     # I think all we have to quote is single quotes and I think
3623     # this is a safe way to do it.
3624     $text =~ s{'}{'\\''}g;
3625
3626     return "'$text'";
3627 }
3628
3629
3630 =item escape_newlines
3631
3632 =cut
3633
3634 sub escape_newlines {
3635     my($self, $text) = @_;
3636
3637     $text =~ s{\n}{\\\n}g;
3638
3639     return $text;
3640 }
3641
3642
3643 =item max_exec_len
3644
3645 Using POSIX::ARG_MAX.  Otherwise falling back to 4096.
3646
3647 =cut
3648
3649 sub max_exec_len {
3650     my $self = shift;
3651
3652     if (!defined $self->{_MAX_EXEC_LEN}) {
3653         if (my $arg_max = eval { require POSIX;  &POSIX::ARG_MAX }) {
3654             $self->{_MAX_EXEC_LEN} = $arg_max;
3655         }
3656         else {      # POSIX minimum exec size
3657             $self->{_MAX_EXEC_LEN} = 4096;
3658         }
3659     }
3660
3661     return $self->{_MAX_EXEC_LEN};
3662 }
3663
3664
3665 =item static (o)
3666
3667 Defines the static target.
3668
3669 =cut
3670
3671 sub static {
3672 # --- Static Loading Sections ---
3673
3674     my($self) = shift;
3675     '
3676 ## $(INST_PM) has been moved to the all: target.
3677 ## It remains here for awhile to allow for old usage: "make static"
3678 static :: $(FIRST_MAKEFILE) $(INST_STATIC)
3679         $(NOECHO) $(NOOP)
3680 ';
3681 }
3682
3683 =item static_lib (o)
3684
3685 Defines how to produce the *.a (or equivalent) files.
3686
3687 =cut
3688
3689 sub static_lib {
3690     my($self) = @_;
3691     return '' unless $self->has_link_code;
3692
3693     my(@m);
3694     push(@m, <<'END');
3695
3696 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DIRFILESEP).exists
3697         $(RM_RF) $@
3698 END
3699
3700     # If this extension has its own library (eg SDBM_File)
3701     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3702     push(@m, <<'MAKE_FRAG') if $self->{MYEXTLIB};
3703         $(CP) $(MYEXTLIB) $@
3704 MAKE_FRAG
3705
3706     my $ar; 
3707     if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3708         # Prefer the absolute pathed ar if available so that PATH
3709         # doesn't confuse us.  Perl itself is built with the full_ar.  
3710         $ar = 'FULL_AR';
3711     } else {
3712         $ar = 'AR';
3713     }
3714     push @m, sprintf <<'MAKE_FRAG', $ar;
3715         $(%s) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@
3716         $(CHMOD) $(PERM_RWX) $@
3717         $(NOECHO) $(ECHO) "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3718 MAKE_FRAG
3719
3720     # Old mechanism - still available:
3721     push @m, <<'MAKE_FRAG' if $self->{PERL_SRC} && $self->{EXTRALIBS};
3722         $(NOECHO) $(ECHO) "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3723 MAKE_FRAG
3724
3725     push @m, "\n", $self->dir_target('$(INST_ARCHAUTODIR)');
3726     join('', @m);
3727 }
3728
3729 =item staticmake (o)
3730
3731 Calls makeaperl.
3732
3733 =cut
3734
3735 sub staticmake {
3736     my($self, %attribs) = @_;
3737     my(@static);
3738
3739     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3740
3741     # And as it's not yet built, we add the current extension
3742     # but only if it has some C code (or XS code, which implies C code)
3743     if (@{$self->{C}}) {
3744         @static = $self->catfile($self->{INST_ARCHLIB},
3745                                  "auto",
3746                                  $self->{FULLEXT},
3747                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3748                                 );
3749     }
3750
3751     # Either we determine now, which libraries we will produce in the
3752     # subdirectories or we do it at runtime of the make.
3753
3754     # We could ask all subdir objects, but I cannot imagine, why it
3755     # would be necessary.
3756
3757     # Instead we determine all libraries for the new perl at
3758     # runtime.
3759     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3760
3761     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3762                      DIRS       => \@searchdirs,
3763                      STAT       => \@static,
3764                      INCL       => \@perlinc,
3765                      TARGET     => $self->{MAP_TARGET},
3766                      TMP        => "",
3767                      LIBPERL    => $self->{LIBPERL_A}
3768                     );
3769 }
3770
3771 =item subdir_x (o)
3772
3773 Helper subroutine for subdirs
3774
3775 =cut
3776
3777 sub subdir_x {
3778     my($self, $subdir) = @_;
3779     return sprintf <<'EOT', $subdir;
3780
3781 subdirs ::
3782         $(NOECHO)cd %s && $(MAKE) -f $(FIRST_MAKEFILE) all $(PASTHRU)
3783 EOT
3784 }
3785
3786 =item subdirs (o)
3787
3788 Defines targets to process subdirectories.
3789
3790 =cut
3791
3792 sub subdirs {
3793 # --- Sub-directory Sections ---
3794     my($self) = shift;
3795     my(@m,$dir);
3796     # This method provides a mechanism to automatically deal with
3797     # subdirectories containing further Makefile.PL scripts.
3798     # It calls the subdir_x() method for each subdirectory.
3799     foreach $dir (@{$self->{DIR}}){
3800         push(@m, $self->subdir_x($dir));
3801 ####    print "Including $dir subdirectory\n";
3802     }
3803     if (@m){
3804         unshift(@m, "
3805 # The default clean, realclean and test targets in this Makefile
3806 # have automatically been given entries for each subdir.
3807
3808 ");
3809     } else {
3810         push(@m, "\n# none")
3811     }
3812     join('',@m);
3813 }
3814
3815 =item test (o)
3816
3817 Defines the test targets.
3818
3819 =cut
3820
3821 sub test {
3822 # --- Test and Installation Sections ---
3823
3824     my($self, %attribs) = @_;
3825     my $tests = $attribs{TESTS} || '';
3826     if (!$tests && -d 't') {
3827         $tests = $self->find_tests;
3828     }
3829     # note: 'test.pl' name is also hardcoded in init_dirscan()
3830     my(@m);
3831     push(@m,"
3832 TEST_VERBOSE=0
3833 TEST_TYPE=test_\$(LINKTYPE)
3834 TEST_FILE = test.pl
3835 TEST_FILES = $tests
3836 TESTDB_SW = -d
3837
3838 testdb :: testdb_\$(LINKTYPE)
3839
3840 test :: \$(TEST_TYPE)
3841 ");
3842
3843     if ($Is_Win95) {
3844         push(@m, map(qq{\t\$(NOECHO) \$(PERLRUN) -e "exit unless -f shift; chdir '$_'; system q{\$(MAKE) test \$(PASTHRU)}" \$(FIRST_MAKEFILE)\n}, @{$self->{DIR}}));
3845     }
3846     else {
3847         push(@m, map("\t\$(NOECHO) cd $_ && \$(TEST_F) \$(FIRST_MAKEFILE) && \$(MAKE) test \$(PASTHRU)\n", @{$self->{DIR}}));
3848     }
3849
3850     push(@m, "\t\$(NOECHO) \$(ECHO) 'No tests defined for \$(NAME) extension.'\n")
3851         unless $tests or -f "test.pl" or @{$self->{DIR}};
3852     push(@m, "\n");
3853
3854     push(@m, "test_dynamic :: pure_all\n");
3855     push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)')) 
3856       if $tests;
3857     push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)')) 
3858       if -f "test.pl";
3859     push(@m, "\n");
3860
3861     push(@m, "testdb_dynamic :: pure_all\n");
3862     push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)', 
3863                                     '$(TEST_FILE)'));
3864     push(@m, "\n");
3865
3866     # Occasionally we may face this degenerate target:
3867     push @m, "test_ : test_dynamic\n\n";
3868
3869     if ($self->needs_linking()) {
3870         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3871         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3872         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3873         push(@m, "\n");
3874         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3875         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3876         push(@m, "\n");
3877     } else {
3878         push @m, "test_static :: test_dynamic\n";
3879         push @m, "testdb_static :: testdb_dynamic\n";
3880     }
3881     join("", @m);
3882 }
3883
3884 =item test_via_harness (override)
3885
3886 For some reason which I forget, Unix machines like to have
3887 PERL_DL_NONLAZY set for tests.
3888
3889 =cut
3890
3891 sub test_via_harness {
3892     my($self, $perl, $tests) = @_;
3893     return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
3894 }
3895
3896 =item test_via_script (override)
3897
3898 Again, the PERL_DL_NONLAZY thing.
3899
3900 =cut
3901
3902 sub test_via_script {
3903     my($self, $perl, $script) = @_;
3904     return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
3905 }
3906
3907
3908 =item tools_other (o)
3909
3910     my $make_frag = $MM->tools_other;
3911
3912 Returns a make fragment containing definitions for:
3913
3914 SHELL, CHMOD, CP, MV, NOOP, NOECHO, RM_F, RM_RF, TEST_F, TOUCH,
3915 DEV_NULL, UMASK_NULL, MKPATH, EQUALIZE_TIMESTAMP,
3916 WARN_IF_OLD_PACKLIST, UNINST, VERBINST, MOD_INSTALL, DOC_INSTALL and
3917 UNINSTALL
3918
3919 init_others() initializes all these values.
3920
3921 =cut
3922
3923 sub tools_other {
3924     my($self) = shift;
3925     my @m;
3926
3927     for my $tool (qw{ SHELL CHMOD CP MV NOOP NOECHO RM_F RM_RF TEST_F TOUCH 
3928                       UMASK_NULL DEV_NULL MKPATH EQUALIZE_TIMESTAMP 
3929                       ECHO ECHO_N
3930                       UNINST VERBINST
3931                       MOD_INSTALL DOC_INSTALL UNINSTALL
3932                       WARN_IF_OLD_PACKLIST
3933                     } ) 
3934     {
3935         next unless defined $self->{$tool};
3936         push @m, "$tool = $self->{$tool}\n";
3937     }
3938
3939     return join "", @m;
3940 }
3941
3942 =item tool_xsubpp (o)
3943
3944 Determines typemaps, xsubpp version, prototype behaviour.
3945
3946 =cut
3947
3948 sub tool_xsubpp {
3949     my($self) = shift;
3950     return "" unless $self->needs_linking;
3951
3952     my $xsdir;
3953     foreach my $dir (@INC) {
3954         $xsdir = $self->catdir($dir, 'ExtUtils');
3955         if( -r $self->catfile($xsdir, "xsubpp") ) {
3956             last;
3957         }
3958     }
3959
3960     my $tmdir   = File::Spec->catdir($self->{PERL_LIB},"ExtUtils");
3961     my(@tmdeps) = $self->catfile($tmdir,'typemap');
3962     if( $self->{TYPEMAPS} ){
3963         my $typemap;
3964         foreach $typemap (@{$self->{TYPEMAPS}}){
3965                 if( ! -f  $typemap ){
3966                         warn "Typemap $typemap not found.\n";
3967                 }
3968                 else{
3969                         push(@tmdeps,  $typemap);
3970                 }
3971         }
3972     }
3973     push(@tmdeps, "typemap") if -f "typemap";
3974     my(@tmargs) = map("-typemap $_", @tmdeps);
3975     if( exists $self->{XSOPT} ){
3976         unshift( @tmargs, $self->{XSOPT} );
3977     }
3978
3979
3980     $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3981
3982     return qq{
3983 XSUBPPDIR = $xsdir
3984 XSUBPP = \$(XSUBPPDIR)/xsubpp
3985 XSPROTOARG = $self->{XSPROTOARG}
3986 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3987 XSUBPPARGS = @tmargs
3988 XSUBPP_EXTRA_ARGS = 
3989 };
3990 };
3991
3992
3993 =item all_target
3994
3995 Build man pages, too
3996
3997 =cut
3998
3999 sub all_target {
4000     my $self = shift;
4001
4002     return <<'MAKE_EXT';
4003 all :: pure_all manifypods
4004         $(NOECHO) $(NOOP)
4005 MAKE_EXT
4006 }
4007
4008 =item top_targets (o)
4009
4010 Defines the targets all, subdirs, config, and O_FILES
4011
4012 =cut
4013
4014 sub top_targets {
4015 # --- Target Sections ---
4016
4017     my($self) = shift;
4018     my(@m);
4019
4020     push @m, $self->all_target, "\n" unless $self->{SKIPHASH}{'all'};
4021     
4022     push @m, '
4023 pure_all :: config pm_to_blib subdirs linkext
4024         $(NOECHO) $(NOOP)
4025
4026 subdirs :: $(MYEXTLIB)
4027         $(NOECHO) $(NOOP)
4028
4029 config :: $(FIRST_MAKEFILE) $(INST_LIBDIR)$(DIRFILESEP).exists
4030         $(NOECHO) $(NOOP)
4031
4032 config :: $(INST_ARCHAUTODIR)$(DIRFILESEP).exists
4033         $(NOECHO) $(NOOP)
4034
4035 config :: $(INST_AUTODIR)$(DIRFILESEP).exists
4036         $(NOECHO) $(NOOP)
4037 ';
4038
4039     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
4040
4041     if (%{$self->{MAN1PODS}}) {
4042         push @m, q[
4043 config :: $(INST_MAN1DIR)$(DIRFILESEP).exists
4044         $(NOECHO) $(NOOP)
4045
4046 ];
4047         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
4048     }
4049     if (%{$self->{MAN3PODS}}) {
4050         push @m, q[
4051 config :: $(INST_MAN3DIR)$(DIRFILESEP).exists
4052         $(NOECHO) $(NOOP)
4053
4054 ];
4055         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
4056     }
4057
4058     push @m, '
4059 $(O_FILES): $(H_FILES)
4060 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
4061
4062     push @m, q{
4063 help:
4064         perldoc ExtUtils::MakeMaker
4065 };
4066
4067     join('',@m);
4068 }
4069
4070 =item writedoc
4071
4072 Obsolete, deprecated method. Not used since Version 5.21.
4073
4074 =cut
4075
4076 sub writedoc {
4077 # --- perllocal.pod section ---
4078     my($self,$what,$name,@attribs)=@_;
4079     my $time = localtime;
4080     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
4081     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
4082     print "\n\n=back\n\n";
4083 }
4084
4085 =item xs_c (o)
4086
4087 Defines the suffix rules to compile XS files to C.
4088
4089 =cut
4090
4091 sub xs_c {
4092     my($self) = shift;
4093     return '' unless $self->needs_linking();
4094     '
4095 .xs.c:
4096         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
4097 ';
4098 }
4099
4100 =item xs_cpp (o)
4101
4102 Defines the suffix rules to compile XS files to C++.
4103
4104 =cut
4105
4106 sub xs_cpp {
4107     my($self) = shift;
4108     return '' unless $self->needs_linking();
4109     '
4110 .xs.cpp:
4111         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
4112 ';
4113 }
4114
4115 =item xs_o (o)
4116
4117 Defines suffix rules to go from XS to object files directly. This is
4118 only intended for broken make implementations.
4119
4120 =cut
4121
4122 sub xs_o {      # many makes are too dumb to use xs_c then c_o
4123     my($self) = shift;
4124     return '' unless $self->needs_linking();
4125     '
4126 .xs$(OBJ_EXT):
4127         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
4128         $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
4129 ';
4130 }
4131
4132
4133 1;
4134
4135 =back
4136
4137 =head1 SEE ALSO
4138
4139 L<ExtUtils::MakeMaker>
4140
4141 =cut
4142
4143 __END__