lib/ExtUtils/MM_Unix.pm

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