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