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