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