[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/se3-unattended/var/se3/unattended/install/linuxaux/opt/perl/lib/5.10.0/ExtUtils/ -> MM_Unix.pm (source)

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


Generated: Tue Mar 17 22:47:18 2015 Cross-referenced by PHPXref 0.7.1