lib/ExtUtils/MM_Unix.pm

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