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