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