lib/ExtUtils/MM_Unix.pm

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