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