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