lib/ExtUtils/MM_Unix.pm

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