lib/ExtUtils/MM_Unix.pm

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