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