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