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