Updated to MakeMaker-5.16
[perl.git] / lib / ExtUtils / MakeMaker.pm
1 package ExtUtils::MakeMaker::TieAtt;
2 # this package will go away again, when we don't have modules around
3 # anymore that import %att It ties an empty %att and records in which
4 # object this %att was tied. FETCH and STORE return/store-to the
5 # appropriate value from %$self
6
7 # the warndirectuse method warns if somebody calls MM->something. It
8 # has nothing to do with the tie'd %att.
9
10 $Enough_limit = 5;
11
12 sub TIEHASH {
13     bless { SECRETHASH => $_[1]};
14 }
15
16 sub FETCH {
17     print "Warning (non-fatal): Importing of %att is deprecated [$_[1]]
18         use \$self instead\n" unless ++$Enough>$Enough_limit;
19     print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
20     $_[0]->{SECRETHASH}->{$_[1]};
21 }
22
23 sub STORE {
24     print "Warning (non-fatal): Importing of %att is deprecated [$_[1]][$_[2]]
25         use \$self instead\n" unless ++$Enough>$Enough_limit;
26     print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
27     $_[0]->{SECRETHASH}->{$_[1]} = $_[2];
28 }
29
30 sub FIRSTKEY {
31     print "Warning (non-fatal): Importing of %att is deprecated [FIRSTKEY]
32         use \$self instead\n" unless ++$Enough>$Enough_limit;
33     print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n" if $Enough==$Enough_limit;
34     each %{$_[0]->{SECRETHASH}};
35 }
36
37 sub NEXTKEY {
38     each %{$_[0]->{SECRETHASH}};
39 }
40
41 sub DESTROY {
42 }
43
44 sub warndirectuse {
45     my($caller) = @_;
46     return if $Enough>$Enough_limit;
47     print STDOUT "Warning (non-fatal): Direct use of class methods deprecated; use\n";
48     my($method) = $caller =~ /.*:(\w+)$/;
49     print STDOUT
50 '               my $self = shift;
51                 $self->MM::', $method, "();
52         instead\n";
53     print "Further ExtUtils::MakeMaker::TieAtt warnings suppressed\n"
54         if ++$Enough==$Enough_limit;
55 }
56
57 package ExtUtils::MakeMaker;
58
59 # Last edited $Date: 1996/01/05 20:40:47 $ by Andreas Koenig
60 # $Id: MakeMaker.pm,v 1.135 1996/01/05 20:40:47 k Exp $
61
62 $Version = $VERSION = "5.16";
63
64 $ExtUtils::MakeMaker::Version_OK = 4.13;        # Makefiles older than $Version_OK will die
65                         # (Will be checked from MakeMaker version 4.13 onwards)
66
67 use Config;
68 use Carp;
69 use Cwd;
70 require Exporter;
71 require ExtUtils::Manifest;
72 require ExtUtils::Liblist;
73 #use strict qw(refs);
74
75 eval {require DynaLoader;};     # Get mod2fname, if defined. Will fail
76                                 # with miniperl.
77
78 # print join "**\n**", "", %INC, "";
79 %NORMAL_INC = %INC;
80
81
82
83 @ISA = qw(Exporter);
84 @EXPORT = qw(&WriteMakefile &writeMakefile $Verbose &prompt);
85 @EXPORT_OK = qw($Version $VERSION &Version_check
86                 &help &neatvalue &mkbootstrap &mksymlists
87                 %att  ## Import of %att is deprecated, please use OO features!
88 );
89
90 if ($Is_VMS = ($Config::Config{osname} eq 'VMS')) {
91     require ExtUtils::MM_VMS;
92     require VMS::Filespec;
93     import VMS::Filespec '&vmsify';
94 }
95 $Is_OS2 = $Config::Config{osname} =~ m|^os/?2$|i ;
96 $ENV{EMXSHELL} = 'sh' if $Is_OS2; # to run `commands`
97
98 $ExtUtils::MakeMaker::Verbose = 0 unless defined $ExtUtils::MakeMaker::Verbose;
99 $^W=1;
100 #$SIG{__DIE__} = sub { print @_, Carp::longmess(); die; };
101 ####$SIG{__WARN__} = sub { print Carp::longmess(); warn @_; };
102 $SIG{__WARN__} = sub {
103     $_[0] =~ /^Use of uninitialized value/ && return;
104     $_[0] =~ /used only once/ && return;
105     $_[0] =~ /^Subroutine\s+[\w:]+\s+redefined/ && return;
106     warn @_;
107 };
108
109 # Setup dummy package:
110 # MY exists for overriding methods to be defined within
111 unshift(@MY::ISA, qw(MM));
112
113 # Dummy package MM inherits actual methods from OS-specific
114 # default packages.  We use this intermediate package so
115 # MY::XYZ->func() can call MM->func() and get the proper
116 # default routine without having to know under what OS
117 # it's running.
118
119 @MM::ISA = qw[MM_Unix ExtUtils::MakeMaker];
120 unshift @MM::ISA, 'ExtUtils::MM_VMS' if $Is_VMS;
121 unshift @MM::ISA, 'ExtUtils::MM_OS2' if $Is_OS2;
122
123
124 @ExtUtils::MakeMaker::MM_Sections_spec = (
125     post_initialize     => {},
126     const_config        => {},
127     constants           => {},
128     const_loadlibs      => {},
129     const_cccmd         => {}, # the last but one addition here (CONST_CCCMD)
130     tool_autosplit      => {},
131     tool_xsubpp         => {},
132     tools_other         => {},
133     dist                => {},
134     macro               => {},
135     post_constants      => {},
136     pasthru             => {},
137     c_o                 => {},
138     xs_c                => {},
139     xs_o                => {},
140     top_targets         => {}, # currently the last section that adds a key to $self (DIR_TARGET)
141     linkext             => {},
142     dlsyms              => {},
143     dynamic             => {},
144     dynamic_bs          => {},
145     dynamic_lib         => {},
146     static              => {},
147     static_lib          => {},
148     installpm           => {},
149     manifypods          => {},
150     processPL           => {},
151     installbin          => {},
152     subdirs             => {},
153     clean               => {},
154     realclean           => {},
155     dist_basics         => {},
156     dist_core           => {},
157     dist_dir            => {},
158     dist_test           => {},
159     dist_ci             => {},
160     install             => {},
161     force               => {},
162     perldepend          => {},
163     makefile            => {},
164     staticmake          => {},  # Sadly this defines more macros
165     test                => {},
166     postamble           => {},  # should always be last the user has hands on
167     selfdocument        => {},  # well, he may override it, but he won't do it
168 );
169 # loses section ordering
170 %ExtUtils::MakeMaker::MM_Sections = @ExtUtils::MakeMaker::MM_Sections_spec;
171 # keeps order
172 @ExtUtils::MakeMaker::MM_Sections = grep(!ref, @ExtUtils::MakeMaker::MM_Sections_spec);
173
174 %ExtUtils::MakeMaker::Recognized_Att_Keys = %ExtUtils::MakeMaker::MM_Sections; # All sections are valid keys.
175
176 @ExtUtils::MakeMaker::Get_from_Config = qw(
177 ar
178 cc
179 cccdlflags
180 ccdlflags
181 dlext
182 dlsrc
183 ld
184 lddlflags
185 ldflags
186 libc
187 lib_ext
188 obj_ext
189 ranlib
190 so
191 );
192
193 my $item;
194 foreach $item (split(/\n/,attrib_help())){
195     next unless $item =~ m/^=item\s+(\w+)\s*$/;
196     $ExtUtils::MakeMaker::Recognized_Att_Keys{$1} = $2;
197     print "Attribute '$1' => '$2'\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
198 }
199 foreach $item (@ExtUtils::MakeMaker::Get_from_Config) {
200     next unless $Config::Config{$item};
201     $ExtUtils::MakeMaker::Recognized_Att_Keys{uc $item} = $Config::Config{$item};
202     print "Attribute '\U$item\E' => '$Config::Config{$item}'\n"
203         if ($ExtUtils::MakeMaker::Verbose >= 2);
204 }
205
206 %ExtUtils::MakeMaker::Prepend_dot_dot = qw(
207 INST_LIB 1 INST_ARCHLIB 1 INST_EXE 1 MAP_TARGET 1 INST_MAN1DIR 1 INST_MAN3DIR 1
208 PERL_SRC 1 PERL 1 FULLPERL 1
209 );
210 $PACKNAME = "PACK000";
211
212 sub writeMakefile {
213     die <<END;
214
215 The extension you are trying to build apparently is rather old and
216 most probably outdated. We detect that from the fact, that a
217 subroutine "writeMakefile" is called, and this subroutine is not
218 supported anymore since about October 1994.
219
220 Please contact the author or look into CPAN (details about CPAN can be
221 found in the FAQ and at http:/www.perl.com) for a more recent version
222 of the extension. If you're really desperate, you can try to change
223 the subroutine name from writeMakefile to WriteMakefile and rerun
224 'perl Makefile.PL', but you're most probably left alone, when you do
225 so.
226
227 The MakeMaker team
228
229 END
230 }
231
232 sub WriteMakefile {
233     Carp::croak "WriteMakefile: Need even number of args" if @_ % 2;
234     my %att = @_;
235     MM->new(\%att)->flush;
236 }
237
238 sub new {
239     my($class,$self) = @_;
240     my($key);
241
242     print STDOUT "MakeMaker (v$ExtUtils::MakeMaker::VERSION)\n" if $ExtUtils::MakeMaker::Verbose;
243     if (-f "MANIFEST" && ! -f "Makefile"){
244         check_manifest();
245     }
246
247     $self = {} unless (defined $self);
248
249     check_hints($self);
250
251     my(%initial_att) = %$self; # record initial attributes
252
253     if (defined $self->{CONFIGURE}) {
254         if (ref $self->{CONFIGURE} eq 'CODE') {
255             $self = { %$self, %{&{$self->{CONFIGURE}}}};
256         } else {
257             croak "Attribute 'CONFIGURE' to WriteMakefile() not a code reference\n";
258         }
259     }
260
261     # This is for old Makefiles written pre 5.00, will go away
262     if ( Carp::longmess("") =~ /runsubdirpl/s ){
263         $self->{Correct_relativ_directories}++;
264     } else {
265         $self->{Correct_relativ_directories}=0;
266     }
267
268     my $class = ++$PACKNAME;
269     {
270 #       no strict;
271         print "Blessing Object into class [$class]\n" if $ExtUtils::MakeMaker::Verbose;
272         mv_all_methods("MY",$class);
273         bless $self, $class;
274 ########        tie %::att, ExtUtils::MakeMaker::TieAtt, $self;
275         push @ExtUtils::MakeMaker::Parent, $self;
276         @{"$class\:\:ISA"} = 'MM';
277     }
278
279     if (defined $ExtUtils::MakeMaker::Parent[-2]){
280         $self->{PARENT} = $ExtUtils::MakeMaker::Parent[-2];
281         my $key;
282         for $key (keys %ExtUtils::MakeMaker::Prepend_dot_dot) {
283             next unless defined $self->{PARENT}{$key};
284             $self->{$key} = $self->{PARENT}{$key};
285             $self->{$key} = $self->catdir("..",$self->{$key})
286                 unless $self->{$key} =~ m!^/!;
287         }
288         $self->{PARENT}->{CHILDREN}->{$class} = $self if $self->{PARENT};
289     } else {
290         parse_args($self,@ARGV);
291     }
292
293     $self->{NAME} ||= $self->guess_name;
294
295     ($self->{NAME_SYM} = $self->{NAME}) =~ s/\W+/_/g;
296
297     $self->init_main();
298
299     if (! $self->{PERL_SRC} ) {
300         my($pthinks) = $INC{'Config.pm'};
301         $pthinks = vmsify($pthinks) if $Is_VMS;
302         if ($pthinks ne $self->catfile($Config::Config{archlibexp},'Config.pm')){
303             $pthinks =~ s!/Config\.pm$!!;
304             $pthinks =~ s!.*/!!;
305             print STDOUT <<END;
306 Your perl and your Config.pm seem to have different ideas about the architecture
307 they are running on.
308 Perl thinks: [$pthinks]
309 Config says: [$Config::Config{archname}]
310 This may or may not cause problems. Please check your installation of perl if you
311 have problems building this extension.
312 END
313         }
314     }
315
316     $self->init_dirscan();
317     $self->init_others();
318
319     push @{$self->{RESULT}}, <<END;
320 # This Makefile is for the $self->{NAME} extension to perl.
321 #
322 # It was generated automatically by MakeMaker version $ExtUtils::MakeMaker::VERSION from the contents
323 # of Makefile.PL. Don't edit this file, edit Makefile.PL instead.
324 #
325 #       ANY CHANGES MADE HERE WILL BE LOST!
326 #
327 #   MakeMaker Parameters:
328 END
329
330     foreach $key (sort keys %initial_att){
331         my($v) = neatvalue($initial_att{$key});
332         $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
333         $v =~ tr/\n/ /s;
334         push @{$self->{RESULT}}, "#     $key => $v";
335     }
336
337     # turn the SKIP array into a SKIPHASH hash
338     my (%skip,$skip);
339     for $skip (@{$self->{SKIP} || []}) {
340         $self->{SKIPHASH}{$skip} = 1;
341     }
342
343     # We run all the subdirectories now. They don't have much to query
344     # from the parent, but the parent has to query them: if they need linking!
345     my($dir);
346     unless ($self->{NORECURS}) {
347         foreach $dir (@{$self->{DIR}}){
348             chdir $dir;
349             package main;
350             local *FH;
351             open FH, "Makefile.PL";
352             eval join "", <FH>;
353             close FH;
354             chdir "..";
355         }
356     }
357
358     tie %::att, ExtUtils::MakeMaker::TieAtt, $self;
359     my $section;
360     foreach $section ( @ExtUtils::MakeMaker::MM_Sections ){
361         print "Processing Makefile '$section' section\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
362         my($skipit) = $self->skipcheck($section);
363         if ($skipit){
364             push @{$self->{RESULT}}, "\n# --- MakeMaker $section section $skipit.";
365         } else {
366             my(%a) = %{$self->{$section} || {}};
367             push @{$self->{RESULT}}, "\n# --- MakeMaker $section section:";
368             push @{$self->{RESULT}}, "# " . join ", ", %a if $ExtUtils::MakeMaker::Verbose && %a;
369             push @{$self->{RESULT}}, $self->nicetext($self->$section( %a ));
370         }
371     }
372
373     push @{$self->{RESULT}}, "\n# End.";
374 ########    untie %::att;
375     pop @ExtUtils::MakeMaker::Parent;
376
377     $self;
378 }
379
380 sub check_manifest {
381     eval {require ExtUtils::Manifest};
382     if ($@){
383         print STDOUT "Warning: you have not installed the ExtUtils::Manifest
384          module -- skipping check of the MANIFEST file\n";
385     } else {
386         print STDOUT "Checking if your kit is complete...\n";
387         $ExtUtils::Manifest::Quiet=$ExtUtils::Manifest::Quiet=1; #avoid warning
388         my(@missed)=ExtUtils::Manifest::manicheck();
389         if (@missed){
390             print STDOUT "Warning: the following files are missing in your kit:\n";
391             print "\t", join "\n\t", @missed;
392             print STDOUT "\n";
393             print STDOUT "Please inform the author.\n";
394         } else {
395             print STDOUT "Looks good\n";
396         }
397     }
398 }
399
400 sub parse_args{
401     my($self, @args) = @_;
402     foreach (@args){
403         unless (m/(.*?)=(.*)/){
404             help(),exit 1 if m/^help$/;
405             ++$ExtUtils::MakeMaker::Verbose if m/^verb/;
406             next;
407         }
408         my($name, $value) = ($1, $2);
409         if ($value =~ m/^~(\w+)?/){ # tilde with optional username
410             $value =~ s [^~(\w*)]
411                 [$1 ?
412                  ((getpwnam($1))[7] || "~$1") :
413                  (getpwuid($>))[7]
414                  ]ex;
415         }
416         # This may go away, in mid 1996
417         if ($self->{Correct_relativ_directories}){
418             $value = $self->catdir("..",$value)
419                 if $ExtUtils::MakeMaker::Prepend_dot_dot{$name} && ! $value =~ m!^/!;
420         }
421         $self->{$name} = $value;
422     }
423     # This may go away, in mid 1996
424     delete $self->{Correct_relativ_directories};
425
426     # catch old-style 'potential_libs' and inform user how to 'upgrade'
427     if (defined $self->{potential_libs}){
428         my($msg)="'potential_libs' => '$self->{potential_libs}' should be";
429         if ($self->{potential_libs}){
430             print STDOUT "$msg changed to:\n\t'LIBS' => ['$self->{potential_libs}']\n";
431         } else {
432             print STDOUT "$msg deleted.\n";
433         }
434         $self->{LIBS} = [$self->{potential_libs}];
435         delete $self->{potential_libs};
436     }
437     # catch old-style 'ARMAYBE' and inform user how to 'upgrade'
438     if (defined $self->{ARMAYBE}){
439         my($armaybe) = $self->{ARMAYBE};
440         print STDOUT "ARMAYBE => '$armaybe' should be changed to:\n",
441                         "\t'dynamic_lib' => {ARMAYBE => '$armaybe'}\n";
442         my(%dl) = %{$self->{dynamic_lib} || {}};
443         $self->{dynamic_lib} = { %dl, ARMAYBE => $armaybe};
444         delete $self->{ARMAYBE};
445     }
446     if (defined $self->{LDTARGET}){
447         print STDOUT "LDTARGET should be changed to LDFROM\n";
448         $self->{LDFROM} = $self->{LDTARGET};
449         delete $self->{LDTARGET};
450     }
451     # Turn a DIR argument on the command line into an array
452     if (defined $self->{DIR} && ref \$self->{DIR} eq 'SCALAR') {
453         # So they can choose from the command line, which extensions they want
454         # the grep enables them to have some colons too much in case they
455         # have to build a list with the shell
456         $self->{DIR} = [grep $_, split ":", $self->{DIR}];
457     }
458     my $mmkey;
459     foreach $mmkey (sort keys %$self){
460         print STDOUT "  $mmkey => ", neatvalue($self->{$mmkey}), "\n" if $ExtUtils::MakeMaker::Verbose;
461         print STDOUT "'$mmkey' is not a known MakeMaker parameter name.\n"
462             unless exists $ExtUtils::MakeMaker::Recognized_Att_Keys{$mmkey};
463     }
464 }
465
466 sub check_hints {
467     my($self) = @_;
468     # We allow extension-specific hints files.
469
470     return unless -d "hints";
471
472     # First we look for the best hintsfile we have
473     my(@goodhints);
474     my($hint)="$Config::Config{osname}_$Config::Config{osvers}";
475     $hint =~ s/\./_/g;
476     $hint =~ s/_$//;
477     return unless $hint;
478
479     # Also try without trailing minor version numbers.
480     while (1) {
481         last if -f "hints/$hint.pl";      # found
482     } continue {
483         last unless $hint =~ s/_[^_]*$//; # nothing to cut off
484     }
485     return unless -f "hints/$hint.pl";    # really there
486
487     # execute the hintsfile:
488     local *HINTS;
489     open HINTS, "hints/$hint.pl";
490     @goodhints = <HINTS>;
491     close HINTS;
492     print STDOUT "Processing hints file hints/$hint.pl\n";
493     eval join('',@goodhints);
494     print STDOUT $@ if $@;
495 }
496
497 sub mv_all_methods {
498     my($from,$to) = @_;
499     my($method);
500     my($symtab) = \%{"${from}::"};
501 #    no strict;
502
503     # Here you see the *current* list of methods that are overridable
504     # from Makefile.PL via MY:: subroutines. As of VERSION 5.07 I'm
505     # still trying to reduce the list to some reasonable minimum --
506     # because I want to make it easier for the user. A.K.
507
508     foreach $method (@ExtUtils::MakeMaker::MM_Sections, qw[ dir_target
509 exescan fileparse fileparse_set_fstype installpm_x libscan makeaperl
510 mksymlists needs_linking runsubdirpl subdir_x test_via_harness
511 test_via_script writedoc ]) {
512
513         # We cannot say "next" here. Nick might call MY->makeaperl
514         # which isn't defined right now
515
516         # next unless defined &{"${from}::$method"};
517
518         *{"${to}::$method"} = \&{"${from}::$method"};
519
520         # delete would do, if we were sure, nobody ever called
521         # MY->makeaperl directly
522
523         # delete $symtab->{$method};
524
525         # If we delete a method, then it will be undefined and cannot
526         # be called.  But as long as we have Makefile.PLs that rely on
527         # %MY:: being intact, we have to fill the hole with an
528         # inheriting method:
529
530         eval "package MY; sub $method {local *$method; shift->MY::$method(\@_); }";
531
532     }
533
534     # We have to clean out %INC also, because the current directory is
535     # changed frequently and Graham Barr prefers to get his version
536     # out of a History.pl file which is "required" so woudn't get
537     # loaded again in another extension requiring a History.pl
538
539     my $inc;
540     foreach $inc (keys %INC) {
541         next if $ExtUtils::MakeMaker::NORMAL_INC{$inc};
542         #warn "***$inc*** deleted";
543         delete $INC{$inc};
544     }
545
546 }
547
548 sub prompt {
549     my($mess,$def)=@_;
550     BEGIN { $ISA_TTY = -t STDIN && -t STDOUT }
551     Carp::confess("prompt function called without an argument") unless defined $mess;
552     $def = "" unless defined $def;
553     my $dispdef = "[$def] ";
554     my $ans;
555     if ($ISA_TTY) {
556         local $|=1;
557         print "$mess $dispdef";
558         chop($ans = <STDIN>);
559     }
560     return $ans if defined $ans;
561     return $def;
562 }
563
564 sub attrib_help {
565     return $Attrib_Help if $Attrib_Help;
566     my $switch = 0;
567     my $help;
568     my $line;
569     local *POD;
570 ####    local $/ = ""; # bug in 5.001m
571     open POD, $INC{"ExtUtils/MakeMaker.pm"}
572     or die "Open $INC{'ExtUtils/MakeMaker.pm'}: $!";
573     while ($line = <POD>) {
574         $switch ||= $line =~ /^=item C\s*$/;
575         next unless $switch;
576         last if $line =~ /^=cut/;
577         $help .= $line;
578     }
579     close POD;
580     $Attrib_Help = $help;
581 }
582
583 sub help {print &attrib_help, "\n";}
584
585 sub skipcheck{
586     my($self) = shift;
587     my($section) = @_;
588     if ($section eq 'dynamic') {
589         print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
590         "in skipped section 'dynamic_bs'\n"
591             if $self->{SKIPHASH}{dynamic_bs} && $ExtUtils::MakeMaker::Verbose;
592         print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
593         "in skipped section 'dynamic_lib'\n"
594             if $self->{SKIPHASH}{dynamic_lib} && $ExtUtils::MakeMaker::Verbose;
595     }
596     if ($section eq 'dynamic_lib') {
597         print STDOUT "Warning (non-fatal): Target '\$(INST_DYNAMIC)' depends on ",
598         "targets in skipped section 'dynamic_bs'\n"
599             if $self->{SKIPHASH}{dynamic_bs} && $ExtUtils::MakeMaker::Verbose;
600     }
601     if ($section eq 'static') {
602         print STDOUT "Warning (non-fatal): Target 'static' depends on targets ",
603         "in skipped section 'static_lib'\n"
604             if $self->{SKIPHASH}{static_lib} && $ExtUtils::MakeMaker::Verbose;
605     }
606     return 'skipped' if $self->{SKIPHASH}{$section};
607     return '';
608 }
609
610 sub flush {
611     my $self = shift;
612     my($chunk);
613     local *MAKE;
614     print STDOUT "Writing $self->{MAKEFILE} for $self->{NAME}\n";
615
616     unlink($self->{MAKEFILE}, "MakeMaker.tmp", $Is_VMS ? 'Descrip.MMS' : '');
617     open MAKE, ">MakeMaker.tmp" or die "Unable to open MakeMaker.tmp: $!";
618
619     for $chunk (@{$self->{RESULT}}) {
620         print MAKE "$chunk\n";
621     }
622
623     close MAKE;
624     my($finalname) = $self->{MAKEFILE};
625     rename("MakeMaker.tmp", $finalname);
626     chmod 0644, $finalname unless $Is_VMS;
627     system("$Config::Config{eunicefix} $finalname") unless $Config::Config{eunicefix} eq ":";
628 }
629
630 sub Version_check {
631     my($checkversion) = @_;
632     die "Your Makefile was built with ExtUtils::MakeMaker v $checkversion.
633 Current Version is $ExtUtils::MakeMaker::VERSION. There have been considerable
634 changes in the meantime.
635 Please rerun 'perl Makefile.PL' to regenerate the Makefile.\n"
636     if $checkversion < $ExtUtils::MakeMaker::Version_OK;
637     printf STDOUT "%s %s %s %s.\n", "Makefile built with ExtUtils::MakeMaker v",
638     $checkversion, "Current Version is", $ExtUtils::MakeMaker::VERSION
639         unless $checkversion == $ExtUtils::MakeMaker::VERSION;
640 }
641
642 sub mksymlists {
643     my $class = shift;
644     my $self = shift;
645     bless $self, $class;
646     tie %att, ExtUtils::MakeMaker::TieAtt, $self;
647     $self->parse_args(@ARGV);
648     $self->mksymlists(@_);
649 }
650
651 # The following mkbootstrap() is only for installations that are calling
652 # the pre-4.1 mkbootstrap() from their old Makefiles. This MakeMaker
653 # writes Makefiles, that use ExtUtils::Mkbootstrap directly.
654 sub mkbootstrap {
655     die <<END;
656 !!! Your Makefile has been built such a long time ago, !!!
657 !!! that is unlikely to work with current MakeMaker.   !!!
658 !!! Please rebuild your Makefile                       !!!
659 END
660 }
661
662 sub neatvalue {
663     my($v) = @_;
664     return "undef" unless defined $v;
665     my($t) = ref $v;
666     return "'$v'" unless $t;
667     if ($t eq 'ARRAY') {
668         my(@m, $elem, @neat);
669         push @m, "[";
670         foreach $elem (@$v) {
671             push @neat, "'$elem'";
672         }
673         push @m, join ", ", @neat;
674         push @m, "]";
675         return join "", @m;
676     }
677     return "$v" unless $t eq 'HASH';
678     my(@m, $key, $val);
679     push(@m,"$key=>".neatvalue($val)) while (($key,$val) = each %$v);
680     return "{ ".join(', ',@m)." }";
681 }
682
683 sub selfdocument {
684     my($self) = @_;
685     my(@m);
686     if ($ExtUtils::MakeMaker::Verbose){
687         push @m, "\n# Full list of MakeMaker attribute values:";
688         foreach $key (sort keys %$self){
689             next if $key eq 'RESULT' || $key =~ /^[A-Z][a-z]/;
690             my($v) = neatvalue($self->{$key});
691             $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
692             $v =~ tr/\n/ /s;
693             push @m, "# $key => $v";
694         }
695     }
696     join "\n", @m;
697 }
698
699
700  #     # #     #         #     #
701  ##   ## ##   ##         #     #  #    #     #    #    #
702  # # # # # # # #         #     #  ##   #     #     #  #
703  #  #  # #  #  #         #     #  # #  #     #      ##
704  #     # #     #         #     #  #  # #     #      ##
705  #     # #     #         #     #  #   ##     #     #  #
706  #     # #     # #######  #####   #    #     #    #    #
707
708 package MM_Unix;
709
710 use Config;
711 use Cwd;
712 use File::Basename;
713 require Exporter;
714
715 Exporter::import('ExtUtils::MakeMaker',
716         qw( $Verbose));
717
718 # These attributes cannot be overridden externally
719 @Other_Att_Keys{qw(EXTRALIBS BSLOADLIBS LDLOADLIBS)} = (1) x 3;
720
721 if ($Is_VMS = $Config::Config{osname} eq 'VMS') {
722     require VMS::Filespec;
723     import VMS::Filespec qw( &vmsify );
724 }
725
726 $Is_OS2 = $ExtUtils::MakeMaker::Is_OS2;
727
728 sub guess_name {
729     my($self) = @_;
730     my $name = fastcwd();
731     $name =~ s:.*/:: unless ($name =~ s:^.*/ext/::);
732     $name =~ s#/#::#g;
733     $name =~  s#[\-_][\d.\-]+$##;  # this is new with MM 5.00
734     $name;
735 }
736
737 sub init_main {
738     my($self) = @_;
739     unless (ref $self){
740         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
741         $self = $ExtUtils::MakeMaker::Parent[-1];
742     }
743
744     # --- Initialize Module Name and Paths
745
746     # NAME    = The perl module name for this extension (eg DBD::Oracle).
747     # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
748     # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
749     # ROOTEXT = Directory part of FULLEXT with leading /.
750     ($self->{FULLEXT} =
751      $self->{NAME}) =~ s!::!/!g ;                            #eg. BSD/Foo/Socket
752
753     # Copied from DynaLoader:
754
755     my(@modparts) = split(/::/,$self->{NAME});
756     my($modfname) = $modparts[-1];
757
758     # Some systems have restrictions on files names for DLL's etc.
759     # mod2fname returns appropriate file base name (typically truncated)
760     # It may also edit @modparts if required.
761     if (defined &DynaLoader::mod2fname) {
762         $modfname = &DynaLoader::mod2fname(\@modparts);
763     } elsif ($Is_OS2) {                # Need manual correction if run with miniperl:-(
764         $modfname = substr($modfname, 0, 7) . '_';
765     }
766
767
768     ($self->{BASEEXT} =
769      $self->{NAME}) =~ s!.*::!! ;                            #eg. Socket
770
771     if (defined &DynaLoader::mod2fname or $Is_OS2) {
772         # As of 5.001m, dl_os2 appends '_'
773         $self->{DLBASE} = $modfname;                    #eg. Socket_
774     } else {
775         $self->{DLBASE} = '$(BASEEXT)';
776     }
777
778     ($self->{ROOTEXT} =
779      $self->{FULLEXT}) =~ s#/?\Q$self->{BASEEXT}\E$## ;      #eg. /BSD/Foo
780
781     $self->{ROOTEXT} = ($Is_VMS ? '' : '/') . $self->{ROOTEXT} if $self->{ROOTEXT};
782
783
784     # --- Initialize PERL_LIB, INST_LIB, PERL_SRC
785
786     # *Real* information: where did we get these two from? ...
787     my $inc_config_dir = dirname($INC{'Config.pm'});
788     my $inc_carp_dir   = dirname($INC{'Carp.pm'});
789
790     # Typically PERL_* and INST_* will be identical but that need
791     # not be the case (e.g., installing into project libraries etc).
792
793     # Perl Macro:    With source    No source
794     # PERL_SRC       ../..          (undefined)
795     # PERL_LIB       PERL_SRC/lib   $Config{privlibexp}
796     # PERL_ARCHLIB   PERL_SRC/lib   $Config{archlibexp}
797
798     # INST Macro:    For standard   for any other
799     #                modules        module
800     # INST_LIB       PERL_SRC/lib   ./blib
801     # INST_ARCHLIB   PERL_SRC/lib   ./blib/<archname>
802
803     unless ($self->{PERL_SRC}){
804         my($dir);
805         foreach $dir (qw(.. ../.. ../../..)){
806             if ( -f "$dir/config.sh"
807                 && -f "$dir/perl.h"
808                 && -f "$dir/lib/Exporter.pm") {
809                 $self->{PERL_SRC}=$dir ;
810                 last;
811             }
812         }
813     }
814     if ($self->{PERL_SRC}){
815         $self->{PERL_LIB}     ||= $self->catdir("$self->{PERL_SRC}","lib");
816         $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
817         $self->{PERL_INC}     = $self->{PERL_SRC};
818         # catch a situation that has occurred a few times in the past:
819         warn <<EOM unless -s "$self->{PERL_SRC}/cflags";
820 You cannot build extensions below the perl source tree after executing
821 a 'make clean' in the perl source tree.
822
823 To rebuild extensions distributed with the perl source you should
824 simply Configure (to include those extensions) and then build perl as
825 normal. After installing perl the source tree can be deleted. It is not
826 needed for building extensions.
827
828 It is recommended that you unpack and build additional extensions away
829 from the perl source tree.
830 EOM
831     } else {
832         # we should also consider $ENV{PERL5LIB} here
833         $self->{PERL_LIB}     = $Config::Config{privlibexp} unless $self->{PERL_LIB};
834         $self->{PERL_ARCHLIB} = $Config::Config{archlibexp} unless $self->{PERL_ARCHLIB};
835         $self->{PERL_INC}     = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
836         my $perl_h;
837         die <<EOM unless (-f ($perl_h = $self->catfile("$self->{PERL_INC}","perl.h")));
838 Error: Unable to locate installed Perl libraries or Perl source code.
839
840 It is recommended that you install perl in a standard location before
841 building extensions. You can say:
842
843     $^X Makefile.PL PERL_SRC=/path/to/perl/source/directory
844
845 if you have not yet installed perl but still want to build this
846 extension now.
847 (You get this message, because MakeMaker could not find "$perl_h")
848 EOM
849
850 #        print STDOUT "Using header files found in $self->{PERL_INC}\n"
851 #            if $Verbose && $self->needs_linking();
852
853     }
854
855     # INST_LIB typically pre-set if building an extension after
856     # perl has been built and installed. Setting INST_LIB allows
857     # you to build directly into, say $Config::Config{privlibexp}.
858     unless ($self->{INST_LIB}){
859
860
861         ##### XXXXX We have to change this nonsense
862
863         if (defined $self->{PERL_SRC}) {
864             $self->{INST_LIB} = $self->{PERL_LIB};
865         } else {
866             $self->{INST_LIB} = $self->catdir(".","blib");
867         }
868     }
869     # Try to work out what INST_ARCHLIB should be if not set:
870     unless ($self->{INST_ARCHLIB}){
871         my(%archmap) = (
872                         # our private build lib
873             $self->catdir(".","blib")   =>
874                         $self->catdir(".","blib",$Config::Config{archname}),
875             $self->{PERL_LIB}   => $self->{PERL_ARCHLIB},
876             $Config::Config{privlibexp} => $Config::Config{archlibexp},
877             $inc_carp_dir       => $inc_config_dir,
878         );
879         $self->{INST_ARCHLIB} = $archmap{$self->{INST_LIB}};
880         unless($self->{INST_ARCHLIB}){
881             # Oh dear, we'll have to default it and warn the user
882             my($archname) = $Config::Config{archname};
883             if (-d "$self->{INST_LIB}/$archname"){
884                 $self->{INST_ARCHLIB} = $self->catdir("$self->{INST_LIB}","$archname");
885                 print STDOUT "Defaulting INST_ARCHLIB to $self->{INST_ARCHLIB}\n";
886             } else {
887                 $self->{INST_ARCHLIB} = $self->{INST_LIB};
888             }
889         }
890     }
891     $self->{INST_EXE} ||= $self->catdir('.','blib',$Config::Config{archname});
892
893     my($prefix) = $Config{'prefix'};
894     $prefix = VMS::Filespec::unixify($prefix) if $Is_VMS;
895     unless ($self->{PREFIX}){
896         $self->{PREFIX} = $prefix;
897     }
898 # With perl5.002 it turns out, that we hardcoded some assumptions in here:
899 #       $self->{INSTALLPRIVLIB} = $self->catdir($self->{PREFIX},"lib","perl5");
900 #       $self->{INSTALLBIN} = $self->catdir($self->{PREFIX},"bin");
901 #       $self->{INSTALLMAN3DIR} = $self->catdir($self->{PREFIX},"perl5","man","man3")
902 #           unless defined $self->{INSTALLMAN3DIR};
903
904     # we have to look at the relation between $Config{prefix} and
905     # the requested values
906     $self->{INSTALLPRIVLIB} = $Config{installprivlib};
907     $self->{INSTALLPRIVLIB} = VMS::Filespec::unixpath($self->{INSTALLPRIVLIB})
908       if $Is_VMS;
909     $self->{INSTALLPRIVLIB} =~ s/\Q$prefix\E/\$(PREFIX)/;
910     $self->{INSTALLBIN} = $Config{installbin};
911     $self->{INSTALLBIN} = VMS::Filespec::unixpath($self->{INSTALLBIN})
912       if $Is_VMS;
913     $self->{INSTALLBIN} =~ s/\Q$prefix\E/\$(PREFIX)/;
914     $self->{INSTALLMAN1DIR} = $Config{installman1dir};
915     $self->{INSTALLMAN1DIR} = VMS::Filespec::unixpath($self->{INSTALLMAN1DIR})
916       if $Is_VMS;
917     $self->{INSTALLMAN1DIR} =~ s/\Q$prefix\E/\$(PREFIX)/;
918     $self->{INSTALLMAN3DIR} = $Config{installman3dir};
919     $self->{INSTALLMAN3DIR} = VMS::Filespec::unixpath($self->{INSTALLMAN3DIR})
920       if $Is_VMS;
921     $self->{INSTALLMAN3DIR} =~ s/\Q$prefix\E/\$(PREFIX)/;
922
923     if( $self->{INSTALLPRIVLIB} && ! $self->{INSTALLARCHLIB} ){
924 # Same as above here. With the unresolved versioned directory issue, we have to
925 # be more careful to follow Configure
926 #       my($archname) = $Config::Config{archname};
927 #       if (-d $self->catdir($self->{INSTALLPRIVLIB},$archname)){
928 #           $self->{INSTALLARCHLIB} = $self->catdir($self->{INSTALLPRIVLIB},$archname);
929 #           print STDOUT "Defaulting INSTALLARCHLIB to $self->{INSTALLARCHLIB}\n";
930 #       } else {
931 #           $self->{INSTALLARCHLIB} = $self->{INSTALLPRIVLIB};
932 #       }
933         my($installprivlib) = $Config{'installprivlib'};
934         $installprivlib = VMS::Filespec::unixify($installprivlib) if $Is_VMS;
935         $self->{INSTALLARCHLIB} = $Config{installarchlib};
936         $self->{INSTALLARCHLIB} = VMS::Filespec::unixpath($self->{INSTALLARCHLIB})
937            if $Is_VMS;
938         $self->{INSTALLARCHLIB} =~ s/\Q$installprivlib\E/$self->{INSTALLPRIVLIB}/;
939
940         # It's a pain to be so friendly to the user. I wish we wouldn't have been so nice.
941         # Now we have '$(PREFIX)' in the string, and the directory won't exist
942         my($installarchlib);
943         ($installarchlib = $self->{INSTALLARCHLIB}) =~ s/\$\(PREFIX\)/$self->{PREFIX}/;
944         if (-d $installarchlib) {
945         } else {
946             print STDOUT "Directory $self->{INSTALLARCHLIB} not found, thusly\n" if $Verbose;
947             $self->{INSTALLARCHLIB} = $self->{INSTALLPRIVLIB};
948         }
949         print STDOUT "Defaulting INSTALLARCHLIB to $self->{INSTALLARCHLIB}\n" if $Verbose;
950     }
951
952     $self->{INSTALLPRIVLIB} ||= $Config::Config{installprivlib};
953     $self->{INSTALLARCHLIB} ||= $Config::Config{installarchlib};
954     $self->{INSTALLBIN}     ||= $Config::Config{installbin};
955
956     $self->{INSTALLMAN1DIR} = $Config::Config{installman1dir}
957         unless defined $self->{INSTALLMAN1DIR};
958     unless (defined $self->{INST_MAN1DIR}){
959         if ($self->{INSTALLMAN1DIR} =~ /^(none|\s*)$/){
960             $self->{INST_MAN1DIR} = $self->{INSTALLMAN1DIR};
961         } else {
962             $self->{INST_MAN1DIR} = $self->catdir('.','blib','man','man1');
963         }
964     }
965     $self->{MAN1EXT} ||= $Config::Config{man1ext};
966
967     $self->{INSTALLMAN3DIR} = $Config::Config{installman3dir}
968         unless defined $self->{INSTALLMAN3DIR};
969     unless (defined $self->{INST_MAN3DIR}){
970         if ($self->{INSTALLMAN3DIR} =~ /^(none|\s*)$/){
971             $self->{INST_MAN3DIR} = $self->{INSTALLMAN3DIR};
972         } else {
973             $self->{INST_MAN3DIR} = $self->catdir('.','blib','man','man3');
974         }
975     }
976     $self->{MAN3EXT} ||= $Config::Config{man3ext};
977
978     print STDOUT "CONFIG must be an array ref\n"
979         if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
980     $self->{CONFIG} = [] unless (ref $self->{CONFIG});
981     push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
982     push(@{$self->{CONFIG}}, 'shellflags') if $Config::Config{shellflags};
983     my(%once_only,$m);
984     foreach $m (@{$self->{CONFIG}}){
985         next if $once_only{$m};
986         print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
987                 unless exists $Config::Config{$m};
988         $self->{uc $m} ||= $Config::Config{$m};
989         $once_only{$m} = 1;
990     }
991
992     # These should never be needed
993     $self->{LD} ||= 'ld';
994     $self->{OBJ_EXT} ||= '.o';
995     $self->{LIB_EXT} ||= '.a';
996
997     $self->{MAP_TARGET} ||= "perl";
998
999     unless ($self->{LIBPERL_A}){
1000         $self->{LIBPERL_A} = "libperl$self->{LIB_EXT}";
1001     }
1002
1003     # make a few simple checks
1004     warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1005         (Exporter.pm not found)"
1006         unless (-f $self->catfile("$self->{PERL_LIB}","Exporter.pm"));
1007
1008     ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1009     if ($self->{VERSION_FROM}){
1010         local *PM;
1011         open PM, $self->{VERSION_FROM} or die "Could not open '$self->{VERSION_FROM}' (attribute VERSION_FROM): $!";
1012         while (<PM>) {
1013             chop;
1014             next unless /\$([\w:]*\bVERSION)\b.*=/;
1015             local $ExtUtils::MakeMaker::module_version_variable = $1;
1016             my($eval) = "$_;";
1017             eval $eval;
1018             die "Could not eval '$eval': $@" if $@;
1019             if ($self->{VERSION} = $$ExtUtils::MakeMaker::module_version_variable){
1020                 print "Setting VERSION to $self->{VERSION}\n" if $Verbose;
1021             } else {
1022                 print "WARNING: Setting VERSION via file '$self->{VERSION_FROM}' failed\n";
1023             }
1024             last;
1025         }
1026         close PM;
1027     }
1028     $self->{VERSION} = "0.10" unless $self->{VERSION};
1029     $self->{VERSION} = sprintf("%.10g",$self->{VERSION})
1030         if ($self->{VERSION} =~ /^[\d.]{9,}$/);
1031     ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1032
1033     # Graham Barr and Paul Marquess had some ideas how to ensure
1034     # version compatibility between the *.pm file and the
1035     # corresponding *.xs file. The bottomline was, that we need an
1036     # XS_VERSION macro that defaults to VERSION:
1037     $self->{XS_VERSION} ||= $self->{VERSION};
1038
1039     # --- Initialize Perl Binary Locations
1040
1041     # Find Perl 5. The only contract here is that both 'PERL' and 'FULLPERL'
1042     # will be working versions of perl 5. miniperl has priority over perl
1043     # for PERL to ensure that $(PERL) is usable while building ./ext/*
1044     my ($component,@defpath);
1045     foreach $component ($self->{PERL_SRC}, $self->path(), $Config::Config{binexp}) {
1046         push @defpath, $component if defined $component;
1047     }
1048     $self->{PERL} =
1049         $self->find_perl(5.0, [ $^X, 'miniperl','perl','perl5',"perl$]" ],
1050             \@defpath, $ExtUtils::MakeMaker::Verbose ) unless ($self->{PERL});
1051 # don't check, if perl is executable, maybe they
1052 # have decided to supply switches with perl
1053
1054     # Define 'FULLPERL' to be a non-miniperl (used in test: target)
1055     ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
1056         unless ($self->{FULLPERL});
1057 }
1058
1059 # Ilya's suggestion, will have to go into ExtUtils::MM_OS2 and MM_VMS
1060 sub path {
1061     my($self) = @_;
1062     my $path_sep = $Is_OS2 ? ";" : $Is_VMS ? "/" : ":";
1063     my $path = $ENV{PATH};
1064     $path =~ s:\\:/:g if $Is_OS2;
1065     my @path = split $path_sep, $path;
1066 }
1067
1068 sub init_dirscan {      # --- File and Directory Lists (.xs .pm .pod etc)
1069     my($self) = @_;
1070     unless (ref $self){
1071         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1072         $self = $ExtUtils::MakeMaker::Parent[-1];
1073     }
1074     my($name, %dir, %xs, %c, %h, %ignore, %pl_files, %manifypods);
1075     local(%pm); #the sub in find() has to see this hash
1076     $ignore{'test.pl'} = 1;
1077     $ignore{'makefile.pl'} = 1 if $Is_VMS;
1078     foreach $name ($self->lsdir(".")){
1079         next if ($name =~ /^\./ or $ignore{$name});
1080         if (-d $name){
1081             $dir{$name} = $name if (-f "$name/Makefile.PL");
1082         } elsif ($name =~ /\.xs$/){
1083             my($c); ($c = $name) =~ s/\.xs$/.c/;
1084             $xs{$name} = $c;
1085             $c{$c} = 1;
1086         } elsif ($name =~ /\.c$/i){
1087             $c{$name} = 1
1088                 unless $name =~ m/perlmain\.c/; # See MAP_TARGET
1089         } elsif ($name =~ /\.h$/i){
1090             $h{$name} = 1;
1091         } elsif ($name =~ /\.(p[ml]|pod)$/){
1092             $pm{$name} = $self->catfile('$(INST_LIBDIR)',"$name");
1093         } elsif ($name =~ /\.PL$/ && $name ne "Makefile.PL") {
1094             ($pl_files{$name} = $name) =~ s/\.PL$// ;
1095         } elsif ($Is_VMS && $name =~ /\.pl$/ && $name ne 'makefile.pl' &&
1096                  $name ne 'test.pl') {  # case-insensitive filesystem
1097             ($pl_files{$name} = $name) =~ s/\.pl$// ;
1098         }
1099     }
1100
1101     # Some larger extensions often wish to install a number of *.pm/pl
1102     # files into the library in various locations.
1103
1104     # The attribute PMLIBDIRS holds an array reference which lists
1105     # subdirectories which we should search for library files to
1106     # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ].  We
1107     # recursively search through the named directories (skipping any
1108     # which don't exist or contain Makefile.PL files).
1109
1110     # For each *.pm or *.pl file found $self->libscan() is called with
1111     # the default installation path in $_[1]. The return value of
1112     # libscan defines the actual installation location.  The default
1113     # libscan function simply returns the path.  The file is skipped
1114     # if libscan returns false.
1115
1116     # The default installation location passed to libscan in $_[1] is:
1117     #
1118     #  ./*.pm           => $(INST_LIBDIR)/*.pm
1119     #  ./xyz/...        => $(INST_LIBDIR)/xyz/...
1120     #  ./lib/...        => $(INST_LIB)/...
1121     #
1122     # In this way the 'lib' directory is seen as the root of the actual
1123     # perl library whereas the others are relative to INST_LIBDIR
1124     # (which includes ROOTEXT). This is a subtle distinction but one
1125     # that's important for nested modules.
1126
1127     $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1128         unless $self->{PMLIBDIRS};
1129
1130     #only existing directories that aren't in $dir are allowed
1131
1132     # Avoid $_ wherever possible:
1133     # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1134     my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1135     my ($pmlibdir);
1136     @{$self->{PMLIBDIRS}} = ();
1137     foreach $pmlibdir (@pmlibdirs) {
1138         -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1139     }
1140
1141     if (@{$self->{PMLIBDIRS}}){
1142         print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1143             if ($ExtUtils::MakeMaker::Verbose >= 2);
1144         use File::Find;         # try changing to require !
1145         File::Find::find(sub {
1146             if (-d $_){
1147                 if ($_ eq "CVS" || $_ eq "RCS"){
1148                     $File::Find::prune = 1;
1149                 }
1150                 return;
1151             }
1152             my($path, $prefix) = ($File::Find::name, '$(INST_LIBDIR)');
1153             my($striplibpath,$striplibname);
1154             $prefix =  '$(INST_LIB)' if (($striplibpath = $path) =~ s:^(\W*)lib\W:$1:);
1155             ($striplibname,$striplibpath) = fileparse($striplibpath);
1156             my($inst) = $self->catfile($self->catdir($prefix,$striplibpath),$striplibname);
1157             local($_) = $inst; # for backwards compatibility
1158             $inst = $self->libscan($inst);
1159             print "libscan($path) => '$inst'\n" if ($ExtUtils::MakeMaker::Verbose >= 2);
1160             return unless $inst;
1161             $pm{$path} = $inst;
1162         }, @{$self->{PMLIBDIRS}});
1163     }
1164
1165     $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1166     $self->{XS}  = \%xs             unless $self->{XS};
1167     $self->{PM}  = \%pm             unless $self->{PM};
1168     $self->{C}   = [sort keys %c]   unless $self->{C};
1169     my(@o_files) = @{$self->{C}};
1170     $self->{O_FILES} = [grep s/\.c$/$self->{OBJ_EXT}/i, @o_files] ;
1171     $self->{H}   = [sort keys %h]   unless $self->{H};
1172     $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1173
1174     # Set up names of manual pages to generate from pods
1175     if ($self->{MAN1PODS}) {
1176     } elsif ( $self->{INST_MAN1DIR} =~ /^(none|\s*)$/ ) {
1177         $self->{MAN1PODS} = {};
1178     } else {
1179         my %manifypods = ();
1180         if ( exists $self->{EXE_FILES} ) {
1181             foreach $name (@{$self->{EXE_FILES}}) {
1182                 local(*TESTPOD);
1183                 my($ispod)=0;
1184                 # one day test, if $/ can be set to '' safely (is the bug fixed that was in 5.001m?)
1185                 if (open(TESTPOD,"<$name")) {
1186                     my $testpodline;
1187                     while ($testpodline = <TESTPOD>) {
1188                         if($testpodline =~ /^=head1\s+\w+/) {
1189                             $ispod=1;
1190                             last;
1191                         }
1192                     }
1193                     close(TESTPOD);
1194                 } else {
1195                     # If it doesn't exist yet, we assume, it has pods in it
1196                     $ispod = 1;
1197                 }
1198                 if( $ispod ) {
1199                     $manifypods{$name} = $self->catfile('$(INST_MAN1DIR)',basename($name).'.$(MAN1EXT)');
1200                 }
1201             }
1202         }
1203         $self->{MAN1PODS} = \%manifypods;
1204     }
1205     if ($self->{MAN3PODS}) {
1206     } elsif ( $self->{INST_MAN3DIR} =~ /^(none|\s*)$/ ) {
1207         $self->{MAN3PODS} = {};
1208     } else {
1209         my %manifypods = (); # we collect the keys first, i.e. the files
1210                              # we have to convert to pod
1211         foreach $name (keys %{$self->{PM}}) {
1212             if ($name =~ /\.pod$/ ) {
1213                 $manifypods{$name} = $self->{PM}{$name};
1214             } elsif ($name =~ /\.p[ml]$/ ) {
1215                 local(*TESTPOD);
1216                 my($ispod)=0;
1217                 open(TESTPOD,"<$name");
1218                 my $testpodline;
1219                 while ($testpodline = <TESTPOD>) {
1220                     if($testpodline =~ /^=head/) {
1221                         $ispod=1;
1222                         last;
1223                     }
1224                     #Speculation on the future (K.A., not A.K. :)
1225                     #if(/^=don't\S+install/) { $ispod=0; last}
1226                 }
1227                 close(TESTPOD);
1228
1229                 if( $ispod ) {
1230                     $manifypods{$name} = $self->{PM}{$name};
1231                 }
1232             }
1233         }
1234
1235         # Remove "Configure.pm" and similar, if it's not the only pod listed
1236         # To force inclusion, just name it "Configure.pod", or override MAN3PODS
1237         foreach $name (keys %manifypods) {
1238             if ($name =~ /(config|install|setup).*\.pm/i) {
1239                 delete $manifypods{$name};
1240                 next;
1241             }
1242             my($manpagename) = $name;
1243             unless ($manpagename =~ s!^(\W*)lib\W!$1!) {
1244                 $manpagename = $self->catfile($self->{ROOTEXT},$manpagename);
1245             }
1246             $manpagename =~ s/\.p(od|m|l)$//;
1247             # Strip leading slashes
1248             $manpagename =~ s!^/+!!;
1249             # Turn other slashes into colons
1250 #           $manpagename =~ s,/+,::,g;
1251             $manpagename = $self->replace_manpage_separator($manpagename);
1252             $manifypods{$name} = $self->catfile("\$(INST_MAN3DIR)","$manpagename.\$(MAN3EXT)");
1253         }
1254         $self->{MAN3PODS} = \%manifypods;
1255     }
1256 }
1257
1258 sub lsdir {
1259     my($self) = shift;
1260     my($dir, $regex) = @_;
1261     local(*DIR, @ls);
1262     opendir(DIR, $dir || ".") or return ();
1263     @ls = readdir(DIR);
1264     closedir(DIR);
1265     @ls = grep(/$regex/, @ls) if $regex;
1266     @ls;
1267 }
1268
1269 sub replace_manpage_separator {
1270     my($self,$man) = @_;
1271     $man =~ s,/+,::,g;
1272     $man;
1273 }
1274
1275 sub libscan {
1276     my($self,$path) = @_;
1277     return '' if $path =~ m:/(RCS|SCCS)/: ;
1278     $path;
1279 }
1280
1281 sub init_others {       # --- Initialize Other Attributes
1282     my($self) = shift;
1283     unless (ref $self){
1284         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1285         $self = $ExtUtils::MakeMaker::Parent[-1];
1286     }
1287
1288     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1289     # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1290     # undefined. In any case we turn it into an anon array:
1291
1292     # May check $Config{libs} too, thus not empty.
1293     $self->{LIBS}=[''] unless $self->{LIBS}; 
1294
1295     $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq SCALAR;
1296     $self->{LD_RUN_PATH} = "";
1297     my($libs);
1298     foreach $libs ( @{$self->{LIBS}} ){
1299         $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1300         my(@libs) = $self->extliblist($libs);
1301         if ($libs[0] or $libs[1] or $libs[2]){
1302             # LD_RUN_PATH now computed by ExtUtils::Liblist
1303             ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1304             last;
1305         }
1306     }
1307
1308     unless ( $self->{OBJECT} ){
1309         # init_dirscan should have found out, if we have C files
1310         $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1311     }
1312     $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1313     $self->{BOOTDEP}  = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1314     $self->{PERLMAINCC} ||= '$(CC)';
1315     $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1316
1317     # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1318     # the 'dynamic' section of MM.  We don't have this problem with
1319     # 'static', since we either must use it (%Config says we can't
1320     # use dynamic loading) or the caller asked for it explicitly.
1321     if (!$self->{LINKTYPE}) {
1322        $self->{LINKTYPE} = grep(/dynamic/,@{$self->{SKIP} || []})
1323                         ? 'static'
1324                         : ($Config::Config{usedl} ? 'dynamic' : 'static');
1325     };
1326
1327     # These get overridden for VMS and maybe some other systems
1328     $self->{NOOP}  ||= "";
1329     $self->{FIRST_MAKEFILE} ||= "Makefile";
1330     $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1331     $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1332     $self->{NOECHO} ||= '@';
1333     $self->{RM_F}  ||= "rm -f";
1334     $self->{RM_RF} ||= "rm -rf";
1335     $self->{TOUCH} ||= "touch";
1336     $self->{CP} ||= "cp";
1337     $self->{MV} ||= "mv";
1338     $self->{CHMOD} ||= "chmod";
1339     $self->{UMASK_NULL} ||= "umask 0";
1340 }
1341
1342 sub find_perl {
1343     my($self, $ver, $names, $dirs, $trace) = @_;
1344     unless (ref $self){
1345         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1346         $self = $ExtUtils::MakeMaker::Parent[-1];
1347     }
1348     my($name, $dir);
1349     if ($trace >= 2){
1350         print "Looking for perl $ver by these names:
1351 @$names
1352 in these dirs:
1353 @$dirs
1354 ";
1355     }
1356     foreach $dir (@$dirs){
1357         next unless defined $dir; # $self->{PERL_SRC} may be undefined
1358         foreach $name (@$names){
1359             my $abs;
1360             if ($self->file_name_is_absolute($name)) {
1361                 $abs = $name;
1362             } elsif (($name =~ m|/|) && ($name !~ m|^\.{1,2}/|)) {
1363                 # name is a path that does not begin with dot or dotdot
1364                 $abs = $self->catfile(".", $name);
1365             } else {
1366                 $abs = $self->catfile($dir, $name);
1367             }
1368             print "Checking $abs\n" if ($trace >= 2);
1369             next unless $self->maybe_command($abs);
1370             print "Executing $abs\n" if ($trace >= 2);
1371             if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
1372                 print "Using PERL=$abs\n" if $trace;
1373                 return $abs;
1374             }
1375         }
1376     }
1377     print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
1378     0; # false and not empty
1379 }
1380
1381
1382 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
1383 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
1384     my($self, $names, $dirs, $trace, $ver) = @_;
1385     my($name, $dir);
1386     foreach $dir (@$dirs){
1387         next unless defined $dir; # $self->{PERL_SRC} may be undefined
1388         foreach $name (@$names){
1389             my($abs,$tryabs);
1390             if ($self->file_name_is_absolute($name)) {
1391                 $abs = $name;
1392             } elsif ($name =~ m|/|) {
1393                 $abs = $self->catfile(".", $name); # not absolute
1394             } else {
1395                 $abs = $self->catfile($dir, $name);
1396             }
1397             print "Checking $abs for $name\n" if ($trace >= 2);
1398             next unless $tryabs = $self->maybe_command($abs);
1399             print "Substituting $tryabs instead of $abs\n" 
1400                 if ($trace >= 2 and $tryabs ne $abs);
1401             $abs = $tryabs;
1402             if (defined $ver) {
1403                 print "Executing $abs\n" if ($trace >= 2);
1404                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
1405                     print "Using PERL=$abs\n" if $trace;
1406                     return $abs;
1407                 }
1408             } else { # Do not look for perl
1409                 return $abs;
1410             }
1411         }
1412     }
1413 }
1414
1415 sub maybe_command {
1416     my($self,$file) = @_;
1417     return $file if -x $file && ! -d $file;
1418     return;
1419 }
1420
1421 sub perl_script {
1422     my($self,$file) = @_;
1423     return 1 if -r $file && ! -d $file;
1424     return;
1425 }
1426
1427 # Ilya's suggestion, not yet used
1428 sub file_name_is_absolute {
1429     my($self,$file) = @_;
1430     $file =~ m:^/: ;
1431 }
1432
1433 sub post_initialize {
1434     my($self) = shift;
1435     unless (ref $self){
1436         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1437         $self = $ExtUtils::MakeMaker::Parent[-1];
1438     }
1439     "";
1440 }
1441
1442 # --- Constants Sections ---
1443
1444 sub const_config {
1445     my($self) = shift;
1446     unless (ref $self){
1447         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1448         $self = $ExtUtils::MakeMaker::Parent[-1];
1449     }
1450     my(@m,$m);
1451     push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n");
1452     push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n");
1453     my(%once_only);
1454     foreach $m (@{$self->{CONFIG}}){
1455         next if $once_only{$m};
1456         push @m, "\U$m\E = ".$self->{uc $m}."\n";
1457         $once_only{$m} = 1;
1458     }
1459     join('', @m);
1460 }
1461
1462 sub constants {
1463     my($self) = @_;
1464     unless (ref $self){
1465         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1466         $self = $ExtUtils::MakeMaker::Parent[-1];
1467     }
1468     my(@m,$tmp);
1469
1470     push @m, "
1471 NAME = $self->{NAME}
1472 DISTNAME = $self->{DISTNAME}
1473 NAME_SYM = $self->{NAME_SYM}
1474 VERSION = $self->{VERSION}
1475 VERSION_SYM = $self->{VERSION_SYM}
1476 VERSION_MACRO = VERSION
1477 DEFINE_VERSION = -D\$(VERSION_MACRO)=\\\"\$(VERSION)\\\"
1478 XS_VERSION = $self->{XS_VERSION}
1479 XS_VERSION_MACRO = XS_VERSION
1480 XS_DEFINE_VERSION = -D\$(XS_VERSION_MACRO)=\\\"\$(XS_VERSION)\\\"
1481
1482 # In which directory should we put this extension during 'make'?
1483 # This is typically ./blib.
1484 # (also see INST_LIBDIR and relationship to ROOTEXT)
1485 INST_LIB = $self->{INST_LIB}
1486 INST_ARCHLIB = $self->{INST_ARCHLIB}
1487 INST_EXE = $self->{INST_EXE}
1488
1489 PREFIX = $self->{PREFIX}
1490
1491 # AFS users will want to set the installation directories for
1492 # the final 'make install' early without setting INST_LIB,
1493 # INST_ARCHLIB, and INST_EXE for the testing phase
1494 INSTALLPRIVLIB = $self->{INSTALLPRIVLIB}
1495 INSTALLARCHLIB = $self->{INSTALLARCHLIB}
1496 INSTALLBIN = $self->{INSTALLBIN}
1497
1498 # Perl library to use when building the extension
1499 PERL_LIB = $self->{PERL_LIB}
1500 PERL_ARCHLIB = $self->{PERL_ARCHLIB}
1501 LIBPERL_A = $self->{LIBPERL_A}
1502
1503 MAKEMAKER = \$(PERL_LIB)/ExtUtils/MakeMaker.pm
1504 MM_VERSION = $ExtUtils::MakeMaker::VERSION
1505 FIRST_MAKEFILE  = $self->{FIRST_MAKEFILE}
1506 MAKE_APERL_FILE = $self->{MAKE_APERL_FILE}
1507
1508 PERLMAINCC = $self->{PERLMAINCC}
1509 ";
1510
1511     push @m, "
1512 # Where is the perl source code located?
1513 PERL_SRC = $self->{PERL_SRC}\n" if $self->{PERL_SRC};
1514
1515     push @m, "
1516 # Perl header files (will eventually be under PERL_LIB)
1517 PERL_INC = $self->{PERL_INC}
1518 # Perl binaries
1519 PERL = $self->{PERL}
1520 FULLPERL = $self->{FULLPERL}
1521 ";
1522     push @m, "
1523 # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
1524 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
1525 # ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
1526 # DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
1527 FULLEXT = $self->{FULLEXT}
1528 BASEEXT = $self->{BASEEXT}
1529 ROOTEXT = $self->{ROOTEXT}
1530 DLBASE  = $self->{DLBASE}
1531 ";
1532
1533     push @m, "
1534 VERSION_FROM = $self->{VERSION_FROM}
1535 " if defined $self->{VERSION_FROM};
1536
1537     push @m, "
1538 INC = $self->{INC}
1539 DEFINE = $self->{DEFINE}
1540 OBJECT = $self->{OBJECT}
1541 LDFROM = $self->{LDFROM}
1542 LINKTYPE = $self->{LINKTYPE}
1543
1544 # Handy lists of source code files:
1545 XS_FILES= ".join(" \\\n\t", sort keys %{$self->{XS}})."
1546 C_FILES = ".join(" \\\n\t", @{$self->{C}})."
1547 O_FILES = ".join(" \\\n\t", @{$self->{O_FILES}})."
1548 H_FILES = ".join(" \\\n\t", @{$self->{H}})."
1549 MAN1PODS = ".join(" \\\n\t", sort keys %{$self->{MAN1PODS}})."
1550 MAN3PODS = ".join(" \\\n\t", sort keys %{$self->{MAN3PODS}})."
1551
1552 # Man installation stuff:
1553 INST_MAN1DIR    = $self->{INST_MAN1DIR}
1554 INSTALLMAN1DIR  = $self->{INSTALLMAN1DIR}
1555 MAN1EXT = $self->{MAN1EXT}
1556
1557 INST_MAN3DIR    = $self->{INST_MAN3DIR}
1558 INSTALLMAN3DIR  = $self->{INSTALLMAN3DIR}
1559 MAN3EXT = $self->{MAN3EXT}
1560
1561
1562 # work around a famous dec-osf make(1) feature(?):
1563 makemakerdflt: all
1564
1565 .SUFFIXES: .xs .c .C \$(OBJ_EXT)
1566
1567 # .PRECIOUS: Makefile    # seems to be not necessary anymore
1568
1569 .PHONY: all config static dynamic test linkext
1570
1571 # This extension may link to it's own library (see SDBM_File)
1572 MYEXTLIB = $self->{MYEXTLIB}
1573
1574 # Where is the Config information that we are using/depend on
1575 CONFIGDEP = \$(PERL_ARCHLIB)/Config.pm \$(PERL_INC)/config.h \$(VERSION_FROM)
1576 ";
1577
1578     push @m, '
1579 # Where to put things:
1580 INST_LIBDIR     = $(INST_LIB)$(ROOTEXT)
1581 INST_ARCHLIBDIR = $(INST_ARCHLIB)$(ROOTEXT)
1582
1583 INST_AUTODIR      = $(INST_LIB)/auto/$(FULLEXT)
1584 INST_ARCHAUTODIR  = $(INST_ARCHLIB)/auto/$(FULLEXT)
1585 ';
1586
1587     if ($self->has_link_code()) {
1588         push @m, '
1589 INST_STATIC  = $(INST_ARCHAUTODIR)/$(BASEEXT)$(LIB_EXT)
1590 INST_DYNAMIC = $(INST_ARCHAUTODIR)/$(DLBASE).$(DLEXT)
1591 INST_BOOT    = $(INST_ARCHAUTODIR)/$(BASEEXT).bs
1592 ';
1593     } else {
1594         push @m, '
1595 INST_STATIC  =
1596 INST_DYNAMIC =
1597 INST_BOOT    =
1598 ';
1599     }
1600
1601     if ($Is_OS2) {
1602         $tmp = "$self->{BASEEXT}.def";
1603     } else {
1604         $tmp = "";
1605     }
1606     push @m, "
1607 EXPORT_LIST = $tmp
1608 ";
1609
1610     if ($Is_OS2) {
1611         $tmp = "\$(PERL_INC)/libperl.lib";
1612     } else {
1613         $tmp = "";
1614     }
1615     push @m, "
1616 PERL_ARCHIVE = $tmp
1617 ";
1618
1619     push @m, '
1620 INST_PM = '.join(" \\\n\t", sort values %{$self->{PM}}).'
1621 ';
1622
1623     join('',@m);
1624 }
1625
1626 sub const_loadlibs {
1627     my($self) = shift;
1628     unless (ref $self){
1629         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1630         $self = $ExtUtils::MakeMaker::Parent[-1];
1631     }
1632     return "" unless $self->needs_linking;
1633     # This description can be deleted after ExtUtils::Liblist is in
1634     # the perl dist with pods
1635     "
1636 # $self->{NAME} might depend on some other libraries:
1637 # (These comments may need revising:)
1638 #
1639 # Dependent libraries can be linked in one of three ways:
1640 #
1641 #  1.  (For static extensions) by the ld command when the perl binary
1642 #      is linked with the extension library. See EXTRALIBS below.
1643 #
1644 #  2.  (For dynamic extensions) by the ld command when the shared
1645 #      object is built/linked. See LDLOADLIBS below.
1646 #
1647 #  3.  (For dynamic extensions) by the DynaLoader when the shared
1648 #      object is loaded. See BSLOADLIBS below.
1649 #
1650 # EXTRALIBS =   List of libraries that need to be linked with when
1651 #               linking a perl binary which includes this extension
1652 #               Only those libraries that actually exist are included.
1653 #               These are written to a file and used when linking perl.
1654 #
1655 # LDLOADLIBS =  List of those libraries which can or must be linked into
1656 #               the shared library when created using ld. These may be
1657 #               static or dynamic libraries.
1658 #               LD_RUN_PATH is a colon separated list of the directories
1659 #               in LDLOADLIBS. It is passed as an environment variable to
1660 #               the process that links the shared library.
1661 #
1662 # BSLOADLIBS =  List of those libraries that are needed but can be
1663 #               linked in dynamically at run time on this platform.
1664 #               SunOS/Solaris does not need this because ld records
1665 #               the information (from LDLOADLIBS) into the object file.
1666 #               This list is used to create a .bs (bootstrap) file.
1667 #
1668 EXTRALIBS  = $self->{EXTRALIBS}
1669 LDLOADLIBS = $self->{LDLOADLIBS}
1670 BSLOADLIBS = $self->{BSLOADLIBS}
1671 LD_RUN_PATH= $self->{LD_RUN_PATH}
1672 ";
1673 }
1674
1675 sub const_cccmd {
1676     my($self,$libperl)=@_;
1677     unless (ref $self){
1678         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1679         $self = $ExtUtils::MakeMaker::Parent[-1];
1680     }
1681     return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
1682     return '' unless $self->needs_linking();
1683     $libperl or $libperl = $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ;
1684     $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/;
1685     # This is implemented in the same manner as extliblist,
1686     # e.g., do both and compare results during the transition period.
1687     my($cc,$ccflags,$optimize,$large,$split, $shflags)
1688         = @Config{qw(cc ccflags optimize large split shellflags)};
1689     my($optdebug) = "";
1690
1691     $shflags = '' unless $shflags;
1692     my($prog, $uc, $perltype);
1693
1694     my(%map) =  (
1695                 D =>   '-DDEBUGGING',
1696                 E =>   '-DEMBED',
1697                 DE =>  '-DDEBUGGING -DEMBED',
1698                 M =>   '-DEMBED -DMULTIPLICITY',
1699                 DM =>  '-DDEBUGGING -DEMBED -DMULTIPLICITY',
1700                 );
1701
1702     if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){
1703         $uc = uc($1);
1704     } else {
1705         $uc = ""; # avoid warning
1706     }
1707     $perltype = $map{$uc} ? $map{$uc} : "";
1708
1709     if ($uc =~ /^D/) {
1710         $optdebug = "-g";
1711     }
1712
1713
1714     my($name);
1715     ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
1716     if ($prog = $Config::Config{$name}) {
1717         # Expand hints for this extension via the shell
1718         print STDOUT "Processing $name hint:\n" if $ExtUtils::MakeMaker::Verbose;
1719         my(@o)=`cc=\"$cc\"
1720           ccflags=\"$ccflags\"
1721           optimize=\"$optimize\"
1722           perltype=\"$perltype\"
1723           optdebug=\"$optdebug\"
1724           large=\"$large\"
1725           split=\"$split\"
1726           eval '$prog'
1727           echo cc=\$cc
1728           echo ccflags=\$ccflags
1729           echo optimize=\$optimize
1730           echo perltype=\$perltype
1731           echo optdebug=\$optdebug
1732           echo large=\$large
1733           echo split=\$split
1734           `;
1735         my(%cflags,$line);
1736         foreach $line (@o){
1737             chomp $line;
1738             if ($line =~ /(.*?)=\s*(.*)\s*$/){
1739                 $cflags{$1} = $2;
1740                 print STDOUT "  $1 = $2\n" if $ExtUtils::MakeMaker::Verbose;
1741             } else {
1742                 print STDOUT "Unrecognised result from hint: '$line'\n";
1743             }
1744         }
1745         (    $cc,$ccflags,$perltype,$optdebug,$optimize,$large,$split )=@cflags{
1746           qw( cc  ccflags  perltype  optdebug  optimize  large  split)};
1747     }
1748
1749     if ($optdebug) {
1750         $optimize = $optdebug;
1751     }
1752
1753     my($new) = "$cc -c \$(INC) $ccflags $optimize $perltype $large $split";
1754     $new =~ s/^\s+//; $new =~ s/\s+/ /g; $new =~ s/\s+$//;
1755
1756     my($cccmd) = $new;
1757     $cccmd =~ s/^\s*\Q$Config::Config{cc}\E\s/\$(CC) /;
1758     $cccmd .= " \$(DEFINE_VERSION) \$(XS_DEFINE_VERSION)";
1759     $self->{CONST_CCCMD} = "CCCMD = $cccmd\n";
1760 }
1761
1762 # --- Tool Sections ---
1763
1764 sub tool_autosplit {
1765     my($self, %attribs) = @_;
1766     unless (ref $self){
1767         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1768         $self = $ExtUtils::MakeMaker::Parent[-1];
1769     }
1770     my($asl) = "";
1771     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
1772     q{
1773 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
1774 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
1775 };
1776 }
1777
1778 sub tool_xsubpp {
1779     my($self) = shift;
1780     unless (ref $self){
1781         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1782         $self = $ExtUtils::MakeMaker::Parent[-1];
1783     }
1784     my($xsdir)  = "$self->{PERL_LIB}/ExtUtils";
1785     # drop back to old location if xsubpp is not in new location yet
1786     $xsdir = "$self->{PERL_SRC}/ext" unless (-f "$self->{PERL_LIB}/ExtUtils/xsubpp");
1787     my(@tmdeps) = ('$(XSUBPPDIR)/typemap');
1788     if( $self->{TYPEMAPS} ){
1789         my $typemap;
1790         foreach $typemap (@{$self->{TYPEMAPS}}){
1791                 if( ! -f  $typemap ){
1792                         warn "Typemap $typemap not found.\n";
1793                 }
1794                 else{
1795                         push(@tmdeps,  $typemap);
1796                 }
1797         }
1798     }
1799     push(@tmdeps, "typemap") if -f "typemap";
1800     my(@tmargs) = map("-typemap $_", @tmdeps);
1801     if( exists $self->{XSOPT} ){
1802         unshift( @tmargs, $self->{XSOPT} );
1803     }
1804
1805     my $xsubpp_version = $self->xsubpp_version("$xsdir/xsubpp");
1806
1807     # What are the correct thresholds for version 1 && 2 Paul?
1808     if ( $xsubpp_version > 1.923 ){
1809         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
1810     } else {
1811         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
1812             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
1813         Your version of xsubpp is $xsubpp_version and cannot handle this.
1814         Please upgrade to a more recent version of xsubpp.
1815 };
1816         } else {
1817             $self->{XSPROTOARG} = "";
1818         }
1819     }
1820
1821     "
1822 XSUBPPDIR = $xsdir
1823 XSUBPP = \$(XSUBPPDIR)/xsubpp
1824 XSPROTOARG = $self->{XSPROTOARG}
1825 XSUBPPDEPS = @tmdeps
1826 XSUBPPARGS = @tmargs
1827 ";
1828 };
1829
1830 sub xsubpp_version
1831 {
1832     my($self,$xsubpp) = @_;
1833     my ($version) ;
1834
1835     # try to figure out the version number of the xsubpp on the system
1836
1837     # first try the -v flag, introduced in 1.921 & 2.000a2
1838
1839     my $command = "$self->{PERL} $xsubpp -v 2>&1";
1840     print "Running: $command\n" if $Verbose;
1841     $version = `$command` ;
1842     warn "Running '$command' exits with status " . ($?>>8) if $?;
1843     chop $version ;
1844
1845     return $1 if $version =~ /^xsubpp version (.*)/ ;
1846
1847     # nope, then try something else
1848
1849     my $counter = '000';
1850     my ($file) = 'temp' ;
1851     $counter++ while -e "$file$counter"; # don't overwrite anything
1852     $file .= $counter;
1853
1854     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
1855     print F <<EOM ;
1856 MODULE = fred PACKAGE = fred
1857
1858 int
1859 fred(a)
1860         int     a;
1861 EOM
1862
1863     close F ;
1864
1865     $command = "$self->{PERL} $xsubpp $file 2>&1";
1866     print "Running: $command\n" if $Verbose;
1867     my $text = `$command` ;
1868     warn "Running '$command' exits with status " . ($?>>8) if $?;
1869     unlink $file ;
1870
1871     # gets 1.2 -> 1.92 and 2.000a1
1872     return $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
1873
1874     # it is either 1.0 or 1.1
1875     return 1.1 if $text =~ /^Warning: ignored semicolon/ ;
1876
1877     # none of the above, so 1.0
1878     return "1.0" ;
1879 }
1880
1881 sub tools_other {
1882     my($self) = shift;
1883     unless (ref $self){
1884         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1885         $self = $ExtUtils::MakeMaker::Parent[-1];
1886     }
1887     "
1888 SHELL = /bin/sh
1889 LD = $self->{LD}
1890 TOUCH = $self->{TOUCH}
1891 CP = $self->{CP}
1892 MV = $self->{MV}
1893 RM_F  = $self->{RM_F}
1894 RM_RF = $self->{RM_RF}
1895 CHMOD = $self->{CHMOD}
1896 UMASK_NULL = $self->{UMASK_NULL}
1897 ".q{
1898 # The following is a portable way to say mkdir -p
1899 # To see which directories are created, change the if 0 to if 1
1900 MKPATH = $(PERL) -wle '$$"="/"; foreach $$p (@ARGV){' \\
1901 -e 'next if -d $$p; my(@p); foreach(split(/\//,$$p)){' \\
1902 -e 'push(@p,$$_); next if -d "@p/"; print "mkdir @p" if 0;' \\
1903 -e 'mkdir("@p",0777)||die $$! } } exit 0;'
1904 };
1905 }
1906
1907 sub dist {
1908     my($self, %attribs) = @_;
1909     unless (ref $self){
1910         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1911         $self = $ExtUtils::MakeMaker::Parent[-1];
1912     }
1913     my(@m);
1914     # VERSION should be sanitised before use as a file name
1915     my($name)     = $attribs{NAME}     || '$(DISTVNAME)';
1916     my($tar)      = $attribs{TAR}      || 'tar';        # eg /usr/bin/gnutar
1917     my($tarflags) = $attribs{TARFLAGS} || 'cvf';
1918     my($compress) = $attribs{COMPRESS} || 'compress';   # eg gzip
1919     my($suffix)   = $attribs{SUFFIX}   || 'Z';          # eg gz
1920     my($shar)     = $attribs{SHAR}     || 'shar';       # eg "shar --gzip"
1921     my($preop)    = $attribs{PREOP}    || "$self->{NOECHO}true"; # eg update MANIFEST
1922     my($postop)   = $attribs{POSTOP}   || "$self->{NOECHO}true"; # eg remove the distdir
1923     my($ci)       = $attribs{CI}       || 'ci -u';
1924     my($rcs_label)= $attribs{RCS_LABEL}|| 'rcs -Nv$(VERSION_SYM): -q';
1925     my($dist_cp)  = $attribs{DIST_CP}  || 'best';
1926     my($dist_default) = $attribs{DIST_DEFAULT} || 'tardist';
1927
1928     push @m, "
1929 DISTVNAME = \$(DISTNAME)-\$(VERSION)
1930 TAR  = $tar
1931 TARFLAGS = $tarflags
1932 COMPRESS = $compress
1933 SUFFIX = $suffix
1934 SHAR = $shar
1935 PREOP = $preop
1936 POSTOP = $postop
1937 CI = $ci
1938 RCS_LABEL = $rcs_label
1939 DIST_CP = $dist_cp
1940 DIST_DEFAULT = $dist_default
1941 ";
1942     join "", @m;
1943 }
1944
1945 sub macro {
1946     my($self,%attribs) = @_;
1947     unless (ref $self){
1948         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1949         $self = $ExtUtils::MakeMaker::Parent[-1];
1950     }
1951     my(@m,$key,$val);
1952     while (($key,$val) = each %attribs){
1953         push @m, "$key = $val\n";
1954     }
1955     join "", @m;
1956 }
1957
1958 sub post_constants{
1959     my($self) = shift;
1960     unless (ref $self){
1961         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1962         $self = $ExtUtils::MakeMaker::Parent[-1];
1963     }
1964     "";
1965 }
1966
1967 sub pasthru {
1968     my($self) = shift;
1969     unless (ref $self){
1970         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1971         $self = $ExtUtils::MakeMaker::Parent[-1];
1972     }
1973     my(@m,$key);
1974
1975     my(@pasthru);
1976
1977     foreach $key (qw(INSTALLPRIVLIB INSTALLARCHLIB INSTALLBIN
1978                      INSTALLMAN1DIR INSTALLMAN3DIR LIBPERL_A
1979                      LINKTYPE)){
1980         push @pasthru, "$key=\"\$($key)\"";
1981     }
1982
1983     push @m, "\nPASTHRU = ", join ("\\\n\t", @pasthru), "\n";
1984     join "", @m;
1985 }
1986
1987 # --- Translation Sections ---
1988
1989 sub c_o {
1990     my($self) = shift;
1991     unless (ref $self){
1992         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
1993         $self = $ExtUtils::MakeMaker::Parent[-1];
1994     }
1995     return '' unless $self->needs_linking();
1996     my(@m);
1997     push @m, '
1998 .c$(OBJ_EXT):
1999         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
2000
2001 .C$(OBJ_EXT):
2002         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.C
2003 ';
2004     join "", @m;
2005 }
2006
2007 sub xs_c {
2008     my($self) = shift;
2009     unless (ref $self){
2010         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2011         $self = $ExtUtils::MakeMaker::Parent[-1];
2012     }
2013     return '' unless $self->needs_linking();
2014     '
2015 .xs.c:
2016         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >$*.tc && mv $*.tc $@
2017 ';
2018 }
2019
2020 sub xs_o {      # many makes are too dumb to use xs_c then c_o
2021     my($self) = shift;
2022     unless (ref $self){
2023         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2024         $self = $ExtUtils::MakeMaker::Parent[-1];
2025     }
2026     return '' unless $self->needs_linking();
2027     '
2028 .xs$(OBJ_EXT):
2029         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs >xstmp.c && mv xstmp.c $*.c
2030         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
2031 ';
2032 }
2033
2034 # --- Target Sections ---
2035
2036 sub top_targets {
2037     my($self) = shift;
2038     unless (ref $self){
2039         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2040         $self = $ExtUtils::MakeMaker::Parent[-1];
2041     }
2042     my(@m);
2043     push @m, '
2044 all ::  config $(INST_PM) subdirs linkext manifypods reorg_packlist
2045
2046 subdirs :: $(MYEXTLIB)
2047
2048 '.$self->{NOOP}.'
2049
2050 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
2051
2052 config :: $(INST_ARCHAUTODIR)/.exists Version_check
2053
2054 config :: $(INST_AUTODIR)/.exists
2055 ';
2056
2057     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
2058
2059     if (%{$self->{MAN1PODS}}) {
2060         push @m, q[
2061 config :: $(INST_MAN1DIR)/.exists
2062
2063 ];
2064         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
2065     }
2066     if (%{$self->{MAN3PODS}}) {
2067         push @m, q[
2068 config :: $(INST_MAN3DIR)/.exists
2069
2070 ];
2071         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
2072     }
2073
2074     push @m, '
2075 $(O_FILES): $(H_FILES)
2076 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
2077
2078     push @m, q{
2079 help:
2080         perldoc ExtUtils::MakeMaker
2081 };
2082
2083     push @m, q{
2084 Version_check:
2085         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2086                 -e 'use ExtUtils::MakeMaker qw($$Version &Version_check);' \
2087                 -e '&Version_check("$(MM_VERSION)")'
2088 };
2089
2090     join('',@m);
2091 }
2092
2093 sub linkext {
2094     my($self, %attribs) = @_;
2095     unless (ref $self){
2096         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2097         $self = $ExtUtils::MakeMaker::Parent[-1];
2098     }
2099     # LINKTYPE => static or dynamic or ''
2100     my($linktype) = defined $attribs{LINKTYPE} ?
2101       $attribs{LINKTYPE} : '$(LINKTYPE)';
2102     "
2103 linkext :: $linktype
2104 $self->{NOOP}
2105 ";
2106 }
2107
2108 sub dlsyms {
2109     my($self,%attribs) = @_;
2110     unless (ref $self){
2111         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2112         $self = $ExtUtils::MakeMaker::Parent[-1];
2113     }
2114
2115     return '' unless ($Config::Config{osname} eq 'aix' && $self->needs_linking() );
2116
2117     my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
2118     my($vars)  = $attribs{DL_VARS} || $self->{DL_VARS} || [];
2119     my(@m);
2120
2121     push(@m,"
2122 dynamic :: $self->{BASEEXT}.exp
2123
2124 ") unless $self->{SKIPHASH}{dynamic};
2125
2126     push(@m,"
2127 static :: $self->{BASEEXT}.exp
2128
2129 ") unless $self->{SKIPHASH}{static};
2130
2131     push(@m,"
2132 $self->{BASEEXT}.exp: Makefile.PL
2133 ",'     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e \'use ExtUtils::MakeMaker qw(&mksymlists); \\
2134         MM->new({NAME => "'.$self->{NAME}.'"})->mksymlists({DL_FUNCS => ',
2135         %$funcs ? neatvalue($funcs) : '""',', DL_VARS => ',
2136         @$vars  ? neatvalue($vars)  : '""', ", NAME => \"$self->{NAME}\"})'
2137 ");
2138
2139     join('',@m);
2140 }
2141
2142 # --- Dynamic Loading Sections ---
2143
2144 sub dynamic {
2145     my($self) = shift;
2146     unless (ref $self){
2147         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2148         $self = $ExtUtils::MakeMaker::Parent[-1];
2149     }
2150     '
2151 # $(INST_PM) has been moved to the all: target.
2152 # It remains here for awhile to allow for old usage: "make dynamic"
2153 dynamic :: '.$self->{MAKEFILE}.' $(INST_DYNAMIC) $(INST_BOOT) $(INST_PM)
2154 '.$self->{NOOP}.'
2155 ';
2156 }
2157
2158 sub dynamic_bs {
2159     my($self, %attribs) = @_;
2160     unless (ref $self){
2161         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2162         $self = $ExtUtils::MakeMaker::Parent[-1];
2163     }
2164     return '
2165 BOOTSTRAP =
2166 ' unless $self->has_link_code();
2167
2168     return '
2169 BOOTSTRAP = '."$self->{BASEEXT}.bs".'
2170
2171 # As Mkbootstrap might not write a file (if none is required)
2172 # we use touch to prevent make continually trying to remake it.
2173 # The DynaLoader only reads a non-empty file.
2174 $(BOOTSTRAP): '."$self->{MAKEFILE} $self->{BOOTDEP}".' $(INST_ARCHAUTODIR)/.exists
2175         '.$self->{NOECHO}.'echo "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))"
2176         '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
2177                 -e \'use ExtUtils::Mkbootstrap;\' \
2178                 -e \'Mkbootstrap("$(BASEEXT)","$(BSLOADLIBS)");\'
2179         '.$self->{NOECHO}.'$(TOUCH) $(BOOTSTRAP)
2180         $(CHMOD) 644 $@
2181         '.$self->{NOECHO}.'echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2182
2183 $(INST_BOOT): $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists
2184         '."$self->{NOECHO}$self->{RM_RF}".' $(INST_BOOT)
2185         -'.$self->{CP}.' $(BOOTSTRAP) $(INST_BOOT)
2186         $(CHMOD) 644 $@
2187         '.$self->{NOECHO}.'echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2188 ';
2189 }
2190
2191 sub dynamic_lib {
2192     my($self, %attribs) = @_;
2193     unless (ref $self){
2194         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2195         $self = $ExtUtils::MakeMaker::Parent[-1];
2196     }
2197     return '' unless $self->needs_linking(); #might be because of a subdir
2198
2199     return '' unless $self->has_link_code;
2200
2201     my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
2202     my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
2203     my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":";
2204     my($ldfrom) = '$(LDFROM)';
2205     my($osname) = $Config::Config{osname};
2206     $armaybe = 'ar' if ($osname eq 'dec_osf' and $armaybe eq ':');
2207     my(@m);
2208     push(@m,'
2209 # This section creates the dynamically loadable $(INST_DYNAMIC)
2210 # from $(OBJECT) and possibly $(MYEXTLIB).
2211 ARMAYBE = '.$armaybe.'
2212 OTHERLDFLAGS = '.$otherldflags.'
2213 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.'
2214
2215 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)/.exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
2216 ');
2217     if ($armaybe ne ':'){
2218         $ldfrom = 'tmp$(LIB_EXT)';
2219         push(@m,'       $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n");
2220         push(@m,'       $(RANLIB) '."$ldfrom\n");
2221     }
2222     $ldfrom = "-all $ldfrom -none" if ($osname eq 'dec_osf');
2223     push(@m,'   LD_RUN_PATH="$(LD_RUN_PATH)" $(LD) -o $@ $(LDDLFLAGS) '.$ldfrom.
2224                 ' $(OTHERLDFLAGS) $(MYEXTLIB) $(LDLOADLIBS) $(EXPORT_LIST) $(PERL_ARCHIVE)');
2225     push @m, '
2226         $(CHMOD) 755 $@
2227         '.$self->{NOECHO}.'echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2228 ';
2229
2230     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2231     join('',@m);
2232 }
2233
2234 # --- Static Loading Sections ---
2235
2236 sub static {
2237     my($self) = shift;
2238     unless (ref $self){
2239         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2240         $self = $ExtUtils::MakeMaker::Parent[-1];
2241     }
2242     '
2243 # $(INST_PM) has been moved to the all: target.
2244 # It remains here for awhile to allow for old usage: "make static"
2245 static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
2246 '.$self->{NOOP}.'
2247 ';
2248 }
2249
2250 sub static_lib {
2251     my($self) = @_;
2252     unless (ref $self){
2253         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2254         $self = $ExtUtils::MakeMaker::Parent[-1];
2255     }
2256 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
2257 #    return '' unless $self->needs_linking(); #might be because of a subdir
2258
2259     return '' unless $self->has_link_code;
2260
2261     my(@m);
2262     push(@m, <<'END');
2263 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
2264 END
2265     # If this extension has it's own library (eg SDBM_File)
2266     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
2267     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
2268
2269     push @m, 
2270 q{      $(AR) cr $@ $(OBJECT) && $(RANLIB) $@
2271         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
2272         $(CHMOD) 755 $@
2273         }.$self->{NOECHO}.q{echo $@ >> $(INST_ARCHAUTODIR)/.packlist
2274 };
2275
2276 # Old mechanism - still available:
2277
2278     push @m, "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs}."\n\n"
2279         if $self->{PERL_SRC};
2280
2281     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
2282     join('', "\n",@m);
2283 }
2284
2285 sub installpm {
2286     my($self, %attribs) = @_;
2287     unless (ref $self){
2288         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2289         $self = $ExtUtils::MakeMaker::Parent[-1];
2290     }
2291     # By default .pm files are split into the architecture independent
2292     # library. This is a good thing. If a specific module requires that
2293     # it's .pm files are split into the architecture specific library
2294     # then it should use: installpm => {SPLITLIB=>'$(INST_ARCHLIB)'}
2295     # Note that installperl currently interferes with this (Config.pm)
2296     # User can disable split by saying: installpm => {SPLITLIB=>''}
2297     my($splitlib) = '$(INST_LIB)'; # NOT arch specific by default
2298     $splitlib = $attribs{SPLITLIB} if exists $attribs{SPLITLIB};
2299     my(@m, $dist);
2300     push @m, "inst_pm :: \$(INST_PM)\n\n";
2301     foreach $dist (sort keys %{$self->{PM}}){
2302         my($inst) = $self->{PM}->{$dist};
2303         push(@m, "\n# installpm: $dist => $inst, splitlib=$splitlib\n");
2304         push(@m, $self->installpm_x($dist, $inst, $splitlib));
2305         push(@m, "\n");
2306     }
2307     join('', @m);
2308 }
2309
2310 sub installpm_x { # called by installpm per file
2311     my($self, $dist, $inst, $splitlib) = @_;
2312     unless (ref $self){
2313         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2314         $self = $ExtUtils::MakeMaker::Parent[-1];
2315     }
2316     if ($inst =~ m,[:\#],){
2317         warn "Warning: 'make' would have problems processing this file: '$inst', SKIPPED\n";
2318         return '';
2319     }
2320     my($instdir) = $inst =~ m|(.*)/|;
2321     my(@m);
2322     push(@m,"
2323 $inst: $dist $self->{MAKEFILE} $instdir/.exists \$(INST_ARCHAUTODIR)/.exists
2324         $self->{NOECHO}$self->{RM_F}".' $@
2325         $(UMASK_NULL) && '."$self->{CP} $dist \$\@
2326         $self->{NOECHO}echo ".'$@ >> $(INST_ARCHAUTODIR)/.packlist
2327 ');
2328     push(@m, "\t$self->{NOECHO}\$(AUTOSPLITFILE) \$@ $splitlib/auto\n")
2329         if ($splitlib and $inst =~ m/\.pm$/);
2330
2331     push @m, $self->dir_target($instdir);
2332     join('', @m);
2333 }
2334
2335 sub manifypods {
2336     my($self, %attribs) = @_;
2337     unless (ref $self){
2338         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2339         $self = $ExtUtils::MakeMaker::Parent[-1];
2340     }
2341     return "\nmanifypods :\n" unless %{$self->{MAN3PODS}};
2342     my($dist);
2343     my($pod2man_exe);
2344     if (defined $self->{PERL_SRC}) {
2345         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2346     } else {
2347         $pod2man_exe = $self->catfile($Config{bin},'pod2man');
2348     }
2349     unless ($self->perl_script($pod2man_exe)) {
2350         # No pod2man but some MAN3PODS to be installed
2351         print <<END;
2352
2353 Warning: I could not locate your pod2man program. Please make sure,
2354          your pod2man program is in your PATH before you execute 'make'
2355
2356 END
2357         $pod2man_exe = "-S pod2man";
2358     }
2359     my(@m);
2360     push @m,
2361 qq[POD2MAN_EXE = $pod2man_exe\n],
2362 q[POD2MAN = $(PERL) -we '%m=@ARGV;for (keys %m){' \\
2363 -e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "].$self->{MAKEFILE}.q[";' \\
2364 -e 'print "Installing $$m{$$_}\n";' \\
2365 -e 'system("$$^X \\"-I$(PERL_ARCHLIB)\\" \\"-I$(PERL_LIB)\\" $(POD2MAN_EXE) $$_>$$m{$$_}")==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2366 -e 'chmod 0644, $$m{$$_} or warn "chmod 644 $$m{$$_}: $$!\n";}'
2367 ];
2368     push @m, "\nmanifypods : ";
2369     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2370
2371     push(@m,"\n");
2372     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2373         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2374         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2375     }
2376     join('', @m);
2377 }
2378
2379 sub processPL {
2380     my($self) = shift;
2381     unless (ref $self){
2382         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2383         $self = $ExtUtils::MakeMaker::Parent[-1];
2384     }
2385     return "" unless $self->{PL_FILES};
2386     my(@m, $plfile);
2387     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
2388         push @m, "
2389 all :: $self->{PL_FILES}->{$plfile}
2390
2391 $self->{PL_FILES}->{$plfile} :: $plfile
2392         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile
2393 ";
2394     }
2395     join "", @m;
2396 }
2397
2398 sub installbin {
2399     my($self) = shift;
2400     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2401     return "" unless @{$self->{EXE_FILES}};
2402     my(@m, $from, $to, %fromto, @to);
2403     push @m, $self->dir_target(qw[$(INST_EXE)]);
2404     for $from (@{$self->{EXE_FILES}}) {
2405         my($path)= '$(INST_EXE)/' . basename($from);
2406         local($_) = $path; # for backwards compatibility
2407         $to = $self->exescan($path);
2408         print "exescan($from) => '$to'\n" if ($ExtUtils::MakeMaker::Verbose >=2);
2409         $fromto{$from}=$to;
2410     }
2411     @to   = values %fromto;
2412     push(@m, "
2413 EXE_FILES = @{$self->{EXE_FILES}}
2414
2415 all :: @to
2416
2417 realclean ::
2418         $self->{RM_F} @to
2419 ");
2420
2421     while (($from,$to) = each %fromto) {
2422         my $todir = dirname($to);
2423         push @m, "
2424 $to: $from $self->{MAKEFILE} $todir/.exists
2425         $self->{CP} $from $to
2426 ";
2427     }
2428     join "", @m;
2429 }
2430
2431 sub exescan {
2432     my($self,$path) = @_;
2433     $path;
2434 }
2435 # --- Sub-directory Sections ---
2436
2437 sub subdirs {
2438     my($self) = shift;
2439     unless (ref $self){
2440         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2441         $self = $ExtUtils::MakeMaker::Parent[-1];
2442     }
2443     my(@m,$dir);
2444     # This method provides a mechanism to automatically deal with
2445     # subdirectories containing further Makefile.PL scripts.
2446     # It calls the subdir_x() method for each subdirectory.
2447     foreach $dir (@{$self->{DIR}}){
2448         push(@m, $self->subdir_x($dir));
2449 ####    print "Including $dir subdirectory\n";
2450     }
2451     if (@m){
2452         unshift(@m, "
2453 # The default clean, realclean and test targets in this Makefile
2454 # have automatically been given entries for each subdir.
2455
2456 ");
2457     } else {
2458         push(@m, "\n# none")
2459     }
2460     join('',@m);
2461 }
2462
2463 sub runsubdirpl{        # Experimental! See subdir_x section
2464     my($self,$subdir) = @_;
2465     unless (ref $self){
2466         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2467         $self = $ExtUtils::MakeMaker::Parent[-1];
2468     }
2469     chdir($subdir) or die "chdir($subdir): $!";
2470     package main;
2471     require "Makefile.PL";
2472 }
2473
2474 sub subdir_x {
2475     my($self, $subdir) = @_;
2476     unless (ref $self){
2477         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2478         $self = $ExtUtils::MakeMaker::Parent[-1];
2479     }
2480     my(@m);
2481     qq{
2482
2483 subdirs ::
2484         $self->{NOECHO}-cd $subdir && \$(MAKE) all \$(PASTHRU)
2485
2486 };
2487 }
2488
2489 # --- Cleanup and Distribution Sections ---
2490
2491 sub clean {
2492     my($self, %attribs) = @_;
2493     unless (ref $self){
2494         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2495         $self = $ExtUtils::MakeMaker::Parent[-1];
2496     }
2497     my(@m,$dir);
2498     push(@m, '
2499 # Delete temporary files but do not touch installed files. We don\'t delete
2500 # the Makefile here so a later make realclean still has a makefile to use.
2501
2502 clean ::
2503 ');
2504     # clean subdirectories first
2505     for $dir (@{$self->{DIR}}) {
2506         push @m, "\t-cd $dir && test -f $self->{MAKEFILE} && \$(MAKE) clean\n";
2507     }
2508
2509     my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
2510     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2511     push(@otherfiles, qw[./blib $(MAKE_APERL_FILE) $(INST_ARCHAUTODIR)/extralibs.all
2512                          perlmain.c mon.out core so_locations
2513                          *~ */*~ */*/*~
2514                          *$(OBJ_EXT) *$(LIB_EXT)
2515                          perl.exe $(BOOTSTRAP) $(BASEEXT).bso $(BASEEXT).def $(BASEEXT).exp
2516                         ]);
2517     push @m, "\t-$self->{RM_RF} @otherfiles\n";
2518     # See realclean and ext/utils/make_ext for usage of Makefile.old
2519     push(@m,
2520          "\t-$self->{MV} $self->{MAKEFILE} $self->{MAKEFILE}.old 2>/dev/null\n");
2521     push(@m,
2522          "\t$attribs{POSTOP}\n")   if $attribs{POSTOP};
2523     join("", @m);
2524 }
2525
2526 sub realclean {
2527     my($self, %attribs) = @_;
2528     unless (ref $self){
2529         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2530         $self = $ExtUtils::MakeMaker::Parent[-1];
2531     }
2532     my(@m);
2533     push(@m,'
2534 # Delete temporary files (via clean) and also delete installed files
2535 realclean purge ::  clean
2536 ');
2537     # realclean subdirectories first (already cleaned)
2538     my $sub = "\t-cd %s && test -f %s && \$(MAKE) %s realclean\n";
2539     foreach(@{$self->{DIR}}){
2540         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
2541         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
2542     }
2543     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
2544     push(@m, "  $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
2545     push(@m, "  $self->{RM_F} \$(INST_STATIC) \$(INST_PM)\n");
2546     my(@otherfiles) = ($self->{MAKEFILE},
2547                        "$self->{MAKEFILE}.old"); # Makefiles last
2548     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
2549     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
2550     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
2551     join("", @m);
2552 }
2553
2554 sub dist_basics {
2555     my($self) = shift;
2556     unless (ref $self){
2557         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2558         $self = $ExtUtils::MakeMaker::Parent[-1];
2559     }
2560     my @m;
2561     push @m, q{
2562 distclean :: realclean distcheck
2563 };
2564
2565     push @m, q{
2566 distcheck :
2567         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&fullcheck";' \\
2568                 -e 'fullcheck();'
2569 };
2570
2571     push @m, q{
2572 skipcheck :
2573         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&skipcheck";' \\
2574                 -e 'skipcheck();'
2575 };
2576
2577     push @m, q{
2578 manifest :
2579         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&mkmanifest";' \\
2580                 -e 'mkmanifest();'
2581 };
2582     join "", @m;
2583 }
2584
2585 sub dist_core {
2586     my($self) = shift;
2587     unless (ref $self){
2588         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2589         $self = $ExtUtils::MakeMaker::Parent[-1];
2590     }
2591     my @m;
2592     push @m, q{
2593 dist : $(DIST_DEFAULT)
2594
2595 tardist : $(DISTVNAME).tar.$(SUFFIX)
2596
2597 $(DISTVNAME).tar.$(SUFFIX) : distdir
2598         $(PREOP)
2599         $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME)
2600         $(RM_RF) $(DISTVNAME)
2601         $(COMPRESS) $(DISTVNAME).tar
2602         $(POSTOP)
2603
2604 uutardist : $(DISTVNAME).tar.$(SUFFIX)
2605         uuencode $(DISTVNAME).tar.$(SUFFIX) \\
2606                 $(DISTVNAME).tar.$(SUFFIX) > \\
2607                 $(DISTVNAME).tar.$(SUFFIX).uu
2608
2609 shdist : distdir
2610         $(PREOP)
2611         $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar
2612         $(RM_RF) $(DISTVNAME)
2613         $(POSTOP)
2614 };
2615     join "", @m;
2616 }
2617
2618 sub dist_dir {
2619     my($self) = shift;
2620     unless (ref $self){
2621         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2622         $self = $ExtUtils::MakeMaker::Parent[-1];
2623     }
2624     my @m;
2625     push @m, q{
2626 distdir :
2627         $(RM_RF) $(DISTVNAME)
2628         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "/mani/";' \\
2629                 -e 'manicopy(maniread(),"$(DISTVNAME)", "$(DIST_CP)");'
2630 };
2631     join "", @m;
2632 }
2633
2634 sub dist_test {
2635     my($self) = shift;
2636     unless (ref $self){
2637         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2638         $self = $ExtUtils::MakeMaker::Parent[-1];
2639     }
2640     my @m;
2641     push @m, q{
2642 disttest : distdir
2643         cd $(DISTVNAME) && $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) Makefile.PL
2644         cd $(DISTVNAME) && $(MAKE)
2645         cd $(DISTVNAME) && $(MAKE) test
2646 };
2647     join "", @m;
2648 }
2649
2650 sub dist_ci {
2651     my($self) = shift;
2652     unless (ref $self){
2653         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2654         $self = $ExtUtils::MakeMaker::Parent[-1];
2655     }
2656     my @m;
2657     push @m, q{
2658 ci :
2659         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use ExtUtils::Manifest "&maniread";' \\
2660                 -e '@all = keys %{ maniread() };' \\
2661                 -e 'print("Executing $(CI) @all\n"); system("$(CI) @all");' \\
2662                 -e 'print("Executing $(RCS_LABEL) ...\n"); system("$(RCS_LABEL) @all");'
2663 };
2664     join "", @m;
2665 }
2666
2667 sub install {
2668     my($self, %attribs) = @_;
2669     unless (ref $self){
2670         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2671         $self = $ExtUtils::MakeMaker::Parent[-1];
2672     }
2673     my(@m);
2674     push @m, q{
2675 doc_install ::
2676         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2677         }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB)  \\
2678                 -e "use ExtUtils::MakeMaker; MY->new({})->writedoc('Module', '$(NAME)', \\
2679                 'LINKTYPE=$(LINKTYPE)', 'VERSION=$(VERSION)', 'XS_VERSION=$(XS_VERSION)', \\
2680                 'EXE_FILES=$(EXE_FILES)')" >> $(INSTALLARCHLIB)/perllocal.pod
2681 };
2682
2683     push(@m, "
2684 install :: pure_install doc_install
2685
2686 pure_install ::
2687 ");
2688     # install subdirectories first
2689     push(@m, map("\tcd $_ && test -f $self->{MAKEFILE} && \$(MAKE) install\n",
2690                  @{$self->{DIR}}));
2691
2692     push(@m, "\t$self->{NOECHO}".q{$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'require File::Path;' \
2693         -e '$$message = q[ You do not have permissions to install into];' \
2694         -e 'File::Path::mkpath(@ARGV);' \
2695         -e 'foreach (@ARGV){ die qq{ $$message $$_\\n} unless -w $$_}' \
2696             $(INSTALLPRIVLIB) $(INSTALLARCHLIB)
2697         $(MAKE) INST_LIB=$(INSTALLPRIVLIB) INST_ARCHLIB=$(INSTALLARCHLIB) \
2698             INST_EXE=$(INSTALLBIN) INST_MAN1DIR=$(INSTALLMAN1DIR) \
2699             INST_MAN3DIR=$(INSTALLMAN3DIR) all
2700
2701 reorg_packlist:
2702         }.$self->{NOECHO}.q{$(PERL) -ne 'BEGIN{die "Need 2 arguments to reorg .packlist" unless @ARGV==2;' \
2703             -e '$$out=$$ARGV[1]; shift @ARGV while @ARGV && ! -f $$ARGV[0]; exit unless @ARGV;}' \
2704             -e 'push @lines, $$_ unless $$seen{$$_}++;' \
2705             -e 'END{open STDOUT, ">$$out" or die "Cannot write to $$out: $$!";' \
2706             -e 'print @lines;}' $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist \
2707                 $(INST_ARCHAUTODIR)/.packlist
2708 });
2709
2710 # From MM 5.16:
2711
2712     push @m, q[
2713 # Comment on .packlist rewrite above:
2714 # Read both .packlist files: the old one in PERL_ARCHLIB/auto/FULLEXT, and the new one
2715 # in INSTARCHAUTODIR. Don't croak if they are missing. Write to the one
2716 # in INSTARCHAUTODIR. 
2717
2718 #### UNINSTALL IS STILL EXPERIMENTAL ####
2719 uninstall ::
2720 ];
2721
2722     push(@m, map("\tcd $_ && test -f $self->{MAKEFILE} && \$(MAKE) uninstall\n",
2723                  @{$self->{DIR}}));
2724     push @m, "\t".'$(RM_RF) `cat $(PERL_ARCHLIB)/auto/$(FULLEXT)/.packlist`
2725 ';
2726
2727     join("",@m);
2728 }
2729
2730
2731 sub force {
2732     my($self) = shift;
2733     unless (ref $self){
2734         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2735         $self = $ExtUtils::MakeMaker::Parent[-1];
2736     }
2737     '# Phony target to force checking subdirectories.
2738 FORCE:
2739 ';
2740 }
2741
2742
2743 sub perldepend {
2744     my($self) = shift;
2745     unless (ref $self){
2746         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2747         $self = $ExtUtils::MakeMaker::Parent[-1];
2748     }
2749     my(@m);
2750     push(@m,'
2751 PERL_HDRS = $(PERL_INC)/EXTERN.h $(PERL_INC)/INTERN.h \
2752     $(PERL_INC)/XSUB.h  $(PERL_INC)/av.h        $(PERL_INC)/cop.h \
2753     $(PERL_INC)/cv.h    $(PERL_INC)/dosish.h    $(PERL_INC)/embed.h \
2754     $(PERL_INC)/form.h  $(PERL_INC)/gv.h        $(PERL_INC)/handy.h \
2755     $(PERL_INC)/hv.h    $(PERL_INC)/keywords.h  $(PERL_INC)/mg.h \
2756     $(PERL_INC)/op.h    $(PERL_INC)/opcode.h    $(PERL_INC)/patchlevel.h \
2757     $(PERL_INC)/perl.h  $(PERL_INC)/perly.h     $(PERL_INC)/pp.h \
2758     $(PERL_INC)/proto.h $(PERL_INC)/regcomp.h   $(PERL_INC)/regexp.h \
2759     $(PERL_INC)/scope.h $(PERL_INC)/sv.h        $(PERL_INC)/unixish.h \
2760     $(PERL_INC)/util.h  $(PERL_INC)/config.h
2761
2762 ');
2763
2764     push @m, '
2765 $(OBJECT) : $(PERL_HDRS)
2766 ' if $self->{OBJECT};
2767
2768     push(@m,'
2769 # Check for unpropogated config.sh changes. Should never happen.
2770 # We do NOT just update config.h because that is not sufficient.
2771 # An out of date config.h is not fatal but complains loudly!
2772 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2773         -'.$self->{NOECHO}.'echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2774
2775 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2776         '.$self->{NOECHO}.'echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2777         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2778 ') if $self->{PERL_SRC};
2779
2780     push(@m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n")
2781         if %{$self->{XS}};
2782     join("\n",@m);
2783 }
2784
2785 sub makefile {
2786     my($self) = shift;
2787     unless (ref $self){
2788         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2789         $self = $ExtUtils::MakeMaker::Parent[-1];
2790     }
2791     my @m;
2792     # We do not know what target was originally specified so we
2793     # must force a manual rerun to be sure. But as it should only
2794     # happen very rarely it is not a significant problem.
2795     push @m, '
2796 $(OBJECT) : $(FIRST_MAKEFILE)
2797 ' if $self->{OBJECT};
2798
2799     push @m, '
2800 # We take a very conservative approach here, but it\'s worth it.
2801 # We move Makefile to Makefile.old here to avoid gnu make looping.
2802 '.$self->{MAKEFILE}.' : Makefile.PL $(CONFIGDEP)
2803         '.$self->{NOECHO}.'echo "Makefile out-of-date with respect to $?"
2804         '.$self->{NOECHO}.'echo "Cleaning current config before rebuilding Makefile..."
2805         -'.$self->{NOECHO}.'mv '."$self->{MAKEFILE} $self->{MAKEFILE}.old".'
2806         -$(MAKE) -f '.$self->{MAKEFILE}.'.old clean >/dev/null 2>&1 || true
2807         $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL '."@ARGV".'
2808         '.$self->{NOECHO}.'echo ">>> Your Makefile has been rebuilt. <<<"
2809         '.$self->{NOECHO}.'echo ">>> Please rerun the make command.  <<<"; false
2810 ';
2811
2812     join "", @m;
2813 }
2814
2815 sub staticmake {
2816     my($self, %attribs) = @_;
2817     unless (ref $self){
2818         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2819         $self = $ExtUtils::MakeMaker::Parent[-1];
2820     }
2821     my(@static);
2822
2823     my(%searchdirs)=($self->{PERL_ARCHLIB} => 1,  $self->{INST_ARCHLIB} => 1);
2824     my(@searchdirs)=keys %searchdirs;
2825
2826     # And as it's not yet built, we add the current extension
2827     # but only if it has some C code (or XS code, which implies C code)
2828     if (@{$self->{C}}) {
2829         @static="$self->{INST_ARCHLIB}/auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}";
2830     }
2831
2832     # Either we determine now, which libraries we will produce in the
2833     # subdirectories or we do it at runtime of the make.
2834
2835     # We could ask all subdir objects, but I cannot imagine, why it
2836     # would be necessary.
2837
2838     # Instead we determine all libraries for the new perl at
2839     # runtime.
2840     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
2841
2842     $self->makeaperl(MAKE       => $self->{MAKEFILE},
2843                      DIRS       => \@searchdirs,
2844                      STAT       => \@static,
2845                      INCL       => \@perlinc,
2846                      TARGET     => $self->{MAP_TARGET},
2847                      TMP        => "",
2848                      LIBPERL    => $self->{LIBPERL_A}
2849                     );
2850 }
2851
2852 # --- Test and Installation Sections ---
2853
2854 sub test {
2855     my($self, %attribs) = @_;
2856     unless (ref $self){
2857         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2858         $self = $ExtUtils::MakeMaker::Parent[-1];
2859     }
2860     my($tests) = $attribs{TESTS} || (-d "t" ? "t/*.t" : "");
2861     my(@m);
2862     push(@m,"
2863 TEST_VERBOSE=0
2864 TEST_TYPE=test_\$(LINKTYPE)
2865
2866 test :: \$(TEST_TYPE)
2867 ");
2868     push(@m, map("\t$self->{NOECHO}cd $_ && test -f $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
2869                  @{$self->{DIR}}));
2870     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
2871         unless $tests or -f "test.pl" or @{$self->{DIR}};
2872     push(@m, "\n");
2873
2874     push(@m, "test_dynamic :: all\n");
2875     push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
2876     push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
2877     push(@m, "\n");
2878
2879     # Occasionally we may face this degenerate target:
2880     push @m, "test_ : test_dynamic\n\n";
2881
2882     if ($self->needs_linking()) {
2883         push(@m, "test_static :: all \$(MAP_TARGET)\n");
2884         push(@m, $self->test_via_harness('./$(MAP_TARGET)', $tests)) if $tests;
2885         push(@m, $self->test_via_script('./$(MAP_TARGET)', 'test.pl')) if -f "test.pl";
2886         push(@m, "\n");
2887     } else {
2888         push @m, "test_static :: test_dynamic\n";
2889     }
2890     join("", @m);
2891 }
2892
2893 sub test_via_harness {
2894     my($self, $perl, $tests) = @_;
2895     unless (ref $self){
2896         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2897         $self = $ExtUtils::MakeMaker::Parent[-1];
2898     }
2899     "\tPERL_DL_NONLAZY=1 $perl".q! -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' !."$tests\n";
2900 }
2901
2902 sub test_via_script {
2903     my($self, $perl, $script) = @_;
2904     unless (ref $self){
2905         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2906         $self = $ExtUtils::MakeMaker::Parent[-1];
2907     }
2908     "\tPERL_DL_NONLAZY=1 $perl".' -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) test.pl
2909 ';
2910 }
2911
2912
2913 sub postamble {
2914     my($self) = shift;
2915     unless (ref $self){
2916         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2917         $self = $ExtUtils::MakeMaker::Parent[-1];
2918     }
2919     "";
2920 }
2921
2922 sub makeaperl {
2923     my($self, %attribs) = @_;
2924     unless (ref $self){
2925         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
2926         $self = $ExtUtils::MakeMaker::Parent[-1];
2927     }
2928     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2929         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2930     my(@m);
2931     push @m, "
2932 # --- MakeMaker makeaperl section ---
2933 MAP_TARGET    = $target
2934 FULLPERL      = $self->{FULLPERL}
2935 ";
2936     return join '', @m if $self->{PARENT};
2937
2938     my($dir) = join ":", @{$self->{DIR}};
2939
2940     unless ($self->{MAKEAPERL}) {
2941         push @m, q{
2942 $(MAP_TARGET) :: $(MAKE_APERL_FILE)
2943         $(MAKE) -f $(MAKE_APERL_FILE) static $@
2944
2945 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2946         }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2947         }.$self->{NOECHO}.q{$(PERL) -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
2948                 Makefile.PL DIR=}, $dir, q{ \
2949                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2950                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2951
2952         push @m, map( " \\\n\t\t$_", @ARGV );
2953         push @m, "\n";
2954
2955         return join '', @m;
2956     }
2957
2958
2959
2960     my($cccmd, $linkcmd, $lperl);
2961
2962
2963     $cccmd = $self->const_cccmd($libperl);
2964     $cccmd =~ s/^CCCMD\s*=\s*//;
2965     $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2966     $cccmd .= " $Config::Config{cccdlflags}" if ($Config::Config{d_shrplib});
2967     $cccmd =~ s/\n/ /g; # yes I've seen "\n", don't ask me where it came from. A.K.
2968     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2969
2970     # The front matter of the linkcommand...
2971     $linkcmd = join ' ', "\$(CC)",
2972             grep($_, @Config{qw(large split ldflags ccdlflags)});
2973     $linkcmd =~ s/\s+/ /g;
2974
2975     # Which *.a files could we make use of...
2976     local(%static);
2977     File::Find::find(sub {
2978         return unless m/\Q$self->{LIB_EXT}\E$/;
2979         return if m/^libperl/;
2980         # don't include the installed version of this extension. I
2981         # leave this line here, although it is not necessary anymore:
2982         # I patched minimod.PL instead, so that Miniperl.pm won't
2983         # enclude duplicates
2984
2985         # Once the patch to minimod.PL is in the distribution, I can
2986         # drop it
2987         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}$:;
2988         $static{fastcwd() . "/" . $_}++;
2989     }, grep( -d $_, @{$searchdirs || []}) );
2990
2991     # We trust that what has been handed in as argument, will be buildable
2992     $static = [] unless $static;
2993     @static{@{$static}} = (1) x @{$static};
2994
2995     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2996     for (sort keys %static) {
2997         next unless /\Q$self->{LIB_EXT}\E$/;
2998         $_ = dirname($_) . "/extralibs.ld";
2999         push @$extra, $_;
3000     }
3001
3002     grep(s/^/-I/, @{$perlinc || []});
3003
3004     $target = "perl" unless $target;
3005     $tmp = "." unless $tmp;
3006
3007 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
3008 # regenerate the Makefiles, MAP_STATIC and the dependencies for
3009 # extralibs.all are computed correctly
3010     push @m, "
3011 MAP_LINKCMD   = $linkcmd
3012 MAP_PERLINC   = @{$perlinc || []}
3013 MAP_STATIC    = ",
3014 join(" \\\n\t", reverse sort keys %static), "
3015
3016 MAP_PRELIBS   = $Config::Config{libs} $Config::Config{cryptlib}
3017 ";
3018
3019     if (defined $libperl) {
3020         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
3021     }
3022     unless ($libperl && -f $lperl) { # Could quite follow your idea her, Ilya
3023         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
3024         $libperl ||= "libperl$self->{LIB_EXT}";
3025         $libperl   = "$dir/$libperl";
3026         $lperl   ||= "libperl$self->{LIB_EXT}";
3027         $lperl     = "$dir/$lperl";
3028         print STDOUT "Warning: $libperl not found
3029     If you're going to build a static perl binary, make sure perl is installed
3030     otherwise ignore this warning\n"
3031                 unless (-f $lperl || defined($self->{PERL_SRC}));
3032     }
3033
3034     push @m, "
3035 MAP_LIBPERL = $libperl
3036 ";
3037
3038     push @m, "
3039 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
3040         $self->{NOECHO}$self->{RM_F} \$\@
3041         $self->{NOECHO}\$(TOUCH) \$\@
3042 ";
3043
3044     my $catfile;
3045     foreach $catfile (@$extra){
3046         push @m, "\tcat $catfile >> \$\@\n";
3047     }
3048
3049     push @m, "
3050 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
3051         \$(MAP_LINKCMD) -o \$\@ $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
3052         $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
3053         $self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
3054         $self->{NOECHO}echo 'To remove the intermediate files say'
3055         $self->{NOECHO}echo '    make -f $makefilename map_clean'
3056
3057 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
3058 ";
3059     push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
3060
3061     push @m, qq{
3062 $tmp/perlmain.c: $makefilename}, q{
3063         }.$self->{NOECHO}.q{echo Writing $@
3064         }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -e 'use ExtUtils::Miniperl; \\
3065                 writemain(grep s#.*/auto/##, qw|$(MAP_STATIC)|)' > $@.tmp && mv $@.tmp $@
3066
3067 };
3068
3069 # We write EXTRA outside the perl program to have it eval'd by the shell
3070     push @m, q{
3071 doc_inst_perl:
3072         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
3073         }.$self->{NOECHO}.q{$(FULLPERL) -e 'use ExtUtils::MakeMaker; MY->new->writedoc("Perl binary",' \\
3074                 -e '"$(MAP_TARGET)", "MAP_STATIC=$(MAP_STATIC)",' \\
3075                 -e '"MAP_EXTRA=@ARGV", "MAP_LIBPERL=$(MAP_LIBPERL)")' \\
3076                 -- `cat $(INST_ARCHAUTODIR)/extralibs.all` >> $(INSTALLARCHLIB)/perllocal.pod
3077 };
3078
3079     push @m, qq{
3080 inst_perl: pure_inst_perl doc_inst_perl
3081
3082 pure_inst_perl: \$(MAP_TARGET)
3083         $self->{CP} \$(MAP_TARGET) \$(INSTALLBIN)/\$(MAP_TARGET)
3084
3085 clean :: map_clean
3086
3087 map_clean :
3088         $self->{RM_F} $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
3089 };
3090
3091     join '', @m;
3092 }
3093
3094 sub extliblist {
3095     my($self,$libs) = @_;
3096     unless (ref $self){
3097         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3098         $self = $ExtUtils::MakeMaker::Parent[-1];
3099     }
3100     require ExtUtils::Liblist;
3101     ExtUtils::Liblist::ext($libs, $ExtUtils::MakeMaker::Verbose);
3102 }
3103
3104 sub mksymlists {
3105     my($self) = shift;
3106     unless (ref $self){
3107         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3108         $self = $ExtUtils::MakeMaker::Parent[-1];
3109     }
3110     my($pkg);
3111
3112     # only AIX requires a symbol list at this point
3113     # (so does VMS, but that's handled by the MM_VMS package)
3114     return '' unless $Config::Config{osname} eq 'aix';
3115
3116     $self->init_main(@ARGV) unless defined $self->{BASEEXT};
3117     if (! $self->{DL_FUNCS}) {
3118         my($bootfunc);
3119         ($bootfunc = $self->{NAME}) =~ s/\W/_/g;
3120         $self->{DL_FUNCS} = {$self->{BASEEXT} => ["boot_$bootfunc"]};
3121     }
3122     rename "$self->{BASEEXT}.exp", "$self->{BASEEXT}.exp_old";
3123
3124     open(EXP,">$self->{BASEEXT}.exp") or die $!;
3125     print EXP join("\n",@{$self->{DL_VARS}}, "\n") if $self->{DL_VARS};
3126     foreach $pkg (keys %{$self->{DL_FUNCS}}) {
3127         (my($prefix) = $pkg) =~ s/\W/_/g;
3128         my $func;
3129         foreach $func (@{$self->{DL_FUNCS}->{$pkg}}) {
3130             $func = "XS_${prefix}_$func" unless $func =~ /^boot_/;
3131             print EXP "$func\n";
3132         }
3133     }
3134     close EXP;
3135 }
3136
3137 # --- Make-Directories section (internal method) ---
3138 # dir_target(@array) returns a Makefile entry for the file .exists in each
3139 # named directory. Returns nothing, if the entry has already been processed.
3140 # We're helpless though, if the same directory comes as $(FOO) _and_ as "bar".
3141 # Both of them get an entry, that's why we use "::". I chose '$(PERL)' as the
3142 # prerequisite, because there has to be one, something that doesn't change
3143 # too often :)
3144
3145 sub dir_target {
3146     my($self,@dirs) = @_;
3147     unless (ref $self){
3148         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3149         $self = $ExtUtils::MakeMaker::Parent[-1];
3150     }
3151     my(@m,$dir);
3152     foreach $dir (@dirs) {
3153         next if $self->{DIR_TARGET}{$self}{$dir}++;
3154         push @m, "
3155 $dir/.exists :: \$(PERL)
3156         $self->{NOECHO}\$(MKPATH) $dir
3157         $self->{NOECHO}\$(TOUCH) $dir/.exists
3158         $self->{NOECHO}-\$(CHMOD) 755 $dir
3159 ";
3160     }
3161     join "", @m;
3162 }
3163
3164 # --- Output postprocessing section ---
3165 # nicetext is included to make VMS support easier
3166 sub nicetext { # Just return the input - no action needed
3167     my($self,$text) = @_;
3168     unless (ref $self){
3169         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3170         $self = $ExtUtils::MakeMaker::Parent[-1];
3171     }
3172     $text;
3173 }
3174
3175 sub needs_linking { # Does this module need linking? Looks into
3176                     # subdirectory objects (see also has_link_code()
3177     my($self) = shift;
3178     my($child,$caller);
3179     $caller = (caller(0))[3];
3180     unless (ref $self){
3181         ExtUtils::MakeMaker::TieAtt::warndirectuse($caller);
3182         $self = $ExtUtils::MakeMaker::Parent[-1];
3183     }
3184     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
3185     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
3186 #    print "DEBUG:\n";
3187 #    print Carp::longmess();
3188 #    print "EO_DEBUG\n";
3189     if ($self->has_link_code or $self->{MAKEAPERL}){
3190         $self->{NEEDS_LINKING} = 1;
3191         return 1;
3192     }
3193     foreach $child (keys %{$self->{CHILDREN}}) {
3194         if ($self->{CHILDREN}->{$child}->needs_linking) {
3195             $self->{NEEDS_LINKING} = 1;
3196             return 1;
3197         }
3198     }
3199     return $self->{NEEDS_LINKING} = 0;
3200 }
3201
3202 sub has_link_code {
3203     my($self) = shift;
3204     return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE};
3205     if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){
3206         $self->{HAS_LINK_CODE} = 1;
3207         return 1;
3208     }
3209     return $self->{HAS_LINK_CODE} = 0;
3210 }
3211
3212 # --- perllocal.pod section ---
3213 sub writedoc {
3214     my($self,$what,$name,@attribs)=@_;
3215     unless (ref $self){
3216         ExtUtils::MakeMaker::TieAtt::warndirectuse((caller(0))[3]);
3217         $self = $ExtUtils::MakeMaker::Parent[-1];
3218     }
3219     my($time) = localtime;
3220     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3221     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3222     print "\n\n=back\n\n";
3223 }
3224
3225 sub catdir  { shift; my $result = join('/',@_); $result =~ s:/+:/:g; $result; }
3226 sub catfile { shift; my $result = join('/',@_); $result =~ s:/+:/:g; $result; }
3227
3228 package ExtUtils::MM_OS2;
3229
3230 #use Config;
3231 #use Cwd;
3232 #use File::Basename;
3233 require Exporter;
3234
3235 Exporter::import('ExtUtils::MakeMaker',
3236        qw( $Verbose));
3237
3238 sub dlsyms {
3239     my($self,%attribs) = @_;
3240
3241     my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
3242     my($vars)  = $attribs{DL_VARS} || $self->{DL_VARS} || [];
3243     my(@m);
3244     (my $boot = $self->{NAME}) =~ s/:/_/g;
3245
3246     if (not $self->{SKIPHASH}{'dynamic'}) {
3247         push(@m,"
3248 $self->{BASEEXT}.def: Makefile.PL"
3249           . '
3250         echo "LIBRARY ' . "'$self->{DLBASE}'" . ' INITINSTANCE TERMINSTANCE" > $@ ; \\
3251         echo "CODE LOADONCALL" >> $@ ; \\
3252         echo "DATA LOADONCALL NONSHARED MULTIPLE" >> $@ ; \\
3253         echo "EXPORTS" >> $@ ; \\
3254         echo "  ' . "boot_$boot" . '" >> $@');
3255         foreach $sym (keys %$funcs, @$vars) {
3256             push(@m, " ; \\
3257        echo \"  $sym\" >> \$@");
3258         }
3259         push(@m,"\n");
3260     }
3261
3262     join('',@m);
3263 }
3264
3265 sub replace_manpage_separator {
3266     my($self,$man) = @_;
3267     $man =~ s,/+,.,g;
3268     $man;
3269 }
3270
3271 sub maybe_command {
3272     my($self,$file) = @_;
3273     return $file if -x $file && ! -d _;
3274     return "$file.exe" if -x "$file.exe" && ! -d _;
3275     return "$file.cmd" if -x "$file.cmd" && ! -d _;
3276     return;
3277 }
3278
3279 sub file_name_is_absolute {
3280     my($self,$file) = @_;
3281     $file =~ m{^([a-z]:)?[\\/]}i ;
3282 }
3283
3284
3285 # the following keeps AutoSplit happy
3286 package ExtUtils::MakeMaker;
3287 1;
3288
3289 __END__
3290
3291 =head1 NAME
3292
3293 ExtUtils::MakeMaker - create an extension Makefile
3294
3295 =head1 SYNOPSIS
3296
3297 C<use ExtUtils::MakeMaker;>
3298
3299 C<WriteMakefile( ATTRIBUTE =E<gt> VALUE [, ...] );>
3300
3301 which is really
3302
3303 C<MM-E<gt>new(\%att)-E<gt>flush;>
3304
3305 =head1 DESCRIPTION
3306
3307 This utility is designed to write a Makefile for an extension module
3308 from a Makefile.PL. It is based on the Makefile.SH model provided by
3309 Andy Dougherty and the perl5-porters.
3310
3311 It splits the task of generating the Makefile into several subroutines
3312 that can be individually overridden.  Each subroutine returns the text
3313 it wishes to have written to the Makefile.
3314
3315 =head2 Hintsfile support
3316
3317 MakeMaker.pm uses the architecture specific information from
3318 Config.pm. In addition it evaluates architecture specific hints files
3319 in a C<hints/> directory. The hints files are expected to be named
3320 like their counterparts in C<PERL_SRC/hints>, but with an C<.pl> file
3321 name extension (eg. C<next_3_2.pl>). They are simply C<eval>ed by
3322 MakeMaker within the WriteMakefile() subroutine, and can be used to
3323 execute commands as well as to include special variables. The rules
3324 which hintsfile is chosen are the same as in Configure.
3325
3326 The hintsfile is eval()ed immediately after the arguments given to
3327 WriteMakefile are stuffed into a hash reference $self but before this
3328 reference becomes blessed. So if you want to do the equivalent to
3329 override or create an attribute you would say something like
3330
3331     $self->{LIBS} = ['-ldbm -lucb -lc'];
3332
3333 =head2 What's new in version 5 of MakeMaker
3334
3335 MakeMaker 5 is pure object oriented. This allows us to write an
3336 unlimited number of Makefiles with a single perl process. 'perl
3337 Makefile.PL' with MakeMaker 5 goes through all subdirectories
3338 immediately and evaluates any Makefile.PL found in the next level
3339 subdirectories. The benefit of this approach comes in useful for both
3340 single and multi directories extensions.
3341
3342 Multi directory extensions have an immediately visible speed
3343 advantage, because there's no startup penalty for any single
3344 subdirectory Makefile.
3345
3346 Single directory packages benefit from the much improved
3347 needs_linking() method. As the main Makefile knows everything about
3348 the subdirectories, a needs_linking() method can now query all
3349 subdirectories if there is any linking involved down in the tree. The
3350 speedup for PM-only Makefiles seems to be around 1 second on my
3351 Indy 100 MHz.
3352
3353 =head2 Incompatibilities between MakeMaker 5.00 and 4.23
3354
3355 There are no incompatibilities in the short term, as all changes are
3356 accompanied by short-term workarounds that guarantee full backwards
3357 compatibility.
3358
3359 You are likely to face a few warnings that expose deprecations which
3360 will result in incompatibilities in the long run:
3361
3362 You should not use %att directly anymore. Instead any subroutine you
3363 override in the MY package will be called by the object method, so you
3364 can access all object attributes directly via the object in $_[0].
3365
3366 You should not call the class methos MM->something anymore. Instead
3367 you should call the superclass. Something like
3368
3369     sub MY::constants {
3370         my $self = shift;
3371         $self->MM::constants();
3372     }
3373
3374 Especially the libscan() and exescan() methods should be altered
3375 towards OO programming, that means do not expect that $_ to contain
3376 the path but rather $_[1].
3377
3378 You should program with more care. Watch out for any MakeMaker
3379 variables. Do not try to alter them, somebody else might depend on
3380 them. E.g. do not overwrite the ExtUtils::MakeMaker::VERSION variable
3381 (this happens if you import it and then set it to the version number
3382 of your package), do not expect that the INST_LIB variable will be
3383 ./blib (do not 'unshift @INC, "./blib" and do not use
3384 "blib/FindBin.pm"). Do not croak in your Makefile.PL, let it fail with
3385 a warning instead.
3386
3387 Try to build several extensions simultanously to debug your
3388 Makefile.PL. You can unpack a bunch of distributed packages, so your
3389 directory looks like
3390
3391     Alias-1.00/         Net-FTP-1.01a/      Set-Scalar-0.001/
3392     ExtUtils-Peek-0.4/  Net-Ping-1.00/      SetDualVar-1.0/
3393     Filter-1.06/        NetTools-1.01a/     Storable-0.1/
3394     GD-1.00/            Religion-1.04/      Sys-Domain-1.05/
3395     MailTools-1.03/     SNMP-1.5b/          Term-ReadLine-0.7/
3396
3397 and write a dummy Makefile.PL that contains nothing but
3398
3399     use ExtUtils::MakeMaker;
3400     WriteMakefile();
3401
3402 That's actually fun to watch :)
3403
3404 Final suggestion: Try to delete all of your MY:: subroutines and
3405 watch, if you really still need them. MakeMaker might already do what
3406 you want without them. That's all about it.
3407
3408
3409 =head2 Default Makefile Behaviour
3410
3411 The automatically generated Makefile enables the user of the extension
3412 to invoke
3413
3414   perl Makefile.PL # optionally "perl Makefile.PL verbose"
3415   make
3416   make test        # optionally set TEST_VERBOSE=1
3417   make install     # See below
3418
3419 The Makefile to be produced may be altered by adding arguments of the
3420 form C<KEY=VALUE>. If the user wants to work with a different perl
3421 than the default, this can be achieved with
3422
3423   perl Makefile.PL PERL=/tmp/myperl5
3424
3425 Other interesting targets in the generated Makefile are
3426
3427   make config     # to check if the Makefile is up-to-date
3428   make clean      # delete local temp files (Makefile gets renamed)
3429   make realclean  # delete derived files (including ./blib)
3430   make dist       # see below the Distribution Support section
3431
3432 =head2 Special case make install
3433
3434 make alone puts all relevant files into directories that are named by
3435 the macros INST_LIB, INST_ARCHLIB, INST_EXE, INST_MAN1DIR, and
3436 INST_MAN3DIR. All these default to ./blib or something below blib if
3437 you are I<not> building below the perl source directory. If you I<are>
3438 building below the perl source, INST_LIB and INST_ARCHLIB default to
3439  ../../lib, and INST_EXE is not defined.
3440
3441 The I<install> target of the generated Makefile is a recursive call to
3442 make which sets
3443
3444     INST_LIB     to INSTALLPRIVLIB
3445     INST_ARCHLIB to INSTALLARCHLIB
3446     INST_EXE     to INSTALLBIN
3447     INST_MAN1DIR to INSTALLMAN1DIR
3448     INST_MAN3DIR to INSTALLMAN3DIR
3449
3450 The INSTALL... macros in turn default to their %Config
3451 ($Config{installprivlib}, $Config{installarchlib}, etc.) counterparts.
3452
3453 The recommended way to proceed is to set only the INSTALL* macros, not
3454 the INST_* targets. In doing so, you give room to the compilation
3455 process without affecting important directories. Usually a make
3456 test will succeed after the make, and a make install can finish
3457 the game.
3458
3459 MakeMaker gives you much more freedom than needed to configure
3460 internal variables and get different results. It is worth to mention,
3461 that make(1) also lets you configure most of the variables that are
3462 used in the Makefile. But in the majority of situations this will not
3463 be necessary, and should only be done, if the author of a package
3464 recommends it.
3465
3466 The usual relationship between INSTALLPRIVLIB and INSTALLARCHLIB is
3467 that the latter is a subdirectory of the former with the name
3468 C<$Config{archname}>, MakeMaker supports the user who sets
3469 INSTALLPRIVLIB. If INSTALLPRIVLIB is set, but INSTALLARCHLIB not, then
3470 MakeMaker defaults the latter to be INSTALLPRIVLIB/ARCHNAME if that
3471 directory exists, otherwise it defaults to INSTALLPRIVLIB.
3472
3473
3474 =head2 PREFIX attribute
3475
3476 The PREFIX attribute can be used to set the INSTALL* attributes in one
3477 go. The quickest way to install a module in a non-standard place
3478
3479     perl Makefile.PL PREFIX=~
3480
3481 This will replace the string specified by $Config{prefix} in all
3482 $Config{install*} values.
3483
3484 Note, that the tilde expansion is done by MakeMaker, not by perl by
3485 default, nor by make.
3486
3487 It is important to know, that the INSTALL* macros should be absolute
3488 paths, never relativ ones. Packages with multiple Makefile.PLs in
3489 different directories get the contents of the INSTALL* macros
3490 propagated verbatim. (The INST_* macros will be corrected, if they are
3491 relativ paths, but not the INSTALL* macros.)
3492
3493 If the user has superuser privileges, and is not working on AFS
3494 (Andrew File System) or relatives, then the defaults for
3495 INSTALLPRIVLIB, INSTALLARCHLIB, INSTALLBIN, etc. will be appropriate,
3496 and this incantation will be the best:
3497
3498     perl Makefile.PL; make; make test
3499     make install
3500
3501 make install per default writes some documentation of what has been
3502 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This is
3503 an experimental feature. It can be bypassed by calling make
3504 pure_install.
3505
3506 =head2 AFS users
3507
3508 will have to specify the installation directories as these most
3509 probably have changed since perl itself has been installed. They will
3510 have to do this by calling
3511
3512     perl Makefile.PL INSTALLPRIVLIB=/afs/here/today \
3513         INSTALLBIN=/afs/there/now INSTALLMAN3DIR=/afs/for/manpages
3514     make
3515
3516 In nested extensions with many subdirectories, the INSTALL* arguments
3517 will get propagated to the subdirectories. Be careful to repeat this
3518 procedure every time you recompile an extension, unless you are sure
3519 the AFS istallation directories are still valid.
3520
3521 =head2 Static Linking of a new Perl Binary
3522
3523 An extension that is built with the above steps is ready to use on
3524 systems supporting dynamic loading. On systems that do not support
3525 dynamic loading, any newly created extension has to be linked together
3526 with the available resources. MakeMaker supports the linking process
3527 by creating appropriate targets in the Makefile whenever an extension
3528 is built. You can invoke the corresponding section of the makefile with
3529
3530     make perl
3531
3532 That produces a new perl binary in the current directory with all
3533 extensions linked in that can be found in INST_ARCHLIB (which usually
3534 is C<./blib>) and PERL_ARCHLIB. To do that, MakeMaker writes a new
3535 Makefile, on UNIX, this is called Makefile.aperl (may be system
3536 dependent). If you want to force the creation of a new perl, it is
3537 recommended, that you delete this Makefile.aperl, so INST_ARCHLIB and
3538 PERL_ARCHLIB are searched-through for linkable libraries again.
3539
3540 The binary can be installed into the directory where perl normally
3541 resides on your machine with
3542
3543     make inst_perl
3544
3545 To produce a perl binary with a different name than C<perl>, either say
3546
3547     perl Makefile.PL MAP_TARGET=myperl
3548     make myperl
3549     make inst_perl
3550
3551 or say
3552
3553     perl Makefile.PL
3554     make myperl MAP_TARGET=myperl
3555     make inst_perl MAP_TARGET=myperl
3556
3557 In any case you will be prompted with the correct invocation of the
3558 C<inst_perl> target that installs the new binary into INSTALLBIN.
3559
3560 Note, that there is a C<makeaperl> scipt in the perl distribution,
3561 that supports the linking of a new perl binary in a similar fashion,
3562 but with more options.
3563
3564 make inst_perl per default writes some documentation of what has been
3565 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This
3566 can be bypassed by calling make pure_inst_perl.
3567
3568 Warning: the inst_perl: target is rather mighty and will probably
3569 overwrite your existing perl binary. Use with care!
3570
3571 Sometimes you might want to build a statically linked perl although
3572 your system supports dynamic loading. In this case you may explicitly
3573 set the linktype with the invocation of the Makefile.PL or make:
3574
3575     perl Makefile.PL LINKTYPE=static    # recommended
3576
3577 or
3578
3579     make LINKTYPE=static                # works on most systems
3580
3581 =head2 Determination of Perl Library and Installation Locations
3582
3583 MakeMaker needs to know, or to guess, where certain things are
3584 located.  Especially INST_LIB and INST_ARCHLIB (where to install files
3585 into), PERL_LIB and PERL_ARCHLIB (where to read existing modules
3586 from), and PERL_INC (header files and C<libperl*.*>).
3587
3588 Extensions may be built either using the contents of the perl source
3589 directory tree or from an installed copy of the perl library. The
3590 recommended way is to build extensions after you have run 'make
3591 install' on perl itself. Do that in a directory that is not below the
3592 perl source tree. The support for extensions below the ext directory
3593 of the perl distribution is only good for the standard extensions that
3594 come with perl.
3595
3596 If an extension is being built below the C<ext/> directory of the perl
3597 source then MakeMaker will set PERL_SRC automatically (e.g., C<../..>).
3598 If PERL_SRC is defined then other variables default to the following:
3599
3600   PERL_INC     = PERL_SRC
3601   PERL_LIB     = PERL_SRC/lib
3602   PERL_ARCHLIB = PERL_SRC/lib
3603   INST_LIB     = PERL_LIB
3604   INST_ARCHLIB = PERL_ARCHLIB
3605
3606 If an extension is being built away from the perl source then MakeMaker
3607 will leave PERL_SRC undefined and default to using the installed copy
3608 of the perl library. The other variables default to the following:
3609
3610   PERL_INC     = $archlib/CORE
3611   PERL_LIB     = $privlib
3612   PERL_ARCHLIB = $archlib
3613   INST_LIB     = ./blib
3614   INST_ARCHLIB = ./blib/<archname>
3615
3616 If perl has not yet been installed then PERL_SRC can be defined on the
3617 command line as shown in the previous section.
3618
3619 =head2 Useful Default Makefile Macros
3620
3621 FULLEXT = Pathname for extension directory (eg DBD/Oracle).
3622
3623 BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
3624
3625 ROOTEXT = Directory part of FULLEXT with leading slash (eg /DBD)
3626
3627 INST_LIBDIR = C<$(INST_LIB)$(ROOTEXT)>
3628
3629 INST_AUTODIR = C<$(INST_LIB)/auto/$(FULLEXT)>
3630
3631 INST_ARCHAUTODIR = C<$(INST_ARCHLIB)/auto/$(FULLEXT)>
3632
3633 =head2 Using Attributes (and Parameters)
3634
3635 The following attributes can be specified as arguments to WriteMakefile()
3636 or as NAME=VALUE pairs on the command line:
3637
3638 =cut
3639
3640 # The following "=item C" is used by the attrib_help routine
3641 # likewise the "=back" below. So be careful when changing it!
3642
3643 =over 2
3644
3645 =item C
3646
3647 Ref to array of *.c file names. Initialised from a directory scan
3648 and the values portion of the XS attribute hash. This is not
3649 currently used by MakeMaker but may be handy in Makefile.PLs.
3650
3651 =item CONFIG
3652
3653 Arrayref. E.g. [qw(archname manext)] defines ARCHNAME & MANEXT from
3654 config.sh. MakeMaker will add to CONFIG the following values anyway:
3655 ar
3656 cc
3657 cccdlflags
3658 ccdlflags
3659 dlext
3660 dlsrc
3661 ld
3662 lddlflags
3663 ldflags
3664 libc
3665 lib_ext
3666 obj_ext
3667 ranlib
3668 so
3669
3670 =item CONFIGURE
3671
3672 CODE reference. Extension writers are requested to do all their
3673 initializing within that subroutine. The subroutine
3674 should return a hash reference. The hash may contain
3675 further attributes, e.g. {LIBS => ...}, that have to
3676 be determined by some evaluation method.
3677
3678 =item DEFINE
3679
3680 Something like C<"-DHAVE_UNISTD_H">
3681
3682 =item DIR
3683
3684 Ref to array of subdirectories containing Makefile.PLs e.g. [ 'sdbm'
3685 ] in ext/SDBM_File
3686
3687 =item DISTNAME
3688
3689 Your name for distributing the package (by tar file) This defaults to
3690 NAME above.
3691
3692 =item DL_FUNCS
3693
3694 Hashref of symbol names for routines to be made available as
3695 universal symbols.  Each key/value pair consists of the package name
3696 and an array of routine names in that package.  Used only under AIX
3697 (export lists) and VMS (linker options) at present.  The routine
3698 names supplied will be expanded in the same way as XSUB names are
3699 expanded by the XS() macro.  Defaults to
3700
3701   {"$(NAME)" => ["boot_$(NAME)" ] }
3702
3703 e.g.
3704
3705   {"RPC" => [qw( boot_rpcb rpcb_gettime getnetconfigent )],
3706    "NetconfigPtr" => [ 'DESTROY'] }
3707
3708 =item DL_VARS
3709
3710 Array of symbol names for variables to be made available as
3711 universal symbols.  Used only under AIX (export lists) and VMS
3712 (linker options) at present.  Defaults to [].  (e.g. [ qw(
3713 Foo_version Foo_numstreams Foo_tree ) ])
3714
3715 =item EXE_FILES
3716
3717 Ref to array of executable files. The files will be copied to the
3718 INST_EXE directory. Make realclean will delete them from there
3719 again.
3720
3721 =item FIRST_MAKEFILE
3722
3723 The name of the Makefile to be produced. Defaults to the contents of
3724 MAKEFILE, but can be overridden. This is used for the second Makefile
3725 that will be produced for the MAP_TARGET.
3726
3727 =item FULLPERL
3728
3729 Perl binary able to run this extension.
3730
3731 =item H
3732
3733 Ref to array of *.h file names. Similar to C.
3734
3735 =item INC
3736
3737 Include file dirs eg: C<"-I/usr/5include -I/path/to/inc">
3738
3739 =item INSTALLARCHLIB
3740
3741 Used by 'make install', which sets INST_ARCHLIB to this value.
3742
3743 =item INSTALLBIN
3744
3745 Used by 'make install' which sets INST_EXE to this value.
3746
3747 =item INSTALLMAN1DIR
3748
3749 This directory gets the man pages at 'make install' time. Defaults to
3750 $Config{installman1dir}.
3751
3752 =item INSTALLMAN3DIR
3753
3754 This directory gets the man pages at 'make install' time. Defaults to
3755 $Config{installman3dir}.
3756
3757 =item INSTALLPRIVLIB
3758
3759 Used by 'make install', which sets INST_LIB to this value.
3760
3761 =item INST_ARCHLIB
3762
3763 Same as INST_LIB for architecture dependent files.
3764
3765 =item INST_EXE
3766
3767 Directory, where executable scripts should be installed during
3768 'make'. Defaults to "./blib/ARCHNAME", just to have a dummy
3769 location during testing. make install will set
3770 INST_EXE to INSTALLBIN.
3771
3772 =item INST_LIB
3773
3774 Directory where we put library files of this extension while building
3775 it.
3776
3777 =item INST_MAN1DIR
3778
3779 Directory to hold the man pages at 'make' time
3780
3781 =item INST_MAN3DIR
3782
3783 Directory to hold the man pages at 'make' time
3784
3785 =item LDFROM
3786
3787 defaults to "$(OBJECT)" and is used in the ld command to specify
3788 what files to link/load from (also see dynamic_lib below for how to
3789 specify ld flags)
3790
3791 =item LIBPERL_A
3792
3793 The filename of the perllibrary that will be used together with this
3794 extension. Defaults to libperl.a.
3795
3796 =item LIBS
3797
3798 An anonymous array of alternative library
3799 specifications to be searched for (in order) until
3800 at least one library is found. E.g.
3801
3802   'LIBS' => ["-lgdbm", "-ldbm -lfoo", "-L/path -ldbm.nfs"]
3803
3804 Mind, that any element of the array
3805 contains a complete set of arguments for the ld
3806 command. So do not specify
3807
3808   'LIBS' => ["-ltcl", "-ltk", "-lX11"]
3809
3810 See ODBM_File/Makefile.PL for an example, where an array is needed. If
3811 you specify a scalar as in
3812
3813   'LIBS' => "-ltcl -ltk -lX11"
3814
3815 MakeMaker will turn it into an array with one element.
3816
3817 =item LINKTYPE
3818
3819 'static' or 'dynamic' (default unless usedl=undef in config.sh) Should
3820 only be used to force static linking (also see
3821 linkext below).
3822
3823 =item MAKEAPERL
3824
3825 Boolean which tells MakeMaker, that it should include the rules to
3826 make a perl. This is handled automatically as a switch by
3827 MakeMaker. The user normally does not need it.
3828
3829 =item MAKEFILE
3830
3831 The name of the Makefile to be produced.
3832
3833 =item MAN1PODS
3834
3835 Hashref of pod-containing files. MakeMaker will default this to all
3836 EXE_FILES files that include POD directives. The files listed
3837 here will be converted to man pages and installed as was requested
3838 at Configure time.
3839
3840 =item MAN3PODS
3841
3842 Hashref of .pm and .pod files. MakeMaker will default this to all
3843  .pod and any .pm files that include POD directives. The files listed
3844 here will be converted to man pages and installed as was requested
3845 at Configure time.
3846
3847 =item MAP_TARGET
3848
3849 If it is intended, that a new perl binary be produced, this variable
3850 may hold a name for that binary. Defaults to perl
3851
3852 =item MYEXTLIB
3853
3854 If the extension links to a library that it builds set this to the
3855 name of the library (see SDBM_File)
3856
3857 =item NAME
3858
3859 Perl module name for this extension (DBD::Oracle). This will default
3860 to the directory name but should be explicitly defined in the
3861 Makefile.PL.
3862
3863 =item NEEDS_LINKING
3864
3865 MakeMaker will figure out, if an extension contains linkable code
3866 anywhere down the directory tree, and will set this variable
3867 accordingly, but you can speed it up a very little bit, if you define
3868 this boolean variable yourself.
3869
3870 =item NORECURS
3871
3872 Boolean. Experimental attribute to inhibit descending into
3873 subdirectories.
3874
3875 =item OBJECT
3876
3877 List of object files, defaults to '$(BASEEXT)$(OBJ_EXT)', but can be a long
3878 string containing all object files, e.g. "tkpBind.o
3879 tkpButton.o tkpCanvas.o"
3880
3881 =item PERL
3882
3883 Perl binary for tasks that can be done by miniperl
3884
3885 =item PERLMAINCC
3886
3887 The call to the program that is able to compile perlmain.c. Defaults
3888 to $(CC).
3889
3890 =item PERL_ARCHLIB
3891
3892 Same as above for architecture dependent files
3893
3894 =item PERL_LIB
3895
3896 Directory containing the Perl library to use.
3897
3898 =item PERL_SRC
3899
3900 Directory containing the Perl source code (use of this should be
3901 avoided, it may be undefined)
3902
3903 =item PL_FILES
3904
3905 Ref to hash of files to be processed as perl programs. MakeMaker
3906 will default to any found *.PL file (except Makefile.PL) being keys
3907 and the basename of the file being the value. E.g.
3908
3909   {'foobar.PL' => 'foobar'}
3910
3911 The *.PL files are expected to produce output to the target files
3912 themselves.
3913
3914 =item PM
3915
3916 Hashref of .pm files and *.pl files to be installed.  e.g.
3917
3918   {'name_of_file.pm' => '$(INST_LIBDIR)/install_as.pm'}
3919
3920 By default this will include *.pm and *.pl. If a lib directory
3921 exists and is not listed in DIR (above) then any *.pm and *.pl files
3922 it contains will also be included by default.  Defining PM in the
3923 Makefile.PL will override PMLIBDIRS.
3924
3925 =item PMLIBDIRS
3926
3927 Ref to array of subdirectories containing library files.  Defaults to
3928 [ 'lib', $(BASEEXT) ]. The directories will be scanned and any files
3929 they contain will be installed in the corresponding location in the
3930 library.  A libscan() method can be used to alter the behaviour.
3931 Defining PM in the Makefile.PL will override PMLIBDIRS.
3932
3933 =item PREFIX
3934
3935 Can be used to set the three INSTALL* attributes in one go (except for
3936 INSTALLMAN1DIR).  They will have PREFIX as a common directory node and
3937 will branch from that node into lib/, lib/ARCHNAME, and bin/ unless
3938 you override one of them.
3939
3940 =item PREREQ
3941
3942 Placeholder, not yet implemented. Will eventually be a hashref: Names
3943 of modules that need to be available to run this extension (e.g. Fcntl
3944 for SDBM_File) are the keys of the hash and the desired version is the
3945 value. Needs further evaluation, should probably allow to define
3946 prerequisites among header files, libraries, perl version, etc.
3947
3948 =item SKIP
3949
3950 Arryref. E.g. [qw(name1 name2)] skip (do not write) sections of the
3951 Makefile
3952
3953 =item TYPEMAPS
3954
3955 Ref to array of typemap file names.  Use this when the typemaps are
3956 in some directory other than the current directory or when they are
3957 not named B<typemap>.  The last typemap in the list takes
3958 precedence.  A typemap in the current directory has highest
3959 precedence, even if it isn't listed in TYPEMAPS.  The default system
3960 typemap has lowest precedence.
3961
3962 =item VERSION
3963
3964 Your version number for distributing the package.  This defaults to
3965 0.1.
3966
3967 =item VERSION_FROM
3968
3969 Instead of specifying the VERSION in the Makefile.PL you can let
3970 MakeMaker parse a file to determine the version number. The parsing
3971 routine requires that the file named by VERSION_FROM contains one
3972 single line to compute the version number. The first line in the file
3973 that contains the regular expression
3974
3975     /(\$[\w:]*\bVERSION)\b.*=/
3976
3977 will be evaluated with eval() and the value of the named variable
3978 B<after> the eval() will be assigned to the VERSION attribute of the
3979 MakeMaker object. The following lines will be parsed o.k.:
3980
3981     $VERSION = '1.00';
3982     ( $VERSION ) = '$Revision: 1.135 $ ' =~ /\$Revision:\s+([^\s]+)/;
3983     $FOO::VERSION = '1.10';
3984
3985 but these will fail:
3986
3987     my $VERSION = '1.01';
3988     local $VERSION = '1.02';
3989     local $FOO::VERSION = '1.30';
3990
3991 The file named in VERSION_FROM is added as a dependency to Makefile to
3992 guarantee, that the Makefile contains the correct VERSION macro after
3993 a change of the file.
3994
3995 =item XS
3996
3997 Hashref of .xs files. MakeMaker will default this.  e.g.
3998
3999   {'name_of_file.xs' => 'name_of_file.c'}
4000
4001 The .c files will automatically be included in the list of files
4002 deleted by a make clean.
4003
4004 =item XSOPT
4005
4006 String of options to pass to xsubpp.  This might include C<-C++> or
4007 C<-extern>.  Do not include typemaps here; the TYPEMAP parameter exists for
4008 that purpose.
4009
4010 =item XSPROTOARG
4011
4012 May be set to an empty string, which is identical to C<-prototypes>, or
4013 C<-noprototypes>. See the xsubpp documentation for details. MakeMaker
4014 defaults to the empty string.
4015
4016 =item XS_VERSION
4017
4018 Your version number for the .xs file of this package.  This defaults
4019 to the value of the VERSION attribute.
4020
4021 =back
4022
4023 =head2 Additional lowercase attributes
4024
4025 can be used to pass parameters to the methods which implement that
4026 part of the Makefile. These are not normally required:
4027
4028 =over 2
4029
4030 =item clean
4031
4032   {FILES => "*.xyz foo"}
4033
4034 =item dist
4035
4036   {TARFLAGS => 'cvfF', COMPRESS => 'gzip', SUFFIX => 'gz',
4037   SHAR => 'shar -m', DIST_CP => 'ln'}
4038
4039 If you specify COMPRESS, then SUFFIX should also be altered, as it is
4040 needed to tell make the target file of the compression. Setting
4041 DIST_CP to ln can be useful, if you need to preserve the timestamps on
4042 your files. DIST_CP can take the values 'cp', which copies the file,
4043 'ln', which links the file, and 'best' which copies symbolic links and
4044 links the rest. Default is 'best'.
4045
4046 =item dynamic_lib
4047
4048   {ARMAYBE => 'ar', OTHERLDFLAGS => '...', INST_DYNAMIC_DEP => '...'}
4049
4050 =item installpm
4051
4052   {SPLITLIB => '$(INST_LIB)' (default) or '$(INST_ARCHLIB)'}
4053
4054 =item linkext
4055
4056   {LINKTYPE => 'static', 'dynamic' or ''}
4057
4058 NB: Extensions that have nothing but *.pm files had to say
4059
4060   {LINKTYPE => ''}
4061
4062 with Pre-5.0 MakeMakers. Since version 5.00 of MakeMaker such a line
4063 can be deleted safely. MakeMaker recognizes, when there's nothing to
4064 be linked.
4065
4066 =item macro
4067
4068   {ANY_MACRO => ANY_VALUE, ...}
4069
4070 =item realclean
4071
4072   {FILES => '$(INST_ARCHAUTODIR)/*.xyz'}
4073
4074 =item tool_autosplit
4075
4076   {MAXLEN =E<gt> 8}
4077
4078 =back
4079
4080 =cut
4081
4082 # bug in pod2html, so leave the =back
4083
4084 # Don't delete this cut, MM depends on it!
4085
4086 =head2 Overriding MakeMaker Methods
4087
4088 If you cannot achieve the desired Makefile behaviour by specifying
4089 attributes you may define private subroutines in the Makefile.PL.
4090 Each subroutines returns the text it wishes to have written to
4091 the Makefile. To override a section of the Makefile you can
4092 either say:
4093
4094         sub MY::c_o { "new literal text" }
4095
4096 or you can edit the default by saying something like:
4097
4098         sub MY::c_o {
4099             my $self = shift;
4100             local *c_o;
4101             $_=$self->MM::c_o;
4102             s/old text/new text/;
4103             $_;
4104         }
4105
4106 Both methods above are available for backwards compatibility with
4107 older Makefile.PLs.
4108
4109 If you still need a different solution, try to develop another
4110 subroutine, that fits your needs and submit the diffs to
4111 F<perl5-porters@nicoh.com> or F<comp.lang.perl.misc> as appropriate.
4112
4113 =head2 Distribution Support
4114
4115 For authors of extensions MakeMaker provides several Makefile
4116 targets. Most of the support comes from the ExtUtils::Manifest module,
4117 where additional documentation can be found.
4118
4119 =over 4
4120
4121 =item    make distcheck
4122
4123 reports which files are below the build directory but not in the
4124 MANIFEST file and vice versa. (See ExtUtils::Manifest::fullcheck() for
4125 details)
4126
4127 =item    make skipcheck
4128
4129 reports which files are skipped due to the entries in the
4130 C<MANIFEST.SKIP> file (See ExtUtils::Manifest::skipcheck() for
4131 details)
4132
4133 =item    make distclean
4134
4135 does a realclean first and then the distcheck. Note that this is not
4136 needed to build a new distribution as long as you are sure, that the
4137 MANIFEST file is ok.
4138
4139 =item    make manifest
4140
4141 rewrites the MANIFEST file, adding all remaining files found (See
4142 ExtUtils::Manifest::mkmanifest() for details)
4143
4144 =item    make distdir
4145
4146 Copies all the files that are in the MANIFEST file to a newly created
4147 directory with the name C<$(DISTNAME)-$(VERSION)>. If that directory
4148 exists, it will be removed first.
4149
4150 =item   make disttest
4151
4152 Makes a distdir first, and runs a C<perl Makefile.PL>, a make, and
4153 a make test in that directory.
4154
4155 =item    make tardist
4156
4157 First does a command $(PREOP) which defaults to a null command. Does a
4158 distdir next and runs C<tar> on that directory into a tarfile. Then
4159 deletes the distdir. Finishes with a command $(POSTOP) which defaults
4160 to a null command.
4161
4162 =item    make dist
4163
4164 Defaults to $(DIST_DEFAULT) which in turn defaults to tardist.
4165
4166 =item    make uutardist
4167
4168 Runs a tardist first and uuencodes the tarfile.
4169
4170 =item    make shdist
4171
4172 First does a command $(PREOP) which defaults to a null command. Does a
4173 distdir next and runs C<shar> on that directory into a sharfile. Then
4174 deletes the distdir. Finishes with a command $(POSTOP) which defaults
4175 to a null command.  Note: For shdist to work properly a C<shar>
4176 program that can handle directories is mandatory.
4177
4178 =item    make ci
4179
4180 Does a $(CI) and a $(RCS_LABEL) on all files in the MANIFEST file.
4181
4182 =back
4183
4184 Customization of the dist targets can be done by specifying a hash
4185 reference to the dist attribute of the WriteMakefile call. The
4186 following parameters are recognized:
4187
4188     CI           ('ci -u')
4189     COMPRESS     ('compress')
4190     POSTOP       ('@ :')
4191     PREOP        ('@ :')
4192     RCS_LABEL    ('rcs -q -Nv$(VERSION_SYM):')
4193     SHAR         ('shar')
4194     SUFFIX       ('Z')
4195     TAR          ('tar')
4196     TARFLAGS     ('cvf')
4197
4198 An example:
4199
4200     WriteMakefile( 'dist' => { COMPRESS=>"gzip", SUFFIX=>"gz" })
4201
4202
4203 =head1 AUTHORS 
4204
4205 Andy Dougherty F<E<lt>doughera@lafcol.lafayette.eduE<gt>>, Andreas
4206 KE<ouml>nig F<E<lt>A.Koenig@franz.ww.TU-Berlin.DEE<gt>>, Tim Bunce
4207 F<E<lt>Tim.Bunce@ig.co.ukE<gt>>.  VMS support by Charles Bailey
4208 F<E<lt>bailey@HMIVAX.HUMGEN.UPENN.EDUE<gt>>. Contact the makemaker
4209 mailing list C<mailto:makemaker@franz.ww.tu-berlin.de>, if you have any
4210 questions.
4211
4212 =head1 MODIFICATION HISTORY
4213
4214 For a more complete documentation see the file Changes in the
4215 MakeMaker distribution package.
4216
4217 =head1 TODO
4218
4219 See the file Todo in the MakeMaker distribution package.
4220
4221 =cut