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