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