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