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