lib/ExtUtils/MM_Unix.pm

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