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