lib/ExtUtils/MM_Unix.pm

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