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