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
  16             $Verbose %pm %static $Xsubpp_Version
  17             %Config_Override
  18            );
  19
  20 use ExtUtils::MakeMaker qw($Verbose neatvalue);
  21
  22 $VERSION = '1.33';
  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) $(PASTHRU)
 865         cd $(DISTVNAME) && $(MAKE) test $(PASTHRU)
 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 = '$(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     if ($Is_VMS) {
1353       # avoid logical name collisions by adding directory syntax
1354       $self->{PMLIBDIRS} = ['./lib', './' . $self->{BASEEXT}]
1355         unless $self->{PMLIBDIRS};
1356     }
1357     else {
1358       $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]
1359        unless $self->{PMLIBDIRS};
1360     }
1361
1362     #only existing directories that aren't in $dir are allowed
1363
1364     # Avoid $_ wherever possible:
1365     # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}};
1366     my (@pmlibdirs) = @{$self->{PMLIBDIRS}};
1367     my ($pmlibdir);
1368     @{$self->{PMLIBDIRS}} = ();
1369     foreach $pmlibdir (@pmlibdirs) {
1370         -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir;
1371     }
1372
1373     if (@{$self->{PMLIBDIRS}}){
1374         print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n"
1375             if ($Verbose >= 2);
1376         require File::Find;
1377         File::Find::find(sub {
1378             if (-d $_){
1379                 if ($_ eq "CVS" || $_ eq "RCS"){
1380                     $File::Find::prune = 1;
1381                 }
1382                 return;
1383             }
1384             return if /\#/;
1385             return if /~$/;    # emacs temp files
1386
1387             my $path   = $File::Find::name;
1388             my $prefix = $self->{INST_LIBDIR};
1389             my $striplibpath;
1390
1391             $prefix =  $self->{INST_LIB}
1392                 if ($striplibpath = $path) =~ s:^(\W*)lib\W:$1:i;
1393
1394             my($inst) = File::Spec->catfile($prefix,$striplibpath);
1395             local($_) = $inst; # for backwards compatibility
1396             $inst = $self->libscan($inst);
1397             print "libscan($path) => '$inst'\n" if ($Verbose >= 2);
1398             return unless $inst;
1399             $pm{$path} = $inst;
1400         }, @{$self->{PMLIBDIRS}});
1401     }
1402
1403     $self->{DIR} = [sort keys %dir] unless $self->{DIR};
1404     $self->{XS}  = \%xs             unless $self->{XS};
1405     $self->{PM}  = \%pm             unless $self->{PM};
1406     $self->{C}   = [sort keys %c]   unless $self->{C};
1407     my(@o_files) = @{$self->{C}};
1408     $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files] ;
1409     $self->{H}   = [sort keys %h]   unless $self->{H};
1410     $self->{PL_FILES} = \%pl_files unless $self->{PL_FILES};
1411
1412     # Set up names of manual pages to generate from pods
1413     my %pods;
1414     foreach my $man (qw(MAN1 MAN3)) {
1415         unless ($self->{"${man}PODS"}) {
1416             $self->{"${man}PODS"} = {};
1417             $pods{$man} = 1 unless
1418               $self->{"INSTALL${man}DIR"} =~ /^(none|\s*)$/;
1419         }
1420     }
1421
1422     if ($pods{MAN1}) {
1423         if ( exists $self->{EXE_FILES} ) {
1424             foreach $name (@{$self->{EXE_FILES}}) {
1425                 local *FH;
1426                 my($ispod)=0;
1427                 if (open(FH,"<$name")) {
1428                     while (<FH>) {
1429                         if (/^=\w/) {
1430                             $ispod=1;
1431                             last;
1432                         }
1433                     }
1434                     close FH;
1435                 } else {
1436                     # If it doesn't exist yet, we assume, it has pods in it
1437                     $ispod = 1;
1438                 }
1439                 next unless $ispod;
1440                 if ($pods{MAN1}) {
1441                     $self->{MAN1PODS}->{$name} =
1442                       File::Spec->catfile("\$(INST_MAN1DIR)", basename($name).".\$(MAN1EXT)");
1443                 }
1444             }
1445         }
1446     }
1447     if ($pods{MAN3}) {
1448         my %manifypods = (); # we collect the keys first, i.e. the files
1449                              # we have to convert to pod
1450         foreach $name (keys %{$self->{PM}}) {
1451             if ($name =~ /\.pod\z/ ) {
1452                 $manifypods{$name} = $self->{PM}{$name};
1453             } elsif ($name =~ /\.p[ml]\z/ ) {
1454                 local *FH;
1455                 my($ispod)=0;
1456                 if (open(FH,"<$name")) {
1457                     while (<FH>) {
1458                         if (/^=\w/) {
1459                             $ispod=1;
1460                             last;
1461                         }
1462                     }
1463                     close FH;
1464                 } else {
1465                     $ispod = 1;
1466                 }
1467                 if( $ispod ) {
1468                     $manifypods{$name} = $self->{PM}{$name};
1469                 }
1470             }
1471         }
1472
1473         # Remove "Configure.pm" and similar, if it's not the only pod listed
1474         # To force inclusion, just name it "Configure.pod", or override
1475         # MAN3PODS
1476         foreach $name (keys %manifypods) {
1477            if ($self->{PERL_CORE} and $name =~ /(config|setup).*\.pm/is) {
1478                 delete $manifypods{$name};
1479                 next;
1480             }
1481             my($manpagename) = $name;
1482             $manpagename =~ s/\.p(od|m|l)\z//;
1483             unless ($manpagename =~ s!^\W*lib\W+!!s) { # everything below lib is ok
1484                 $manpagename = File::Spec->catfile(split(/::/,$self->{PARENT_NAME}),$manpagename);
1485             }
1486             if ($pods{MAN3}) {
1487                 $manpagename = $self->replace_manpage_separator($manpagename);
1488                 $self->{MAN3PODS}->{$name} =
1489                   File::Spec->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)");
1490             }
1491         }
1492     }
1493 }
1494
1495 =item init_main
1496
1497 Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE,
1498 EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*,
1499 INSTALL*, INSTALLDIRS, LD, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME,
1500 OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB,
1501 PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION,
1502 VERSION_FROM, VERSION_SYM, XS_VERSION.
1503
1504 =cut
1505
1506 sub init_main {
1507     my($self) = @_;
1508
1509     # --- Initialize Module Name and Paths
1510
1511     # NAME    = Foo::Bar::Oracle
1512     # FULLEXT = Foo/Bar/Oracle
1513     # BASEEXT = Oracle
1514     # PARENT_NAME = Foo::Bar
1515 ### Only UNIX:
1516 ###    ($self->{FULLEXT} =
1517 ###     $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket
1518     $self->{FULLEXT} = File::Spec->catdir(split /::/, $self->{NAME});
1519
1520
1521     # Copied from DynaLoader:
1522
1523     my(@modparts) = split(/::/,$self->{NAME});
1524     my($modfname) = $modparts[-1];
1525
1526     # Some systems have restrictions on files names for DLL's etc.
1527     # mod2fname returns appropriate file base name (typically truncated)
1528     # It may also edit @modparts if required.
1529     if (defined &DynaLoader::mod2fname) {
1530         $modfname = &DynaLoader::mod2fname(\@modparts);
1531     }
1532
1533     ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ;
1534     $self->{PARENT_NAME} ||= '';
1535
1536     if (defined &DynaLoader::mod2fname) {
1537         # As of 5.001m, dl_os2 appends '_'
1538         $self->{DLBASE} = $modfname;
1539     } else {
1540         $self->{DLBASE} = '$(BASEEXT)';
1541     }
1542
1543
1544     # --- Initialize PERL_LIB, PERL_SRC
1545
1546     # *Real* information: where did we get these two from? ...
1547     my $inc_config_dir = dirname($INC{'Config.pm'});
1548     my $inc_carp_dir   = dirname($INC{'Carp.pm'});
1549
1550     unless ($self->{PERL_SRC}){
1551         my($dir);
1552         foreach $dir ($Updir,
1553                       File::Spec->catdir($Updir,$Updir),
1554                       File::Spec->catdir($Updir,$Updir,$Updir),
1555                       File::Spec->catdir($Updir,$Updir,$Updir,$Updir),
1556                       File::Spec->catdir($Updir,$Updir,$Updir,$Updir,$Updir))
1557         {
1558             if (
1559                 -f File::Spec->catfile($dir,"config_h.SH")
1560                 &&
1561                 -f File::Spec->catfile($dir,"perl.h")
1562                 &&
1563                 -f File::Spec->catfile($dir,"lib","Exporter.pm")
1564                ) {
1565                 $self->{PERL_SRC}=$dir ;
1566                 last;
1567             }
1568         }
1569     }
1570
1571     warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if
1572       $self->{PERL_CORE} and !$self->{PERL_SRC};
1573
1574     if ($self->{PERL_SRC}){
1575         $self->{PERL_LIB}     ||= File::Spec->catdir("$self->{PERL_SRC}","lib");
1576
1577         if (defined $Cross::platform) {
1578             $self->{PERL_ARCHLIB} =
1579               File::Spec->catdir("$self->{PERL_SRC}","xlib",$Cross::platform);
1580             $self->{PERL_INC}     =
1581               File::Spec->catdir("$self->{PERL_SRC}","xlib",$Cross::platform,
1582                                  $Is_Win32?("CORE"):());
1583         }
1584         else {
1585             $self->{PERL_ARCHLIB} = $self->{PERL_LIB};
1586             $self->{PERL_INC}     = ($Is_Win32) ?
1587               File::Spec->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC};
1588         }
1589
1590         # catch a situation that has occurred a few times in the past:
1591         unless (
1592                 -s File::Spec->catfile($self->{PERL_SRC},'cflags')
1593                 or
1594                 $Is_VMS
1595                 &&
1596                 -s File::Spec->catfile($self->{PERL_SRC},'perlshr_attr.opt')
1597                 or
1598                 $Is_Mac
1599                 or
1600                 $Is_Win32
1601                ){
1602             warn qq{
1603 You cannot build extensions below the perl source tree after executing
1604 a 'make clean' in the perl source tree.
1605
1606 To rebuild extensions distributed with the perl source you should
1607 simply Configure (to include those extensions) and then build perl as
1608 normal. After installing perl the source tree can be deleted. It is
1609 not needed for building extensions by running 'perl Makefile.PL'
1610 usually without extra arguments.
1611
1612 It is recommended that you unpack and build additional extensions away
1613 from the perl source tree.
1614 };
1615         }
1616     } else {
1617         # we should also consider $ENV{PERL5LIB} here
1618         my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC};
1619         $self->{PERL_LIB}     ||= $Config{privlibexp};
1620         $self->{PERL_ARCHLIB} ||= $Config{archlibexp};
1621         $self->{PERL_INC}     = File::Spec->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now
1622         my $perl_h;
1623
1624         if (not -f ($perl_h = File::Spec->catfile($self->{PERL_INC},"perl.h"))
1625             and not $old){
1626             # Maybe somebody tries to build an extension with an
1627             # uninstalled Perl outside of Perl build tree
1628             my $found;
1629             for my $dir (@INC) {
1630               $found = $dir, last if -e File::Spec->catdir($dir, "Config.pm");
1631             }
1632             if ($found) {
1633               my $inc = dirname $found;
1634               if (-e File::Spec->catdir($inc, "perl.h")) {
1635                 $self->{PERL_LIB}          = $found;
1636                 $self->{PERL_ARCHLIB}      = $found;
1637                 $self->{PERL_INC}          = $inc;
1638                 $self->{UNINSTALLED_PERL}  = 1;
1639                 print STDOUT <<EOP;
1640 ... Detected uninstalled Perl.  Trying to continue.
1641 EOP
1642               }
1643             }
1644         }
1645
1646         unless(-f ($perl_h = File::Spec->catfile($self->{PERL_INC},"perl.h")))
1647         {
1648             die qq{
1649 Error: Unable to locate installed Perl libraries or Perl source code.
1650
1651 It is recommended that you install perl in a standard location before
1652 building extensions. Some precompiled versions of perl do not contain
1653 these header files, so you cannot build extensions. In such a case,
1654 please build and install your perl from a fresh perl distribution. It
1655 usually solves this kind of problem.
1656
1657 \(You get this message, because MakeMaker could not find "$perl_h"\)
1658 };
1659         }
1660 #        print STDOUT "Using header files found in $self->{PERL_INC}\n"
1661 #            if $Verbose && $self->needs_linking();
1662
1663     }
1664
1665     # We get SITELIBEXP and SITEARCHEXP directly via
1666     # Get_from_Config. When we are running standard modules, these
1667     # won't matter, we will set INSTALLDIRS to "perl". Otherwise we
1668     # set it to "site". I prefer that INSTALLDIRS be set from outside
1669     # MakeMaker.
1670     $self->{INSTALLDIRS} ||= "site";
1671
1672
1673     $self->init_INST;
1674     $self->init_INSTALL;
1675
1676     $self->{MAN1EXT} ||= $Config{man1ext};
1677     $self->{MAN3EXT} ||= $Config{man3ext};
1678
1679     # Get some stuff out of %Config if we haven't yet done so
1680     print STDOUT "CONFIG must be an array ref\n"
1681         if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY');
1682     $self->{CONFIG} = [] unless (ref $self->{CONFIG});
1683     push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config);
1684     push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags};
1685     my(%once_only,$m);
1686     foreach $m (@{$self->{CONFIG}}){
1687         next if $once_only{$m};
1688         print STDOUT "CONFIG key '$m' does not exist in Config.pm\n"
1689                 unless exists $Config{$m};
1690         $self->{uc $m} ||= $Config{$m};
1691         $once_only{$m} = 1;
1692     }
1693
1694 # This is too dangerous:
1695 #    if ($^O eq "next") {
1696 #       $self->{AR} = "libtool";
1697 #       $self->{AR_STATIC_ARGS} = "-o";
1698 #    }
1699 # But I leave it as a placeholder
1700
1701     $self->{AR_STATIC_ARGS} ||= "cr";
1702
1703     # These should never be needed
1704     $self->{LD} ||= 'ld';
1705     $self->{OBJ_EXT} ||= '.o';
1706     $self->{LIB_EXT} ||= '.a';
1707
1708     $self->{MAP_TARGET} ||= "perl";
1709
1710     $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}";
1711
1712     # make a simple check if we find Exporter
1713     warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory
1714         (Exporter.pm not found)"
1715         unless -f File::Spec->catfile("$self->{PERL_LIB}","Exporter.pm") ||
1716         $self->{NAME} eq "ExtUtils::MakeMaker";
1717
1718     # Determine VERSION and VERSION_FROM
1719     ($self->{DISTNAME}=$self->{NAME}) =~ s#(::)#-#g unless $self->{DISTNAME};
1720     if ($self->{VERSION_FROM}){
1721         $self->{VERSION} = $self->parse_version($self->{VERSION_FROM});
1722         if( $self->{VERSION} eq 'undef' ) {
1723             carp "WARNING: Setting VERSION via file ".
1724                  "'$self->{VERSION_FROM}' failed\n";
1725         }
1726     }
1727
1728     # strip blanks
1729     if (defined $self->{VERSION}) {
1730         $self->{VERSION} =~ s/^\s+//;
1731         $self->{VERSION} =~ s/\s+$//;
1732     }
1733     else {
1734         $self->{VERSION} = '';
1735     }
1736     ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g;
1737
1738     $self->{DISTVNAME} = "$self->{DISTNAME}-$self->{VERSION}";
1739
1740     # Graham Barr and Paul Marquess had some ideas how to ensure
1741     # version compatibility between the *.pm file and the
1742     # corresponding *.xs file. The bottomline was, that we need an
1743     # XS_VERSION macro that defaults to VERSION:
1744     $self->{XS_VERSION} ||= $self->{VERSION};
1745
1746
1747     # --- Initialize Perl Binary Locations
1748     $self->init_PERL;
1749 }
1750
1751 =item init_others
1752
1753 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
1754 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
1755 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
1756
1757 =cut
1758
1759 sub init_others {       # --- Initialize Other Attributes
1760     my($self) = shift;
1761
1762     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
1763     # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
1764     # undefined. In any case we turn it into an anon array:
1765
1766     # May check $Config{libs} too, thus not empty.
1767     $self->{LIBS}=[''] unless $self->{LIBS};
1768
1769     $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
1770     $self->{LD_RUN_PATH} = "";
1771     my($libs);
1772     foreach $libs ( @{$self->{LIBS}} ){
1773         $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
1774         my(@libs) = $self->extliblist($libs);
1775         if ($libs[0] or $libs[1] or $libs[2]){
1776             # LD_RUN_PATH now computed by ExtUtils::Liblist
1777             ($self->{EXTRALIBS},  $self->{BSLOADLIBS},
1778              $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
1779             last;
1780         }
1781     }
1782
1783     if ( $self->{OBJECT} ) {
1784         $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
1785     } else {
1786         # init_dirscan should have found out, if we have C files
1787         $self->{OBJECT} = "";
1788         $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
1789     }
1790     $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
1791     $self->{BOOTDEP}  = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
1792     $self->{PERLMAINCC} ||= '$(CC)';
1793     $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
1794
1795     # Sanity check: don't define LINKTYPE = dynamic if we're skipping
1796     # the 'dynamic' section of MM.  We don't have this problem with
1797     # 'static', since we either must use it (%Config says we can't
1798     # use dynamic loading) or the caller asked for it explicitly.
1799     if (!$self->{LINKTYPE}) {
1800        $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
1801                         ? 'static'
1802                         : ($Config{usedl} ? 'dynamic' : 'static');
1803     };
1804
1805     # These get overridden for VMS and maybe some other systems
1806     $self->{NOOP}  ||= '$(SHELL) -c true';
1807     $self->{FIRST_MAKEFILE} ||= "Makefile";
1808     $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
1809     $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
1810     $self->{NOECHO} = '@' unless defined $self->{NOECHO};
1811     $self->{RM_F}  ||= "rm -f";
1812     $self->{RM_RF} ||= "rm -rf";
1813     $self->{TOUCH} ||= "touch";
1814     $self->{TEST_F} ||= "test -f";
1815     $self->{CP} ||= "cp";
1816     $self->{MV} ||= "mv";
1817     $self->{CHMOD} ||= "chmod";
1818     $self->{UMASK_NULL} ||= "umask 0";
1819     $self->{DEV_NULL} ||= "> /dev/null 2>&1";
1820 }
1821
1822 =item init_INST
1823
1824     $mm->init_INST;
1825
1826 Called by init_main.  Sets up all INST_* variables.
1827
1828 =cut
1829
1830 sub init_INST {
1831     my($self) = shift;
1832
1833     $self->{INST_ARCHLIB} ||= File::Spec->catdir($Curdir,"blib","arch");
1834     $self->{INST_BIN}     ||= File::Spec->catdir($Curdir,'blib','bin');
1835
1836     # INST_LIB typically pre-set if building an extension after
1837     # perl has been built and installed. Setting INST_LIB allows
1838     # you to build directly into, say $Config{privlibexp}.
1839     unless ($self->{INST_LIB}){
1840         if ($self->{PERL_CORE}) {
1841             if (defined $Cross::platform) {
1842                 $self->{INST_LIB} = $self->{INST_ARCHLIB} =
1843                   File::Spec->catdir($self->{PERL_LIB},"..","xlib",
1844                                      $Cross::platform);
1845             }
1846             else {
1847                 $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB};
1848             }
1849         } else {
1850             $self->{INST_LIB} = File::Spec->catdir($Curdir,"blib","lib");
1851         }
1852     }
1853
1854     my @parentdir = split(/::/, $self->{PARENT_NAME});
1855     $self->{INST_LIBDIR} = File::Spec->catdir($self->{INST_LIB},@parentdir);
1856     $self->{INST_ARCHLIBDIR} = File::Spec->catdir($self->{INST_ARCHLIB},
1857                                                   @parentdir);
1858     $self->{INST_AUTODIR} = File::Spec->catdir($self->{INST_LIB},'auto',
1859                                                $self->{FULLEXT});
1860     $self->{INST_ARCHAUTODIR} = File::Spec->catdir($self->{INST_ARCHLIB},
1861                                                    'auto',$self->{FULLEXT});
1862
1863     $self->{INST_SCRIPT} ||= File::Spec->catdir($Curdir,'blib','script');
1864
1865     $self->{INST_MAN1DIR} ||= File::Spec->catdir($Curdir,'blib','man1');
1866     $self->{INST_MAN3DIR} ||= File::Spec->catdir($Curdir,'blib','man3');
1867
1868     return 1;
1869 }
1870
1871 =item init_INSTALL
1872
1873     $mm->init_INSTALL;
1874
1875 Called by init_main.  Sets up all INSTALL_* variables (except
1876 INSTALLDIRS) and PREFIX.
1877
1878 =cut
1879
1880 sub init_INSTALL {
1881     my($self) = shift;
1882
1883     $self->init_lib2arch;
1884
1885     if( $Config{usevendorprefix} ) {
1886         $Config_Override{installvendorman1dir} =
1887           File::Spec->catdir($Config{vendorprefixexp}, 'man', 'man$(MAN1EXT)');
1888         $Config_Override{installvendorman3dir} =
1889           File::Spec->catdir($Config{vendorprefixexp}, 'man', 'man$(MAN3EXT)');
1890     }
1891     else {
1892         $Config_Override{installvendorman1dir} = '';
1893         $Config_Override{installvendorman3dir} = '';
1894     }
1895
1896     my $iprefix = $Config{installprefixexp} || $Config{installprefix} ||
1897                   $Config{prefixexp}        || $Config{prefix} || '';
1898     my $vprefix = $Config{usevendorprefix}  ? $Config{vendorprefixexp} : '';
1899     my $sprefix = $Config{siteprefixexp}    || '';
1900
1901     # 5.005_03 doesn't have a siteprefix.
1902     $sprefix = $iprefix unless $sprefix;
1903
1904     # There are often no Config.pm defaults for these, but we can make
1905     # it up.
1906     unless( $Config{installsiteman1dir} ) {
1907         $Config_Override{installsiteman1dir} =
1908           File::Spec->catdir($sprefix, 'man', 'man$(MAN1EXT)');
1909     }
1910
1911     unless( $Config{installsiteman3dir} ) {
1912         $Config_Override{installsiteman3dir} =
1913           File::Spec->catdir($sprefix, 'man', 'man$(MAN3EXT)');
1914     }
1915
1916     unless( $Config{installsitebin} ) {
1917         $Config_Override{installsitebin} =
1918           File::Spec->catdir($sprefix, 'bin');
1919     }
1920
1921     my $u_prefix  = $self->{PREFIX}       || '';
1922     my $u_sprefix = $self->{SITEPREFIX}   || $u_prefix;
1923     my $u_vprefix = $self->{VENDORPREFIX} || $u_prefix;
1924
1925     $self->{PREFIX}       ||= $u_prefix  || $iprefix;
1926     $self->{SITEPREFIX}   ||= $u_sprefix || $sprefix;
1927     $self->{VENDORPREFIX} ||= $u_vprefix || $vprefix;
1928
1929     my $arch    = $Config{archname};
1930     my $version = $Config{version};
1931
1932     # default style
1933     my $libstyle = 'lib/perl5';
1934     my $manstyle = '';
1935
1936     if( $self->{LIBSTYLE} ) {
1937         $libstyle = $self->{LIBSTYLE};
1938         $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : '';
1939     }
1940
1941     # Some systems, like VOS, set installman*dir to '' if they can't
1942     # read man pages.
1943     for my $num (1, 3) {
1944         $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none'
1945           unless $Config{'installman'.$num.'dir'};
1946     }
1947
1948     my %bin_layouts =
1949     (
1950         bin         => { s => $iprefix,
1951                          r => $u_prefix,
1952                          d => 'bin' },
1953         vendorbin   => { s => $vprefix,
1954                          r => $u_vprefix,
1955                          d => 'bin' },
1956         sitebin     => { s => $sprefix,
1957                          r => $u_sprefix,
1958                          d => 'bin' },
1959         script      => { s => $iprefix,
1960                          r => $u_prefix,
1961                          d => 'bin' },
1962     );
1963
1964     my %man_layouts =
1965     (
1966         man1dir         => { s => $iprefix,
1967                              r => $u_prefix,
1968                              d => 'man/man$(MAN1EXT)',
1969                              style => $manstyle, },
1970         siteman1dir     => { s => $sprefix,
1971                              r => $u_sprefix,
1972                              d => 'man/man$(MAN1EXT)',
1973                              style => $manstyle, },
1974         vendorman1dir   => { s => $vprefix,
1975                              r => $u_vprefix,
1976                              d => 'man/man$(MAN1EXT)',
1977                              style => $manstyle, },
1978
1979         man3dir         => { s => $iprefix,
1980                              r => $u_prefix,
1981                              d => 'man/man$(MAN3EXT)',
1982                              style => $manstyle, },
1983         siteman3dir     => { s => $sprefix,
1984                              r => $u_sprefix,
1985                              d => 'man/man$(MAN3EXT)',
1986                              style => $manstyle, },
1987         vendorman3dir   => { s => $vprefix,
1988                              r => $u_vprefix,
1989                              d => 'man/man$(MAN3EXT)',
1990                              style => $manstyle, },
1991     );
1992
1993     my %lib_layouts =
1994     (
1995         privlib     => { s => $iprefix,
1996                          r => $u_prefix,
1997                          d => '',
1998                          style => $libstyle, },
1999         vendorlib   => { s => $vprefix,
2000                          r => $u_vprefix,
2001                          d => '',
2002                          style => $libstyle, },
2003         sitelib     => { s => $sprefix,
2004                          r => $u_sprefix,
2005                          d => 'site_perl',
2006                          style => $libstyle, },
2007
2008         archlib     => { s => $iprefix,
2009                          r => $u_prefix,
2010                          d => "$version/$arch",
2011                          style => $libstyle },
2012         vendorarch  => { s => $vprefix,
2013                          r => $u_vprefix,
2014                          d => "$version/$arch",
2015                          style => $libstyle },
2016         sitearch    => { s => $sprefix,
2017                          r => $u_sprefix,
2018                          d => "site_perl/$version/$arch",
2019                          style => $libstyle },
2020     );
2021
2022
2023     # Special case for LIB.
2024     if( $self->{LIB} ) {
2025         foreach my $var (keys %lib_layouts) {
2026             my $Installvar = uc "install$var";
2027
2028             if( $var =~ /arch/ ) {
2029                 $self->{$Installvar} ||=
2030                   File::Spec->catdir($self->{LIB}, $Config{archname});
2031             }
2032             else {
2033                 $self->{$Installvar} ||= $self->{LIB};
2034             }
2035         }
2036     }
2037
2038
2039     my %layouts = (%bin_layouts, %man_layouts, %lib_layouts);
2040     while( my($var, $layout) = each(%layouts) ) {
2041         my($s, $r, $d, $style) = @{$layout}{qw(s r d style)};
2042
2043         print STDERR "Prefixing $var\n" if $Verbose >= 2;
2044
2045         my $installvar = "install$var";
2046         my $Installvar = uc $installvar;
2047         next if $self->{$Installvar};
2048
2049         if( $r ) {
2050             $d = "$style/$d" if $style;
2051             $self->prefixify($installvar, $s, $r, $d);
2052         }
2053         else {
2054             $self->{$Installvar} = $Config_Override{$installvar} ||
2055                                    $Config{$installvar};
2056         }
2057
2058         print STDERR "  $Installvar == $self->{$Installvar}\n"
2059           if $Verbose >= 2;
2060     }
2061
2062     return 1;
2063 }
2064
2065 =begin _protected
2066
2067 =item init_lib2arch
2068
2069     $mm->init_lib2arch
2070
2071 =end _protected
2072
2073 =cut
2074
2075 sub init_lib2arch {
2076     my($self) = shift;
2077
2078     # The user who requests an installation directory explicitly
2079     # should not have to tell us an architecture installation directory
2080     # as well. We look if a directory exists that is named after the
2081     # architecture. If not we take it as a sign that it should be the
2082     # same as the requested installation directory. Otherwise we take
2083     # the found one.
2084     for my $libpair ({l=>"privlib",   a=>"archlib"},
2085                      {l=>"sitelib",   a=>"sitearch"},
2086                      {l=>"vendorlib", a=>"vendorarch"},
2087                     )
2088     {
2089         my $lib = "install$libpair->{l}";
2090         my $Lib = uc $lib;
2091         my $Arch = uc "install$libpair->{a}";
2092         if( $self->{$Lib} && ! $self->{$Arch} ){
2093             my($ilib) = $Config{$lib};
2094
2095             $self->prefixify($Arch,$ilib,$self->{$Lib});
2096
2097             unless (-d $self->{$Arch}) {
2098                 print STDOUT "Directory $self->{$Arch} not found\n"
2099                   if $Verbose;
2100                 $self->{$Arch} = $self->{$Lib};
2101             }
2102             print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose;
2103         }
2104     }
2105 }
2106
2107
2108 =item init_PERL
2109
2110     $mm->init_PERL;
2111
2112 Called by init_main.  Sets up ABSPERL, PERL, FULLPERL and all the
2113 *PERLRUN* permutations.
2114
2115     PERL is allowed to be miniperl
2116     FULLPERL must be a complete perl
2117     ABSPERL is PERL converted to an absolute path
2118
2119     *PERLRUN contains everything necessary to run perl, find it's
2120          libraries, etc...
2121
2122     *PERLRUNINST is *PERLRUN + everything necessary to find the
2123          modules being built.
2124
2125 =cut
2126
2127 sub init_PERL {
2128     my($self) = shift;
2129
2130     my @defpath = ();
2131     foreach my $component ($self->{PERL_SRC}, $self->path(),
2132                            $Config{binexp})
2133     {
2134         push @defpath, $component if defined $component;
2135     }
2136
2137     # Build up a set of file names (not command names).
2138     my $thisperl = File::Spec->canonpath($^X);
2139     $thisperl .= $Config{exe_ext} unless $thisperl =~ m/$Config{exe_ext}$/i;
2140     my @perls = ($thisperl);
2141     push @perls, map { "$_$Config{exe_ext}" }
2142                      ('perl', 'perl5', "perl$Config{version}");
2143
2144     # miniperl has priority over all but the cannonical perl when in the
2145     # core.  Otherwise its a last resort.
2146     my $miniperl = "miniperl$Config{exe_ext}";
2147     if( $self->{PERL_CORE} ) {
2148         splice @perls, 1, 0, $miniperl;
2149     }
2150     else {
2151         push @perls, $miniperl;
2152     }
2153
2154     $self->{PERL} ||=
2155         $self->find_perl(5.0, \@perls, \@defpath, $Verbose );
2156     # don't check if perl is executable, maybe they have decided to
2157     # supply switches with perl
2158
2159     # Define 'FULLPERL' to be a non-miniperl (used in test: target)
2160     ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/perl/i
2161         unless $self->{FULLPERL};
2162
2163     # Little hack to get around VMS's find_perl putting "MCR" in front
2164     # sometimes.
2165     $self->{ABSPERL} = $self->{PERL};
2166     my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//;
2167     if( File::Spec->file_name_is_absolute($self->{ABSPERL}) ) {
2168         $self->{ABSPERL} = '$(PERL)';
2169     }
2170     else {
2171         $self->{ABSPERL} = File::Spec->rel2abs($self->{ABSPERL});
2172         $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr;
2173     }
2174
2175     # Are we building the core?
2176     $self->{PERL_CORE} = 0 unless exists $self->{PERL_CORE};
2177
2178     # How do we run perl?
2179     foreach my $perl (qw(PERL FULLPERL ABSPERL)) {
2180         $self->{$perl.'RUN'}  = "\$($perl)";
2181
2182         # Make sure perl can find itself before it's installed.
2183         $self->{$perl.'RUN'} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"}
2184           if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE};
2185
2186         $self->{$perl.'RUNINST'} =
2187           sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl;
2188     }
2189
2190     return 1;
2191 }
2192
2193 =item init_PERM
2194
2195   $mm->init_PERM
2196
2197 Called by init_main.  Initializes PERL_*
2198
2199 =cut
2200
2201 sub init_PERM {
2202     my($self) = shift;
2203
2204     $self->{PERM_RW}  = 644;
2205     $self->{PERM_RWX} = 755;
2206
2207     return 1;
2208 }
2209
2210
2211 =item install (o)
2212
2213 Defines the install target.
2214
2215 =cut
2216
2217 sub install {
2218     my($self, %attribs) = @_;
2219     my(@m);
2220
2221     push @m, q{
2222 install :: all pure_install doc_install
2223
2224 install_perl :: all pure_perl_install doc_perl_install
2225
2226 install_site :: all pure_site_install doc_site_install
2227
2228 install_vendor :: all pure_vendor_install doc_vendor_install
2229
2230 pure_install :: pure_$(INSTALLDIRS)_install
2231
2232 doc_install :: doc_$(INSTALLDIRS)_install
2233         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2234
2235 pure__install : pure_site_install
2236         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2237
2238 doc__install : doc_site_install
2239         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2240
2241 pure_perl_install ::
2242         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2243                 read }.File::Spec->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2244                 write }.File::Spec->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2245                 $(INST_LIB) $(INSTALLPRIVLIB) \
2246                 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
2247                 $(INST_BIN) $(INSTALLBIN) \
2248                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2249                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2250                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2251         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2252                 }.File::Spec->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2253
2254
2255 pure_site_install ::
2256         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2257                 read }.File::Spec->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2258                 write }.File::Spec->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2259                 $(INST_LIB) $(INSTALLSITELIB) \
2260                 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
2261                 $(INST_BIN) $(INSTALLSITEBIN) \
2262                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2263                 $(INST_MAN1DIR) $(INSTALLSITEMAN1DIR) \
2264                 $(INST_MAN3DIR) $(INSTALLSITEMAN3DIR)
2265         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2266                 }.File::Spec->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2267
2268 pure_vendor_install ::
2269         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2270                 $(INST_LIB) $(INSTALLVENDORLIB) \
2271                 $(INST_ARCHLIB) $(INSTALLVENDORARCH) \
2272                 $(INST_BIN) $(INSTALLVENDORBIN) \
2273                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2274                 $(INST_MAN1DIR) $(INSTALLVENDORMAN1DIR) \
2275                 $(INST_MAN3DIR) $(INSTALLVENDORMAN3DIR)
2276
2277 doc_perl_install ::
2278         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2279         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2280                 "Module" "$(NAME)" \
2281                 "installed into" "$(INSTALLPRIVLIB)" \
2282                 LINKTYPE "$(LINKTYPE)" \
2283                 VERSION "$(VERSION)" \
2284                 EXE_FILES "$(EXE_FILES)" \
2285                 >> }.File::Spec->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2286
2287 doc_site_install ::
2288         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2289         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2290                 "Module" "$(NAME)" \
2291                 "installed into" "$(INSTALLSITELIB)" \
2292                 LINKTYPE "$(LINKTYPE)" \
2293                 VERSION "$(VERSION)" \
2294                 EXE_FILES "$(EXE_FILES)" \
2295                 >> }.File::Spec->catfile('$(INSTALLSITEARCH)','perllocal.pod').q{
2296
2297 doc_vendor_install ::
2298
2299 };
2300
2301     push @m, q{
2302 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2303
2304 uninstall_from_perldirs ::
2305         }.$self->{NOECHO}.
2306         q{$(UNINSTALL) }.File::Spec->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2307
2308 uninstall_from_sitedirs ::
2309         }.$self->{NOECHO}.
2310         q{$(UNINSTALL) }.File::Spec->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2311 };
2312
2313     join("",@m);
2314 }
2315
2316 =item installbin (o)
2317
2318 Defines targets to make and to install EXE_FILES.
2319
2320 =cut
2321
2322 sub installbin {
2323     my($self) = shift;
2324     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2325     return "" unless @{$self->{EXE_FILES}};
2326     my(@m, $from, $to, %fromto, @to);
2327     push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2328     for $from (@{$self->{EXE_FILES}}) {
2329         my($path)= File::Spec->catfile('$(INST_SCRIPT)', basename($from));
2330         local($_) = $path; # for backwards compatibility
2331         $to = $self->libscan($path);
2332         print "libscan($from) => '$to'\n" if ($Verbose >=2);
2333         $fromto{$from}=$to;
2334     }
2335     @to   = values %fromto;
2336     push(@m, qq{
2337 EXE_FILES = @{$self->{EXE_FILES}}
2338
2339 } . ($Is_Win32
2340   ? q{FIXIN = pl2bat.bat
2341 } : q{FIXIN = $(PERLRUN) "-MExtUtils::MY" \
2342     -e "MY->fixin(shift)"
2343 }).qq{
2344 pure_all :: @to
2345         $self->{NOECHO}\$(NOOP)
2346
2347 realclean ::
2348         $self->{RM_F} @to
2349 });
2350
2351     while (($from,$to) = each %fromto) {
2352         last unless defined $from;
2353         my $todir = dirname($to);
2354         push @m, "
2355 $to: $from $self->{MAKEFILE} " . File::Spec->catdir($todir,'.exists') . "
2356         $self->{NOECHO}$self->{RM_F} $to
2357         $self->{CP} $from $to
2358         \$(FIXIN) $to
2359         -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2360 ";
2361     }
2362     join "", @m;
2363 }
2364
2365 =item libscan (o)
2366
2367 Takes a path to a file that is found by init_dirscan and returns false
2368 if we don't want to include this file in the library. Mainly used to
2369 exclude RCS, CVS, and SCCS directories from installation.
2370
2371 =cut
2372
2373 # ';
2374
2375 sub libscan {
2376     my($self,$path) = @_;
2377     return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2378     $path;
2379 }
2380
2381 =item linkext (o)
2382
2383 Defines the linkext target which in turn defines the LINKTYPE.
2384
2385 =cut
2386
2387 sub linkext {
2388     my($self, %attribs) = @_;
2389     # LINKTYPE => static or dynamic or ''
2390     my($linktype) = defined $attribs{LINKTYPE} ?
2391       $attribs{LINKTYPE} : '$(LINKTYPE)';
2392     "
2393 linkext :: $linktype
2394         $self->{NOECHO}\$(NOOP)
2395 ";
2396 }
2397
2398 =item lsdir
2399
2400 Takes as arguments a directory name and a regular expression. Returns
2401 all entries in the directory that match the regular expression.
2402
2403 =cut
2404
2405 sub lsdir {
2406     my($self) = shift;
2407     my($dir, $regex) = @_;
2408     my(@ls);
2409     my $dh = new DirHandle;
2410     $dh->open($dir || ".") or return ();
2411     @ls = $dh->read;
2412     $dh->close;
2413     @ls = grep(/$regex/, @ls) if $regex;
2414     @ls;
2415 }
2416
2417 =item macro (o)
2418
2419 Simple subroutine to insert the macros defined by the macro attribute
2420 into the Makefile.
2421
2422 =cut
2423
2424 sub macro {
2425     my($self,%attribs) = @_;
2426     my(@m,$key,$val);
2427     while (($key,$val) = each %attribs){
2428         last unless defined $key;
2429         push @m, "$key = $val\n";
2430     }
2431     join "", @m;
2432 }
2433
2434 =item makeaperl (o)
2435
2436 Called by staticmake. Defines how to write the Makefile to produce a
2437 static new perl.
2438
2439 By default the Makefile produced includes all the static extensions in
2440 the perl library. (Purified versions of library files, e.g.,
2441 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2442
2443 =cut
2444
2445 sub makeaperl {
2446     my($self, %attribs) = @_;
2447     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2448         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2449     my(@m);
2450     push @m, "
2451 # --- MakeMaker makeaperl section ---
2452 MAP_TARGET    = $target
2453 FULLPERL      = $self->{FULLPERL}
2454 ";
2455     return join '', @m if $self->{PARENT};
2456
2457     my($dir) = join ":", @{$self->{DIR}};
2458
2459     unless ($self->{MAKEAPERL}) {
2460         push @m, q{
2461 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2462         $(MAKE) -f $(MAKE_APERL_FILE) $@
2463
2464 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2465         }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2466         }.$self->{NOECHO}.q{$(PERLRUNINST) \
2467                 Makefile.PL DIR=}, $dir, q{ \
2468                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2469                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2470
2471         foreach (@ARGV){
2472                 if( /\s/ ){
2473                         s/=(.*)/='$1'/;
2474                 }
2475                 push @m, " \\\n\t\t$_";
2476         }
2477 #       push @m, map( " \\\n\t\t$_", @ARGV );
2478         push @m, "\n";
2479
2480         return join '', @m;
2481     }
2482
2483
2484
2485     my($cccmd, $linkcmd, $lperl);
2486
2487
2488     $cccmd = $self->const_cccmd($libperl);
2489     $cccmd =~ s/^CCCMD\s*=\s*//;
2490     $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /;
2491     $cccmd .= " $Config{cccdlflags}"
2492         if ($Config{useshrplib} eq 'true');
2493     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2494
2495     # The front matter of the linkcommand...
2496     $linkcmd = join ' ', "\$(CC)",
2497             grep($_, @Config{qw(ldflags ccdlflags)});
2498     $linkcmd =~ s/\s+/ /g;
2499     $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2500
2501     # Which *.a files could we make use of...
2502     local(%static);
2503     require File::Find;
2504     File::Find::find(sub {
2505         return unless m/\Q$self->{LIB_EXT}\E$/;
2506         return if m/^libperl/;
2507         # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2508         return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2509
2510         if( exists $self->{INCLUDE_EXT} ){
2511                 my $found = 0;
2512                 my $incl;
2513                 my $xx;
2514
2515                 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2516                 $xx =~ s,/?$_,,;
2517                 $xx =~ s,/,::,g;
2518
2519                 # Throw away anything not explicitly marked for inclusion.
2520                 # DynaLoader is implied.
2521                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2522                         if( $xx eq $incl ){
2523                                 $found++;
2524                                 last;
2525                         }
2526                 }
2527                 return unless $found;
2528         }
2529         elsif( exists $self->{EXCLUDE_EXT} ){
2530                 my $excl;
2531                 my $xx;
2532
2533                 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2534                 $xx =~ s,/?$_,,;
2535                 $xx =~ s,/,::,g;
2536
2537                 # Throw away anything explicitly marked for exclusion
2538                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2539                         return if( $xx eq $excl );
2540                 }
2541         }
2542
2543         # don't include the installed version of this extension. I
2544         # leave this line here, although it is not necessary anymore:
2545         # I patched minimod.PL instead, so that Miniperl.pm won't
2546         # enclude duplicates
2547
2548         # Once the patch to minimod.PL is in the distribution, I can
2549         # drop it
2550         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2551         use Cwd 'cwd';
2552         $static{cwd() . "/" . $_}++;
2553     }, grep( -d $_, @{$searchdirs || []}) );
2554
2555     # We trust that what has been handed in as argument, will be buildable
2556     $static = [] unless $static;
2557     @static{@{$static}} = (1) x @{$static};
2558
2559     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2560     for (sort keys %static) {
2561         next unless /\Q$self->{LIB_EXT}\E\z/;
2562         $_ = dirname($_) . "/extralibs.ld";
2563         push @$extra, $_;
2564     }
2565
2566     grep(s/^(.*)/"-I$1"/, @{$perlinc || []});
2567
2568     $target ||= "perl";
2569     $tmp    ||= ".";
2570
2571 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2572 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2573 # extralibs.all are computed correctly
2574     push @m, "
2575 MAP_LINKCMD   = $linkcmd
2576 MAP_PERLINC   = @{$perlinc || []}
2577 MAP_STATIC    = ",
2578 join(" \\\n\t", reverse sort keys %static), "
2579
2580 MAP_PRELIBS   = $Config{perllibs} $Config{cryptlib}
2581 ";
2582
2583     if (defined $libperl) {
2584         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2585     }
2586     unless ($libperl && -f $lperl) { # Ilya's code...
2587         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2588         $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2589         $libperl ||= "libperl$self->{LIB_EXT}";
2590         $libperl   = "$dir/$libperl";
2591         $lperl   ||= "libperl$self->{LIB_EXT}";
2592         $lperl     = "$dir/$lperl";
2593
2594         if (! -f $libperl and ! -f $lperl) {
2595           # We did not find a static libperl. Maybe there is a shared one?
2596           if ($^O eq 'solaris' or $^O eq 'sunos') {
2597             $lperl  = $libperl = "$dir/$Config{libperl}";
2598             # SUNOS ld does not take the full path to a shared library
2599             $libperl = '' if $^O eq 'sunos';
2600           }
2601         }
2602
2603         print STDOUT "Warning: $libperl not found
2604     If you're going to build a static perl binary, make sure perl is installed
2605     otherwise ignore this warning\n"
2606                 unless (-f $lperl || defined($self->{PERL_SRC}));
2607     }
2608
2609     # SUNOS ld does not take the full path to a shared library
2610     my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl';
2611
2612     push @m, "
2613 MAP_LIBPERL = $libperl
2614 LLIBPERL    = $llibperl
2615 ";
2616
2617     push @m, "
2618 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2619         $self->{NOECHO}$self->{RM_F} \$\@
2620         $self->{NOECHO}\$(TOUCH) \$\@
2621 ";
2622
2623     my $catfile;
2624     foreach $catfile (@$extra){
2625         push @m, "\tcat $catfile >> \$\@\n";
2626     }
2627
2628 push @m, "
2629 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2630         \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2631         $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2632         $self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2633         $self->{NOECHO}echo 'To remove the intermediate files say'
2634         $self->{NOECHO}echo '    make -f $makefilename map_clean'
2635
2636 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2637 ";
2638     push @m, qq{\tcd $tmp && $cccmd "-I\$(PERL_INC)" perlmain.c\n};
2639
2640     push @m, qq{
2641 $tmp/perlmain.c: $makefilename}, q{
2642         }.$self->{NOECHO}.q{echo Writing $@
2643         }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\
2644                 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2645
2646 };
2647     push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2648 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2649
2650
2651     push @m, q{
2652 doc_inst_perl:
2653         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2654         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2655         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2656                 "Perl binary" "$(MAP_TARGET)" \
2657                 MAP_STATIC "$(MAP_STATIC)" \
2658                 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2659                 MAP_LIBPERL "$(MAP_LIBPERL)" \
2660                 >> }.File::Spec->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2661
2662 };
2663
2664     push @m, q{
2665 inst_perl: pure_inst_perl doc_inst_perl
2666
2667 pure_inst_perl: $(MAP_TARGET)
2668         }.$self->{CP}.q{ $(MAP_TARGET) }.File::Spec->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2669
2670 clean :: map_clean
2671
2672 map_clean :
2673         }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2674 };
2675
2676     join '', @m;
2677 }
2678
2679 =item makefile (o)
2680
2681 Defines how to rewrite the Makefile.
2682
2683 =cut
2684
2685 sub makefile {
2686     my($self) = shift;
2687     my @m;
2688     # We do not know what target was originally specified so we
2689     # must force a manual rerun to be sure. But as it should only
2690     # happen very rarely it is not a significant problem.
2691     push @m, '
2692 $(OBJECT) : $(FIRST_MAKEFILE)
2693 ' if $self->{OBJECT};
2694
2695     push @m, q{
2696 # We take a very conservative approach here, but it\'s worth it.
2697 # We move Makefile to Makefile.old here to avoid gnu make looping.
2698 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2699         }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2700         }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2701         -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2702         -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2703         -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2704         $(PERLRUN) Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2705         }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2706         }.$self->{NOECHO}.q{echo "==> Please rerun the make command.  <=="
2707         false
2708
2709 };
2710
2711     join "", @m;
2712 }
2713
2714 =item manifypods (o)
2715
2716 Defines targets and routines to translate the pods into manpages and
2717 put them into the INST_* directories.
2718
2719 =cut
2720
2721 sub manifypods {
2722     my($self, %attribs) = @_;
2723     return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2724         %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2725     my($dist);
2726     my($pod2man_exe);
2727     if (defined $self->{PERL_SRC}) {
2728         $pod2man_exe = File::Spec->catfile($self->{PERL_SRC},'pod','pod2man');
2729     } else {
2730         $pod2man_exe = File::Spec->catfile($Config{scriptdirexp},'pod2man');
2731     }
2732     unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2733       # Maybe a build by uninstalled Perl?
2734       $pod2man_exe = File::Spec->catfile($self->{PERL_INC}, "pod", "pod2man");
2735     }
2736     unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2737         # No pod2man but some MAN3PODS to be installed
2738         print <<END;
2739
2740 Warning: I could not locate your pod2man program. Please make sure,
2741          your pod2man program is in your PATH before you execute 'make'
2742
2743 END
2744         $pod2man_exe = "-S pod2man";
2745     }
2746     my(@m);
2747     push @m,
2748 qq[POD2MAN_EXE = $pod2man_exe\n],
2749 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2750 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2751  $self->{MAKEFILE}, q[";' \\
2752 -e 'print "Manifying $$m{$$_}\n";' \\
2753 -e 'system(q[$(PERLRUN) $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2754 -e 'chmod(oct($(PERM_RW)), $$m{$$_}) or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2755 ];
2756     push @m, "\nmanifypods : pure_all ";
2757     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2758
2759     push(@m,"\n");
2760     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2761         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2762         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2763     }
2764     join('', @m);
2765 }
2766
2767 =item maybe_command
2768
2769 Returns true, if the argument is likely to be a command.
2770
2771 =cut
2772
2773 sub maybe_command {
2774     my($self,$file) = @_;
2775     return $file if -x $file && ! -d $file;
2776     return;
2777 }
2778
2779 =item maybe_command_in_dirs
2780
2781 method under development. Not yet used. Ask Ilya :-)
2782
2783 =cut
2784
2785 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2786 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2787     my($self, $names, $dirs, $trace, $ver) = @_;
2788     my($name, $dir);
2789     foreach $dir (@$dirs){
2790         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2791         foreach $name (@$names){
2792             my($abs,$tryabs);
2793             if (File::Spec->file_name_is_absolute($name)) { # /foo/bar
2794                 $abs = $name;
2795             } elsif (File::Spec->canonpath($name) eq File::Spec->canonpath(basename($name))) { # bar
2796                 $abs = File::Spec->catfile($dir, $name);
2797             } else { # foo/bar
2798                 $abs = File::Spec->catfile($Curdir, $name);
2799             }
2800             print "Checking $abs for $name\n" if ($trace >= 2);
2801             next unless $tryabs = $self->maybe_command($abs);
2802             print "Substituting $tryabs instead of $abs\n"
2803                 if ($trace >= 2 and $tryabs ne $abs);
2804             $abs = $tryabs;
2805             if (defined $ver) {
2806                 print "Executing $abs\n" if ($trace >= 2);
2807                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2808                     print "Using PERL=$abs\n" if $trace;
2809                     return $abs;
2810                 }
2811             } else { # Do not look for perl
2812                 return $abs;
2813             }
2814         }
2815     }
2816 }
2817
2818 =item needs_linking (o)
2819
2820 Does this module need linking? Looks into subdirectory objects (see
2821 also has_link_code())
2822
2823 =cut
2824
2825 sub needs_linking {
2826     my($self) = shift;
2827     my($child,$caller);
2828     $caller = (caller(0))[3];
2829     confess("Needs_linking called too early") if
2830       $caller =~ /^ExtUtils::MakeMaker::/;
2831     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2832     if ($self->has_link_code or $self->{MAKEAPERL}){
2833         $self->{NEEDS_LINKING} = 1;
2834         return 1;
2835     }
2836     foreach $child (keys %{$self->{CHILDREN}}) {
2837         if ($self->{CHILDREN}->{$child}->needs_linking) {
2838             $self->{NEEDS_LINKING} = 1;
2839             return 1;
2840         }
2841     }
2842     return $self->{NEEDS_LINKING} = 0;
2843 }
2844
2845 =item nicetext
2846
2847 misnamed method (will have to be changed). The MM_Unix method just
2848 returns the argument without further processing.
2849
2850 On VMS used to insure that colons marking targets are preceded by
2851 space - most Unix Makes don't need this, but it's necessary under VMS
2852 to distinguish the target delimiter from a colon appearing as part of
2853 a filespec.
2854
2855 =cut
2856
2857 sub nicetext {
2858     my($self,$text) = @_;
2859     $text;
2860 }
2861
2862 =item parse_abstract
2863
2864 parse a file and return what you think is the ABSTRACT
2865
2866 =cut
2867
2868 sub parse_abstract {
2869     my($self,$parsefile) = @_;
2870     my $result;
2871     local *FH;
2872     local $/ = "\n";
2873     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2874     my $inpod = 0;
2875     my $package = $self->{DISTNAME};
2876     $package =~ s/-/::/g;
2877     while (<FH>) {
2878         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2879         next if !$inpod;
2880         chop;
2881         next unless /^($package\s-\s)(.*)/;
2882         $result = $2;
2883         last;
2884     }
2885     close FH;
2886     return $result;
2887 }
2888
2889 =item parse_version
2890
2891 parse a file and return what you think is $VERSION in this file set to.
2892 It will return the string "undef" if it can't figure out what $VERSION
2893 is. $VERSION should be for all to see, so our $VERSION or plain $VERSION
2894 are okay, but my $VERSION is not.
2895
2896 =cut
2897
2898 sub parse_version {
2899     my($self,$parsefile) = @_;
2900     my $result;
2901     local *FH;
2902     local $/ = "\n";
2903     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2904     my $inpod = 0;
2905     while (<FH>) {
2906         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2907         next if $inpod || /^\s*#/;
2908         chop;
2909         # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2910         next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2911         my $eval = qq{
2912             package ExtUtils::MakeMaker::_version;
2913             no strict;
2914
2915             local $1$2;
2916             \$$2=undef; do {
2917                 $_
2918             }; \$$2
2919         };
2920         local $^W = 0;
2921         $result = eval($eval);
2922         warn "Could not eval '$eval' in $parsefile: $@" if $@;
2923         last;
2924     }
2925     close FH;
2926
2927     $result = "undef" unless defined $result;
2928     return $result;
2929 }
2930
2931
2932 =item pasthru (o)
2933
2934 Defines the string that is passed to recursive make calls in
2935 subdirectories.
2936
2937 =cut
2938
2939 sub pasthru {
2940     my($self) = shift;
2941     my(@m,$key);
2942
2943     my(@pasthru);
2944     my($sep) = $Is_VMS ? ',' : '';
2945     $sep .= "\\\n\t";
2946
2947     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
2948         push @pasthru, "$key=\"\$($key)\"";
2949     }
2950
2951     foreach $key (qw(DEFINE INC)) {
2952         push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
2953     }
2954
2955     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2956     join "", @m;
2957 }
2958
2959 =item perl_script
2960
2961 Takes one argument, a file name, and returns the file name, if the
2962 argument is likely to be a perl script. On MM_Unix this is true for
2963 any ordinary, readable file.
2964
2965 =cut
2966
2967 sub perl_script {
2968     my($self,$file) = @_;
2969     return $file if -r $file && -f _;
2970     return;
2971 }
2972
2973 =item perldepend (o)
2974
2975 Defines the dependency from all *.h files that come with the perl
2976 distribution.
2977
2978 =cut
2979
2980 sub perldepend {
2981     my($self) = shift;
2982     my(@m);
2983     push @m, q{
2984 # Check for unpropogated config.sh changes. Should never happen.
2985 # We do NOT just update config.h because that is not sufficient.
2986 # An out of date config.h is not fatal but complains loudly!
2987 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2988         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2989
2990 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2991         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2992         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2993 } if $self->{PERL_SRC};
2994
2995     return join "", @m unless $self->needs_linking;
2996
2997     push @m, q{
2998 PERL_HDRS = \
2999         $(PERL_INC)/EXTERN.h            \
3000         $(PERL_INC)/INTERN.h            \
3001         $(PERL_INC)/XSUB.h              \
3002         $(PERL_INC)/av.h                \
3003         $(PERL_INC)/cc_runtime.h        \
3004         $(PERL_INC)/config.h            \
3005         $(PERL_INC)/cop.h               \
3006         $(PERL_INC)/cv.h                \
3007         $(PERL_INC)/dosish.h            \
3008         $(PERL_INC)/embed.h             \
3009         $(PERL_INC)/embedvar.h          \
3010         $(PERL_INC)/fakethr.h           \
3011         $(PERL_INC)/form.h              \
3012         $(PERL_INC)/gv.h                \
3013         $(PERL_INC)/handy.h             \
3014         $(PERL_INC)/hv.h                \
3015         $(PERL_INC)/intrpvar.h          \
3016         $(PERL_INC)/iperlsys.h          \
3017         $(PERL_INC)/keywords.h          \
3018         $(PERL_INC)/mg.h                \
3019         $(PERL_INC)/nostdio.h           \
3020         $(PERL_INC)/op.h                \
3021         $(PERL_INC)/opcode.h            \
3022         $(PERL_INC)/opnames.h           \
3023         $(PERL_INC)/patchlevel.h        \
3024         $(PERL_INC)/perl.h              \
3025         $(PERL_INC)/perlapi.h           \
3026         $(PERL_INC)/perlio.h            \
3027         $(PERL_INC)/perlsdio.h          \
3028         $(PERL_INC)/perlsfio.h          \
3029         $(PERL_INC)/perlvars.h          \
3030         $(PERL_INC)/perly.h             \
3031         $(PERL_INC)/pp.h                \
3032         $(PERL_INC)/pp_proto.h          \
3033         $(PERL_INC)/proto.h             \
3034         $(PERL_INC)/regcomp.h           \
3035         $(PERL_INC)/regexp.h            \
3036         $(PERL_INC)/regnodes.h          \
3037         $(PERL_INC)/scope.h             \
3038         $(PERL_INC)/sv.h                \
3039         $(PERL_INC)/thrdvar.h           \
3040         $(PERL_INC)/thread.h            \
3041         $(PERL_INC)/unixish.h           \
3042         $(PERL_INC)/utf8.h              \
3043         $(PERL_INC)/util.h              \
3044         $(PERL_INC)/warnings.h
3045
3046 $(OBJECT) : $(PERL_HDRS)
3047 } if $self->{OBJECT};
3048
3049     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
3050
3051     join "\n", @m;
3052 }
3053
3054
3055 =item perm_rw (o)
3056
3057 Returns the attribute C<PERM_RW> or the string C<644>.
3058 Used as the string that is passed
3059 to the C<chmod> command to set the permissions for read/writeable files.
3060 MakeMaker chooses C<644> because it has turned out in the past that
3061 relying on the umask provokes hard-to-track bug reports.
3062 When the return value is used by the perl function C<chmod>, it is
3063 interpreted as an octal value.
3064
3065 =cut
3066
3067 sub perm_rw {
3068     shift->{PERM_RW} || "644";
3069 }
3070
3071 =item perm_rwx (o)
3072
3073 Returns the attribute C<PERM_RWX> or the string C<755>,
3074 i.e. the string that is passed
3075 to the C<chmod> command to set the permissions for executable files.
3076 See also perl_rw.
3077
3078 =cut
3079
3080 sub perm_rwx {
3081     shift->{PERM_RWX} || "755";
3082 }
3083
3084 =item pm_to_blib
3085
3086 Defines target that copies all files in the hash PM to their
3087 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3088
3089 =cut
3090
3091 sub _pm_to_blib_flush {
3092     my ($self, $autodir, $rr, $ra, $rl) = @_;
3093     $$rr .=
3094 q{      }.$self->{NOECHO}.q[$(PERLRUNINST) "-MExtUtils::Install" \
3095         -e "pm_to_blib({qw{].qq[@$ra].q[}},'].$autodir.q{','$(PM_FILTER)')"
3096 };
3097     @$ra = ();
3098     $$rl = 0;
3099 }
3100
3101 sub pm_to_blib {
3102     my $self = shift;
3103     my($autodir) = File::Spec->catdir('$(INST_LIB)','auto');
3104     my $r = q{
3105 pm_to_blib: $(TO_INST_PM)
3106 };
3107     my %pm_to_blib = %{$self->{PM}};
3108     my @a;
3109     my $l = 0;
3110     while (my ($pm, $blib) = each %pm_to_blib) {
3111         my $la = length $pm;
3112         my $lb = length $blib;
3113         if ($l + $la + $lb + @a / 2 > 200) { # limit line length
3114             _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
3115         }
3116         push @a, $pm, $blib;
3117         $l += $la + $lb;
3118     }
3119     _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
3120     return $r.q{        }.$self->{NOECHO}.q{$(TOUCH) $@};
3121 }
3122
3123 =item post_constants (o)
3124
3125 Returns an empty string per default. Dedicated to overrides from
3126 within Makefile.PL after all constants have been defined.
3127
3128 =cut
3129
3130 sub post_constants{
3131     my($self) = shift;
3132     "";
3133 }
3134
3135 =item post_initialize (o)
3136
3137 Returns an empty string per default. Used in Makefile.PLs to add some
3138 chunk of text to the Makefile after the object is initialized.
3139
3140 =cut
3141
3142 sub post_initialize {
3143     my($self) = shift;
3144     "";
3145 }
3146
3147 =item postamble (o)
3148
3149 Returns an empty string. Can be used in Makefile.PLs to write some
3150 text to the Makefile at the end.
3151
3152 =cut
3153
3154 sub postamble {
3155     my($self) = shift;
3156     "";
3157 }
3158
3159 =item ppd
3160
3161 Defines target that creates a PPD (Perl Package Description) file
3162 for a binary distribution.
3163
3164 =cut
3165
3166 sub ppd {
3167     my($self) = @_;
3168
3169     if ($self->{ABSTRACT_FROM}){
3170         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
3171             carp "WARNING: Setting ABSTRACT via file ".
3172                  "'$self->{ABSTRACT_FROM}' failed\n";
3173     }
3174
3175     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3];
3176
3177     my $abstract = $self->{ABSTRACT} || '';
3178     $abstract =~ s/\n/\\n/sg;
3179     $abstract =~ s/</&lt;/g;
3180     $abstract =~ s/>/&gt;/g;
3181
3182     my $author = $self->{AUTHOR} || '';
3183     $author =~ s/</&lt;/g;
3184     $author =~ s/>/&gt;/g;
3185     $author =~ s/@/\\@/g;
3186
3187     my $make_ppd = sprintf <<'PPD_OUT', $pack_ver, $abstract, $author;
3188 # Creates a PPD (Perl Package Description) for a binary distribution.
3189 ppd:
3190         @$(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
3191 PPD_OUT
3192
3193
3194     $make_ppd .= '      @$(PERL) -e "print qq{\t<IMPLEMENTATION>\n';
3195     foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
3196         my $pre_req = $prereq;
3197         $pre_req =~ s/::/-/g;
3198         my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}),
3199                                   (0) x 4) [0 .. 3];
3200         $make_ppd .= sprintf q{\t\t<DEPENDENCY NAME=\"%s\" VERSION=\"%s\" />\n}, $pre_req, $dep_ver;
3201     }
3202     $make_ppd .= qq[}" >> \$(DISTNAME).ppd\n];
3203
3204
3205     $make_ppd .= sprintf <<'PPD_OUT', $Config{archname};
3206         @$(PERL) -e "print qq{\t\t<OS NAME=\"$(OSNAME)\" />\n\t\t<ARCHITECTURE NAME=\"%s\" />\n
3207 PPD_OUT
3208
3209     chomp $make_ppd;
3210
3211
3212     if ($self->{PPM_INSTALL_SCRIPT}) {
3213         if ($self->{PPM_INSTALL_EXEC}) {
3214             $make_ppd .= sprintf q{\t\t<INSTALL EXEC=\"%s\">%s</INSTALL>\n},
3215                   $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT};
3216         }
3217         else {
3218             $make_ppd .= sprintf q{\t\t<INSTALL>%s</INSTALL>\n},
3219                   $self->{PPM_INSTALL_SCRIPT};
3220         }
3221     }
3222
3223     my ($bin_location) = $self->{BINARY_LOCATION} || '';
3224     $bin_location =~ s/\\/\\\\/g;
3225
3226     $make_ppd .= sprintf q{\t\t<CODEBASE HREF=\"%s\" />\n}, $bin_location;
3227     $make_ppd .= q{\t</IMPLEMENTATION>\n};
3228     $make_ppd .= q{</SOFTPKG>\n};
3229
3230     $make_ppd .= '}" >> $(DISTNAME).ppd';
3231
3232     return $make_ppd;
3233 }
3234
3235 =item prefixify
3236
3237   $MM->prefixify($var, $prefix, $new_prefix, $default);
3238
3239 Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to
3240 replace it's $prefix with a $new_prefix.  Should the $prefix fail to
3241 match it sill simply set it to the $new_prefix + $default.
3242
3243 This is for heuristics which attempt to create directory structures
3244 that mirror those of the installed perl.
3245
3246 For example:
3247
3248     $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1');
3249
3250 this will attempt to remove '/usr' from the front of the
3251 $MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir}
3252 if necessary) and replace it with '/home/foo'.  If this fails it will
3253 simply use '/home/foo/man/man1'.
3254
3255 =cut
3256
3257 sub prefixify {
3258     my($self,$var,$sprefix,$rprefix,$default) = @_;
3259
3260     my $path = $self->{uc $var} ||
3261                $Config_Override{lc $var} || $Config{lc $var} || '';
3262
3263     print STDERR "  prefixify $var => $path\n" if $Verbose >= 2;
3264     print STDERR "    from $sprefix to $rprefix\n" if $Verbose >= 2;
3265
3266     unless( $path =~ s{^\Q$sprefix\E\b}{$rprefix}s ) {
3267
3268         print STDERR "    cannot prefix, using default.\n" if $Verbose >= 2;
3269         print STDERR "    no default!\n" if !$default && $Verbose >= 2;
3270
3271         $path = File::Spec->catdir($rprefix, $default) if $default;
3272     }
3273
3274     print "    now $path\n" if $Verbose >= 2;
3275     return $self->{uc $var} = $path;
3276 }
3277
3278
3279 =item processPL (o)
3280
3281 Defines targets to run *.PL files.
3282
3283 =cut
3284
3285 sub processPL {
3286     my($self) = shift;
3287     return "" unless $self->{PL_FILES};
3288     my(@m, $plfile);
3289     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3290         my $list = ref($self->{PL_FILES}->{$plfile})
3291                 ? $self->{PL_FILES}->{$plfile}
3292                 : [$self->{PL_FILES}->{$plfile}];
3293         my $target;
3294         foreach $target (@$list) {
3295         push @m, "
3296 all :: $target
3297         $self->{NOECHO}\$(NOOP)
3298
3299 $target :: $plfile
3300         \$(PERLRUNINST) $plfile $target
3301 ";
3302         }
3303     }
3304     join "", @m;
3305 }
3306
3307 =item quote_paren
3308
3309 Backslashes parentheses C<()> in command line arguments.
3310 Doesn't handle recursive Makefile C<$(...)> constructs,
3311 but handles simple ones.
3312
3313 =cut
3314
3315 sub quote_paren {
3316     local $_ = shift;
3317     s/\$\((.+?)\)/\$\\\\($1\\\\)/g;     # protect $(...)
3318     s/(?<!\\)([()])/\\$1/g;             # quote unprotected
3319     s/\$\\\\\((.+?)\\\\\)/\$($1)/g;     # unprotect $(...)
3320     return $_;
3321 }
3322
3323 =item realclean (o)
3324
3325 Defines the realclean target.
3326
3327 =cut
3328
3329 sub realclean {
3330     my($self, %attribs) = @_;
3331     my(@m);
3332
3333     push(@m,'
3334 # Delete temporary files (via clean) and also delete installed files
3335 realclean purge ::  clean
3336 ');
3337     # realclean subdirectories first (already cleaned)
3338     my $sub;
3339     if( $Is_Win32  &&  Win32::IsWin95() ) {
3340         $sub = <<'REALCLEAN';
3341         -cd %s
3342         -$(PERLRUN) -e "exit unless -f shift; system q{$(MAKE) realclean}" %s
3343         -cd ..
3344 REALCLEAN
3345     }
3346     else {
3347         $sub = <<'REALCLEAN';
3348         -cd %s && $(TEST_F) %s && $(MAKE) %s realclean
3349 REALCLEAN
3350     }
3351
3352     foreach(@{$self->{DIR}}){
3353         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3354         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3355     }
3356     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3357     push(@m, "  $self->{RM_RF} \$(DISTVNAME)\n");
3358     if( $self->has_link_code ){
3359         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3360         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
3361     }
3362     # Issue a several little RM_F commands rather than risk creating a
3363     # very long command line (useful for extensions such as Encode
3364     # that have many files).
3365     if (keys %{$self->{PM}}) {
3366         my $line = "";
3367         foreach (values %{$self->{PM}}) {
3368             if (length($line) + length($_) > 80) {
3369                 push @m, "\t$self->{RM_F} $line\n";
3370                 $line = $_;
3371             }
3372             else {
3373                 $line .= " $_";
3374             }
3375         }
3376     push @m, "\t$self->{RM_F} $line\n" if $line;
3377     }
3378     my(@otherfiles) = ($self->{MAKEFILE},
3379                        "$self->{MAKEFILE}.old"); # Makefiles last
3380     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3381     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
3382     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
3383     join("", @m);
3384 }
3385
3386 =item replace_manpage_separator
3387
3388   my $man_name = $MM->replace_manpage_separator($file_path);
3389
3390 Takes the name of a package, which may be a nested package, in the
3391 form 'Foo/Bar.pm' and replaces the slash with C<::> or something else
3392 safe for a man page file name.  Returns the replacement.
3393
3394 =cut
3395
3396 sub replace_manpage_separator {
3397     my($self,$man) = @_;
3398
3399     $man =~ s,/+,::,g;
3400     return $man;
3401 }
3402
3403 =item static (o)
3404
3405 Defines the static target.
3406
3407 =cut
3408
3409 sub static {
3410 # --- Static Loading Sections ---
3411
3412     my($self) = shift;
3413     '
3414 ## $(INST_PM) has been moved to the all: target.
3415 ## It remains here for awhile to allow for old usage: "make static"
3416 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3417 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3418         '.$self->{NOECHO}.'$(NOOP)
3419 ';
3420 }
3421
3422 =item static_lib (o)
3423
3424 Defines how to produce the *.a (or equivalent) files.
3425
3426 =cut
3427
3428 sub static_lib {
3429     my($self) = @_;
3430 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3431 #    return '' unless $self->needs_linking(); #might be because of a subdir
3432
3433     return '' unless $self->has_link_code;
3434
3435     my(@m);
3436     push(@m, <<'END');
3437 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3438         $(RM_RF) $@
3439 END
3440     # If this extension has its own library (eg SDBM_File)
3441     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3442     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3443
3444     my $ar;
3445     if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3446         # Prefer the absolute pathed ar if available so that PATH
3447         # doesn't confuse us.  Perl itself is built with the full_ar.
3448         $ar = 'FULL_AR';
3449     } else {
3450         $ar = 'AR';
3451     }
3452     push @m,
3453         "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3454     push @m,
3455 q{      $(CHMOD) $(PERM_RWX) $@
3456         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3457 };
3458     # Old mechanism - still available:
3459     push @m,
3460 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3461 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
3462     push @m, "\n";
3463
3464     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3465     join('', "\n",@m);
3466 }
3467
3468 =item staticmake (o)
3469
3470 Calls makeaperl.
3471
3472 =cut
3473
3474 sub staticmake {
3475     my($self, %attribs) = @_;
3476     my(@static);
3477
3478     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3479
3480     # And as it's not yet built, we add the current extension
3481     # but only if it has some C code (or XS code, which implies C code)
3482     if (@{$self->{C}}) {
3483         @static = File::Spec->catfile($self->{INST_ARCHLIB},
3484                                  "auto",
3485                                  $self->{FULLEXT},
3486                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3487                                 );
3488     }
3489
3490     # Either we determine now, which libraries we will produce in the
3491     # subdirectories or we do it at runtime of the make.
3492
3493     # We could ask all subdir objects, but I cannot imagine, why it
3494     # would be necessary.
3495
3496     # Instead we determine all libraries for the new perl at
3497     # runtime.
3498     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3499
3500     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3501                      DIRS       => \@searchdirs,
3502                      STAT       => \@static,
3503                      INCL       => \@perlinc,
3504                      TARGET     => $self->{MAP_TARGET},
3505                      TMP        => "",
3506                      LIBPERL    => $self->{LIBPERL_A}
3507                     );
3508 }
3509
3510 =item subdir_x (o)
3511
3512 Helper subroutine for subdirs
3513
3514 =cut
3515
3516 sub subdir_x {
3517     my($self, $subdir) = @_;
3518     my(@m);
3519     if ($Is_Win32 && Win32::IsWin95()) {
3520         if ($Config{'make'} =~ /dmake/i) {
3521             # dmake-specific
3522             return <<EOT;
3523 subdirs ::
3524 @[
3525         cd $subdir
3526         \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3527         cd ..
3528 ]
3529 EOT
3530         } elsif ($Config{'make'} =~ /nmake/i) {
3531             # nmake-specific
3532             return <<EOT;
3533 subdirs ::
3534         cd $subdir
3535         \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3536         cd ..
3537 EOT
3538         }
3539     } else {
3540         return <<EOT;
3541
3542 subdirs ::
3543         $self->{NOECHO}cd $subdir && \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3544 EOT
3545     }
3546 }
3547
3548 =item subdirs (o)
3549
3550 Defines targets to process subdirectories.
3551
3552 =cut
3553
3554 sub subdirs {
3555 # --- Sub-directory Sections ---
3556     my($self) = shift;
3557     my(@m,$dir);
3558     # This method provides a mechanism to automatically deal with
3559     # subdirectories containing further Makefile.PL scripts.
3560     # It calls the subdir_x() method for each subdirectory.
3561     foreach $dir (@{$self->{DIR}}){
3562         push(@m, $self->subdir_x($dir));
3563 ####    print "Including $dir subdirectory\n";
3564     }
3565     if (@m){
3566         unshift(@m, "
3567 # The default clean, realclean and test targets in this Makefile
3568 # have automatically been given entries for each subdir.
3569
3570 ");
3571     } else {
3572         push(@m, "\n# none")
3573     }
3574     join('',@m);
3575 }
3576
3577 =item test (o)
3578
3579 Defines the test targets.
3580
3581 =cut
3582
3583 sub test {
3584 # --- Test and Installation Sections ---
3585
3586     my($self, %attribs) = @_;
3587     my $tests = $attribs{TESTS} || '';
3588     if (!$tests && -d 't') {
3589         $tests = $self->find_tests;
3590     }
3591     # note: 'test.pl' name is also hardcoded in init_dirscan()
3592     my(@m);
3593     push(@m,"
3594 TEST_VERBOSE=0
3595 TEST_TYPE=test_\$(LINKTYPE)
3596 TEST_FILE = test.pl
3597 TEST_FILES = $tests
3598 TESTDB_SW = -d
3599
3600 testdb :: testdb_\$(LINKTYPE)
3601
3602 test :: \$(TEST_TYPE)
3603 ");
3604
3605     if ($Is_Win32 && Win32::IsWin95()) {
3606         push(@m, map(qq{\t$self->{NOECHO}\$(PERLRUN) -e "exit unless -f shift; chdir '$_'; system q{\$(MAKE) test \$(PASTHRU)}" $self->{MAKEFILE}\n}, @{$self->{DIR}}));
3607     }
3608     else {
3609         push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n", @{$self->{DIR}}));
3610     }
3611
3612     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3613         unless $tests or -f "test.pl" or @{$self->{DIR}};
3614     push(@m, "\n");
3615
3616     push(@m, "test_dynamic :: pure_all\n");
3617     push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)'))
3618       if $tests;
3619     push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)'))
3620       if -f "test.pl";
3621     push(@m, "\n");
3622
3623     push(@m, "testdb_dynamic :: pure_all\n");
3624     push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)',
3625                                     '$(TEST_FILE)'));
3626     push(@m, "\n");
3627
3628     # Occasionally we may face this degenerate target:
3629     push @m, "test_ : test_dynamic\n\n";
3630
3631     if ($self->needs_linking()) {
3632         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3633         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3634         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3635         push(@m, "\n");
3636         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3637         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3638         push(@m, "\n");
3639     } else {
3640         push @m, "test_static :: test_dynamic\n";
3641         push @m, "testdb_static :: testdb_dynamic\n";
3642     }
3643     join("", @m);
3644 }
3645
3646 =item test_via_harness (override)
3647
3648 For some reason which I forget, Unix machines like to have
3649 PERL_DL_NONLAZY set for tests.
3650
3651 =cut
3652
3653 sub test_via_harness {
3654     my($self, $perl, $tests) = @_;
3655     return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests);
3656 }
3657
3658 =item test_via_script (override)
3659
3660 Again, the PERL_DL_NONLAZY thing.
3661
3662 =cut
3663
3664 sub test_via_script {
3665     my($self, $perl, $script) = @_;
3666     return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script);
3667 }
3668
3669 =item tool_autosplit (o)
3670
3671 Defines a simple perl call that runs autosplit. May be deprecated by
3672 pm_to_blib soon.
3673
3674 =cut
3675
3676 sub tool_autosplit {
3677     my($self, %attribs) = @_;
3678     my($asl) = "";
3679     $asl = "\$\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3680
3681     return sprintf <<'MAKE_FRAG', $asl;
3682 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3683 AUTOSPLITFILE = $(PERLRUN) -e 'use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3684
3685 MAKE_FRAG
3686
3687 }
3688
3689 =item tools_other (o)
3690
3691 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3692 the Makefile. Also defines the perl programs MKPATH,
3693 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3694
3695 =cut
3696
3697 sub tools_other {
3698     my($self) = shift;
3699     my @m;
3700     my $bin_sh = $Config{sh} || '/bin/sh';
3701     push @m, qq{
3702 SHELL = $bin_sh
3703 };
3704
3705     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3706         push @m, "$_ = $self->{$_}\n";
3707     }
3708
3709     push @m, q{
3710 # The following is a portable way to say mkdir -p
3711 # To see which directories are created, change the if 0 to if 1
3712 MKPATH = $(PERLRUN) "-MExtUtils::Command" -e mkpath
3713
3714 # This helps us to minimize the effect of the .exists files A yet
3715 # better solution would be to have a stable file in the perl
3716 # distribution with a timestamp of zero. But this solution doesn't
3717 # need any changes to the core distribution and works with older perls
3718 EQUALIZE_TIMESTAMP = $(PERLRUN) "-MExtUtils::Command" -e eqtime
3719 };
3720
3721
3722     return join "", @m if $self->{PARENT};
3723
3724     push @m, q{
3725 # Here we warn users that an old packlist file was found somewhere,
3726 # and that they should call some uninstall routine
3727 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3728 -e 'print "WARNING: I have found an old package in\n";' \\
3729 -e 'print "\t$$ARGV[0].\n";' \\
3730 -e 'print "Please make sure the two installations are not conflicting\n";'
3731
3732 UNINST=0
3733 VERBINST=0
3734
3735 MOD_INSTALL = $(PERL) "-I$(INST_LIB)" "-I$(PERL_LIB)" "-MExtUtils::Install" \
3736 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3737
3738 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3739 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3740 -e 'print "=over 4";' \
3741 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3742 -e 'print "=back";'
3743
3744 UNINSTALL =   $(PERLRUN) "-MExtUtils::Install" \
3745 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3746 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3747 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3748 };
3749
3750     return join "", @m;
3751 }
3752
3753 =item tool_xsubpp (o)
3754
3755 Determines typemaps, xsubpp version, prototype behaviour.
3756
3757 =cut
3758
3759 sub tool_xsubpp {
3760     my($self) = shift;
3761     return "" unless $self->needs_linking;
3762     my($xsdir)  = File::Spec->catdir($self->{PERL_LIB},"ExtUtils");
3763     my(@tmdeps) = File::Spec->catdir('$(XSUBPPDIR)','typemap');
3764     if( $self->{TYPEMAPS} ){
3765         my $typemap;
3766         foreach $typemap (@{$self->{TYPEMAPS}}){
3767                 if( ! -f  $typemap ){
3768                         warn "Typemap $typemap not found.\n";
3769                 }
3770                 else{
3771                         push(@tmdeps,  $typemap);
3772                 }
3773         }
3774     }
3775     push(@tmdeps, "typemap") if -f "typemap";
3776     my(@tmargs) = map("-typemap $_", @tmdeps);
3777     if( exists $self->{XSOPT} ){
3778         unshift( @tmargs, $self->{XSOPT} );
3779     }
3780
3781
3782     my $xsubpp_version = $self->xsubpp_version(File::Spec->catfile($xsdir,"xsubpp"));
3783
3784     # What are the correct thresholds for version 1 && 2 Paul?
3785     if ( $xsubpp_version > 1.923 ){
3786         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3787     } else {
3788         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3789             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3790         Your version of xsubpp is $xsubpp_version and cannot handle this.
3791         Please upgrade to a more recent version of xsubpp.
3792 };
3793         } else {
3794             $self->{XSPROTOARG} = "";
3795         }
3796     }
3797
3798     my $xsubpp = "xsubpp";
3799
3800     return qq{
3801 XSUBPPDIR = $xsdir
3802 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3803 XSPROTOARG = $self->{XSPROTOARG}
3804 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3805 XSUBPPARGS = @tmargs
3806 XSUBPP_EXTRA_ARGS =
3807 };
3808 };
3809
3810 sub xsubpp_version
3811 {
3812     my($self,$xsubpp) = @_;
3813     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3814
3815     my ($version) ;
3816
3817     # try to figure out the version number of the xsubpp on the system
3818
3819     # first try the -v flag, introduced in 1.921 & 2.000a2
3820
3821     return "" unless $self->needs_linking;
3822
3823     my $command = qq{$self->{PERL} "-I$self->{PERL_LIB}" $xsubpp -v 2>&1};
3824     print "Running $command\n" if $Verbose >= 2;
3825     $version = `$command` ;
3826     warn "Running '$command' exits with status " . ($?>>8) if $?;
3827     chop $version ;
3828
3829     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3830
3831     # nope, then try something else
3832
3833     my $counter = '000';
3834     my ($file) = 'temp' ;
3835     $counter++ while -e "$file$counter"; # don't overwrite anything
3836     $file .= $counter;
3837
3838     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3839     print F <<EOM ;
3840 MODULE = fred PACKAGE = fred
3841
3842 int
3843 fred(a)
3844         int     a;
3845 EOM
3846
3847     close F ;
3848
3849     $command = "$self->{PERL} $xsubpp $file 2>&1";
3850     print "Running $command\n" if $Verbose >= 2;
3851     my $text = `$command` ;
3852     warn "Running '$command' exits with status " . ($?>>8) if $?;
3853     unlink $file ;
3854
3855     # gets 1.2 -> 1.92 and 2.000a1
3856     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3857
3858     # it is either 1.0 or 1.1
3859     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3860
3861     # none of the above, so 1.0
3862     return $Xsubpp_Version = "1.0" ;
3863 }
3864
3865 =item top_targets (o)
3866
3867 Defines the targets all, subdirs, config, and O_FILES
3868
3869 =cut
3870
3871 sub top_targets {
3872 # --- Target Sections ---
3873
3874     my($self) = shift;
3875     my(@m);
3876
3877     push @m, '
3878 all :: pure_all manifypods
3879         '.$self->{NOECHO}.'$(NOOP)
3880 '
3881           unless $self->{SKIPHASH}{'all'};
3882
3883     push @m, '
3884 pure_all :: config pm_to_blib subdirs linkext
3885         '.$self->{NOECHO}.'$(NOOP)
3886
3887 subdirs :: $(MYEXTLIB)
3888         '.$self->{NOECHO}.'$(NOOP)
3889
3890 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3891         '.$self->{NOECHO}.'$(NOOP)
3892
3893 config :: $(INST_ARCHAUTODIR)/.exists
3894         '.$self->{NOECHO}.'$(NOOP)
3895
3896 config :: $(INST_AUTODIR)/.exists
3897         '.$self->{NOECHO}.'$(NOOP)
3898 ';
3899
3900     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3901
3902     if (%{$self->{MAN1PODS}}) {
3903         push @m, qq[
3904 config :: \$(INST_MAN1DIR)/.exists
3905         $self->{NOECHO}\$(NOOP)
3906
3907 ];
3908         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3909     }
3910     if (%{$self->{MAN3PODS}}) {
3911         push @m, qq[
3912 config :: \$(INST_MAN3DIR)/.exists
3913         $self->{NOECHO}\$(NOOP)
3914
3915 ];
3916         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3917     }
3918
3919     push @m, '
3920 $(O_FILES): $(H_FILES)
3921 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3922
3923     push @m, q{
3924 help:
3925         perldoc ExtUtils::MakeMaker
3926 };
3927
3928     join('',@m);
3929 }
3930
3931 =item writedoc
3932
3933 Obsolete, deprecated method. Not used since Version 5.21.
3934
3935 =cut
3936
3937 sub writedoc {
3938 # --- perllocal.pod section ---
3939     my($self,$what,$name,@attribs)=@_;
3940     my $time = localtime;
3941     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3942     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3943     print "\n\n=back\n\n";
3944 }
3945
3946 =item xs_c (o)
3947
3948 Defines the suffix rules to compile XS files to C.
3949
3950 =cut
3951
3952 sub xs_c {
3953     my($self) = shift;
3954     return '' unless $self->needs_linking();
3955     '
3956 .xs.c:
3957         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3958 ';
3959 }
3960
3961 =item xs_cpp (o)
3962
3963 Defines the suffix rules to compile XS files to C++.
3964
3965 =cut
3966
3967 sub xs_cpp {
3968     my($self) = shift;
3969     return '' unless $self->needs_linking();
3970     '
3971 .xs.cpp:
3972         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3973 ';
3974 }
3975
3976 =item xs_o (o)
3977
3978 Defines suffix rules to go from XS to object files directly. This is
3979 only intended for broken make implementations.
3980
3981 =cut
3982
3983 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3984     my($self) = shift;
3985     return '' unless $self->needs_linking();
3986     '
3987 .xs$(OBJ_EXT):
3988         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3989         $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c
3990 ';
3991 }
3992
3993 =item perl_archive
3994
3995 This is internal method that returns path to libperl.a equivalent
3996 to be linked to dynamic extensions. UNIX does not have one but other
3997 OSs might have one.
3998
3999 =cut
4000
4001 sub perl_archive
4002 {
4003  return "";
4004 }
4005
4006 =item perl_archive_after
4007
4008 This is an internal method that returns path to a library which
4009 should be put on the linker command line I<after> the external libraries
4010 to be linked to dynamic extensions.  This may be needed if the linker
4011 is one-pass, and Perl includes some overrides for C RTL functions,
4012 such as malloc().
4013
4014 =cut
4015
4016 sub perl_archive_after
4017 {
4018  return "";
4019 }
4020
4021 =item export_list
4022
4023 This is internal method that returns name of a file that is
4024 passed to linker to define symbols to be exported.
4025 UNIX does not have one but OS2 and Win32 do.
4026
4027 =cut
4028
4029 sub export_list
4030 {
4031  return "";
4032 }
4033
4034
4035 1;
4036
4037 =back
4038
4039 =head1 SEE ALSO
4040
4041 L<ExtUtils::MakeMaker>
4042
4043 =cut
4044
4045 __END__