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 if /^\s*?\#/;
2791         next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2792         my $eval = qq{
2793             package ExtUtils::MakeMaker::_version;
2794             no strict;
2795
2796             local $1$2;
2797             \$$2=undef; do {
2798                 $_
2799             }; \$$2
2800         };
2801         no warnings;
2802         $result = eval($eval);
2803         warn "Could not eval '$eval' in $parsefile: $@" if $@;
2804         $result = "undef" unless defined $result;
2805         last;
2806     }
2807     close FH;
2808     return $result;
2809 }
2810
2811 =item parse_abstract
2812
2813 parse a file and return what you think is the ABSTRACT
2814
2815 =cut
2816
2817 sub parse_abstract {
2818     my($self,$parsefile) = @_;
2819     my $result;
2820     local *FH;
2821     local $/ = "\n";
2822     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2823     my $inpod = 0;
2824     my $package = $self->{DISTNAME};
2825     $package =~ s/-/::/g;
2826     while (<FH>) {
2827         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2828         next if !$inpod;
2829         chop;
2830         next unless /^($package\s-\s)(.*)/;
2831         $result = $2;
2832         last;
2833     }
2834     close FH;
2835     return $result;
2836 }
2837
2838 =item pasthru (o)
2839
2840 Defines the string that is passed to recursive make calls in
2841 subdirectories.
2842
2843 =cut
2844
2845 sub pasthru {
2846     my($self) = shift;
2847     my(@m,$key);
2848
2849     my(@pasthru);
2850     my($sep) = $Is_VMS ? ',' : '';
2851     $sep .= "\\\n\t";
2852
2853     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
2854         push @pasthru, "$key=\"\$($key)\"";
2855     }
2856
2857     foreach $key (qw(DEFINE INC)) {
2858         push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
2859     }
2860
2861     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2862     join "", @m;
2863 }
2864
2865 =item path
2866
2867 Takes no argument, returns the environment variable PATH as an array.
2868
2869 =cut
2870
2871 sub path {
2872     my($self) = @_;
2873     my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2874     my $path = $ENV{PATH};
2875     $path =~ s:\\:/:g if $Is_OS2;
2876     my @path = split $path_sep, $path;
2877     foreach(@path) { $_ = '.' if $_ eq '' }
2878     @path;
2879 }
2880
2881 =item perl_script
2882
2883 Takes one argument, a file name, and returns the file name, if the
2884 argument is likely to be a perl script. On MM_Unix this is true for
2885 any ordinary, readable file.
2886
2887 =cut
2888
2889 sub perl_script {
2890     my($self,$file) = @_;
2891     return $file if -r $file && -f _;
2892     return;
2893 }
2894
2895 =item perldepend (o)
2896
2897 Defines the dependency from all *.h files that come with the perl
2898 distribution.
2899
2900 =cut
2901
2902 sub perldepend {
2903     my($self) = shift;
2904     my(@m);
2905     push @m, q{
2906 # Check for unpropogated config.sh changes. Should never happen.
2907 # We do NOT just update config.h because that is not sufficient.
2908 # An out of date config.h is not fatal but complains loudly!
2909 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2910         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2911
2912 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2913         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2914         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2915 } if $self->{PERL_SRC};
2916
2917     return join "", @m unless $self->needs_linking;
2918
2919     push @m, q{
2920 PERL_HDRS = \
2921         $(PERL_INC)/EXTERN.h            \
2922         $(PERL_INC)/INTERN.h            \
2923         $(PERL_INC)/XSUB.h              \
2924         $(PERL_INC)/av.h                \
2925         $(PERL_INC)/cc_runtime.h        \
2926         $(PERL_INC)/config.h            \
2927         $(PERL_INC)/cop.h               \
2928         $(PERL_INC)/cv.h                \
2929         $(PERL_INC)/dosish.h            \
2930         $(PERL_INC)/embed.h             \
2931         $(PERL_INC)/embedvar.h          \
2932         $(PERL_INC)/fakethr.h           \
2933         $(PERL_INC)/form.h              \
2934         $(PERL_INC)/gv.h                \
2935         $(PERL_INC)/handy.h             \
2936         $(PERL_INC)/hv.h                \
2937         $(PERL_INC)/intrpvar.h          \
2938         $(PERL_INC)/iperlsys.h          \
2939         $(PERL_INC)/keywords.h          \
2940         $(PERL_INC)/mg.h                \
2941         $(PERL_INC)/nostdio.h           \
2942         $(PERL_INC)/op.h                \
2943         $(PERL_INC)/opcode.h            \
2944         $(PERL_INC)/opnames.h           \
2945         $(PERL_INC)/patchlevel.h        \
2946         $(PERL_INC)/perl.h              \
2947         $(PERL_INC)/perlapi.h           \
2948         $(PERL_INC)/perlio.h            \
2949         $(PERL_INC)/perlsdio.h          \
2950         $(PERL_INC)/perlsfio.h          \
2951         $(PERL_INC)/perlvars.h          \
2952         $(PERL_INC)/perly.h             \
2953         $(PERL_INC)/pp.h                \
2954         $(PERL_INC)/pp_proto.h          \
2955         $(PERL_INC)/proto.h             \
2956         $(PERL_INC)/regcomp.h           \
2957         $(PERL_INC)/regexp.h            \
2958         $(PERL_INC)/regnodes.h          \
2959         $(PERL_INC)/scope.h             \
2960         $(PERL_INC)/sv.h                \
2961         $(PERL_INC)/thrdvar.h           \
2962         $(PERL_INC)/thread.h            \
2963         $(PERL_INC)/unixish.h           \
2964         $(PERL_INC)/utf8.h              \
2965         $(PERL_INC)/util.h              \
2966         $(PERL_INC)/warnings.h
2967
2968 $(OBJECT) : $(PERL_HDRS)
2969 } if $self->{OBJECT};
2970
2971     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
2972
2973     join "\n", @m;
2974 }
2975
2976 =item ppd
2977
2978 Defines target that creates a PPD (Perl Package Description) file
2979 for a binary distribution.
2980
2981 =cut
2982
2983 sub ppd {
2984     my($self) = @_;
2985     my(@m);
2986     if ($self->{ABSTRACT_FROM}){
2987         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
2988             Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
2989     }
2990     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
2991     push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
2992     push(@m, "ppd:\n");
2993     push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
2994     push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
2995     my $abstract = $self->{ABSTRACT};
2996     $abstract =~ s/\n/\\n/sg;
2997     $abstract =~ s/</&lt;/g;
2998     $abstract =~ s/>/&gt;/g;
2999     push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
3000     my ($author) = $self->{AUTHOR};
3001     $author =~ s/</&lt;/g;
3002     $author =~ s/>/&gt;/g;
3003     $author =~ s/@/\\@/g;
3004     push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
3005     push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
3006     my ($prereq);
3007     foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
3008         my $pre_req = $prereq;
3009         $pre_req =~ s/::/-/g;
3010         my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}), (0) x 4) [0 .. 3];
3011         push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" VERSION=\\\"$dep_ver\\\" />\\n}");
3012     }
3013     push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
3014     push(@m, ". qq{\\t\\t<ARCHITECTURE NAME=\\\"$Config{'archname'}\\\" />\\n}");
3015     my ($bin_location) = $self->{BINARY_LOCATION};
3016     $bin_location =~ s/\\/\\\\/g;
3017     if ($self->{PPM_INSTALL_SCRIPT}) {
3018         if ($self->{PPM_INSTALL_EXEC}) {
3019             push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3020         }
3021         else {
3022             push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3023         }
3024     }
3025     push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
3026     push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
3027     push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
3028
3029     join("", @m);
3030 }
3031
3032 =item perm_rw (o)
3033
3034 Returns the attribute C<PERM_RW> or the string C<644>.
3035 Used as the string that is passed
3036 to the C<chmod> command to set the permissions for read/writeable files.
3037 MakeMaker chooses C<644> because it has turned out in the past that
3038 relying on the umask provokes hard-to-track bug reports.
3039 When the return value is used by the perl function C<chmod>, it is
3040 interpreted as an octal value.
3041
3042 =cut
3043
3044 sub perm_rw {
3045     shift->{PERM_RW} || "644";
3046 }
3047
3048 =item perm_rwx (o)
3049
3050 Returns the attribute C<PERM_RWX> or the string C<755>,
3051 i.e. the string that is passed
3052 to the C<chmod> command to set the permissions for executable files.
3053 See also perl_rw.
3054
3055 =cut
3056
3057 sub perm_rwx {
3058     shift->{PERM_RWX} || "755";
3059 }
3060
3061 =item pm_to_blib
3062
3063 Defines target that copies all files in the hash PM to their
3064 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3065
3066 =cut
3067
3068 sub pm_to_blib {
3069     my $self = shift;
3070     my($autodir) = $self->catdir('$(INST_LIB)','auto');
3071     return q{
3072 pm_to_blib: $(TO_INST_PM)
3073         }.$self->{NOECHO}.q{$(PERLRUNINST) -MExtUtils::Install \
3074         -e "pm_to_blib({qw{$(PM_TO_BLIB)}},'}.$autodir.q{','$(PM_FILTER)')"
3075         }.$self->{NOECHO}.q{$(TOUCH) $@
3076 };
3077 }
3078
3079 =item post_constants (o)
3080
3081 Returns an empty string per default. Dedicated to overrides from
3082 within Makefile.PL after all constants have been defined.
3083
3084 =cut
3085
3086 sub post_constants{
3087     my($self) = shift;
3088     "";
3089 }
3090
3091 =item post_initialize (o)
3092
3093 Returns an empty string per default. Used in Makefile.PLs to add some
3094 chunk of text to the Makefile after the object is initialized.
3095
3096 =cut
3097
3098 sub post_initialize {
3099     my($self) = shift;
3100     "";
3101 }
3102
3103 =item postamble (o)
3104
3105 Returns an empty string. Can be used in Makefile.PLs to write some
3106 text to the Makefile at the end.
3107
3108 =cut
3109
3110 sub postamble {
3111     my($self) = shift;
3112     "";
3113 }
3114
3115 =item prefixify
3116
3117 Check a path variable in $self from %Config, if it contains a prefix,
3118 and replace it with another one.
3119
3120 Takes as arguments an attribute name, a search prefix and a
3121 replacement prefix. Changes the attribute in the object.
3122
3123 =cut
3124
3125 sub prefixify {
3126     my($self,$var,$sprefix,$rprefix) = @_;
3127     $self->{uc $var} ||= $Config{lc $var};
3128     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
3129     $self->{uc $var} =~ s,^\Q$sprefix\E(?=/|\z),$rprefix,s;
3130 }
3131
3132 =item processPL (o)
3133
3134 Defines targets to run *.PL files.
3135
3136 =cut
3137
3138 sub processPL {
3139     my($self) = shift;
3140     return "" unless $self->{PL_FILES};
3141     my(@m, $plfile);
3142     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3143         my $list = ref($self->{PL_FILES}->{$plfile})
3144                 ? $self->{PL_FILES}->{$plfile}
3145                 : [$self->{PL_FILES}->{$plfile}];
3146         my $target;
3147         foreach $target (@$list) {
3148         push @m, "
3149 all :: $target
3150         $self->{NOECHO}\$(NOOP)
3151
3152 $target :: $plfile
3153         \$(PERLRUNINST) $plfile $target
3154 ";
3155         }
3156     }
3157     join "", @m;
3158 }
3159
3160 =item realclean (o)
3161
3162 Defines the realclean target.
3163
3164 =cut
3165
3166 sub realclean {
3167     my($self, %attribs) = @_;
3168     my(@m);
3169     push(@m,'
3170 # Delete temporary files (via clean) and also delete installed files
3171 realclean purge ::  clean
3172 ');
3173     # realclean subdirectories first (already cleaned)
3174     my $sub = ($Is_Win32  &&  Win32::IsWin95()) ?
3175       "\tcd %s\n\t\$(TEST_F) %s\n\t\$(MAKE) %s realclean\n\tcd ..\n" :
3176       "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
3177     foreach(@{$self->{DIR}}){
3178         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3179         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3180     }
3181     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3182     if( $self->has_link_code ){
3183         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3184         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
3185     }
3186     # Issue a several little RM_F commands rather than risk creating a
3187     # very long command line (useful for extensions such as Encode
3188     # that have many files).
3189     if (keys %{$self->{PM}}) {
3190         my $line = "";
3191         foreach (values %{$self->{PM}}) {
3192             if (length($line) + length($_) > 80) {
3193                 push @m, "\t$self->{RM_F} $line\n";
3194                 $line = $_;
3195             }
3196             else {
3197                 $line .= " $_";
3198             }
3199         }
3200     push @m, "\t$self->{RM_F} $line\n" if $line;
3201     }
3202     my(@otherfiles) = ($self->{MAKEFILE},
3203                        "$self->{MAKEFILE}.old"); # Makefiles last
3204     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3205     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
3206     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
3207     join("", @m);
3208 }
3209
3210 =item replace_manpage_separator
3211
3212 Takes the name of a package, which may be a nested package, in the
3213 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
3214
3215 =cut
3216
3217 sub replace_manpage_separator {
3218     my($self,$man) = @_;
3219         if ($^O eq 'uwin') {
3220             $man =~ s,/+,.,g;
3221         } elsif ($Is_Dos) {
3222             $man =~ s,/+,__,g;
3223         } else {
3224             $man =~ s,/+,::,g;
3225         }
3226     $man;
3227 }
3228
3229 =item static (o)
3230
3231 Defines the static target.
3232
3233 =cut
3234
3235 sub static {
3236 # --- Static Loading Sections ---
3237
3238     my($self) = shift;
3239     '
3240 ## $(INST_PM) has been moved to the all: target.
3241 ## It remains here for awhile to allow for old usage: "make static"
3242 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3243 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3244         '.$self->{NOECHO}.'$(NOOP)
3245 ';
3246 }
3247
3248 =item static_lib (o)
3249
3250 Defines how to produce the *.a (or equivalent) files.
3251
3252 =cut
3253
3254 sub static_lib {
3255     my($self) = @_;
3256 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3257 #    return '' unless $self->needs_linking(); #might be because of a subdir
3258
3259     return '' unless $self->has_link_code;
3260
3261     my(@m);
3262     push(@m, <<'END');
3263 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3264         $(RM_RF) $@
3265 END
3266     # If this extension has its own library (eg SDBM_File)
3267     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3268     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3269
3270     my $ar;
3271     if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3272         # Prefer the absolute pathed ar if available so that PATH
3273         # doesn't confuse us.  Perl itself is built with the full_ar.
3274         $ar = 'FULL_AR';
3275     } else {
3276         $ar = 'AR';
3277     }
3278     push @m,
3279         "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3280     push @m,
3281 q{      $(CHMOD) $(PERM_RWX) $@
3282         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3283 };
3284     # Old mechanism - still available:
3285     push @m,
3286 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3287 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
3288     push @m, "\n";
3289
3290     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3291     join('', "\n",@m);
3292 }
3293
3294 =item staticmake (o)
3295
3296 Calls makeaperl.
3297
3298 =cut
3299
3300 sub staticmake {
3301     my($self, %attribs) = @_;
3302     my(@static);
3303
3304     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3305
3306     # And as it's not yet built, we add the current extension
3307     # but only if it has some C code (or XS code, which implies C code)
3308     if (@{$self->{C}}) {
3309         @static = $self->catfile($self->{INST_ARCHLIB},
3310                                  "auto",
3311                                  $self->{FULLEXT},
3312                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3313                                 );
3314     }
3315
3316     # Either we determine now, which libraries we will produce in the
3317     # subdirectories or we do it at runtime of the make.
3318
3319     # We could ask all subdir objects, but I cannot imagine, why it
3320     # would be necessary.
3321
3322     # Instead we determine all libraries for the new perl at
3323     # runtime.
3324     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3325
3326     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3327                      DIRS       => \@searchdirs,
3328                      STAT       => \@static,
3329                      INCL       => \@perlinc,
3330                      TARGET     => $self->{MAP_TARGET},
3331                      TMP        => "",
3332                      LIBPERL    => $self->{LIBPERL_A}
3333                     );
3334 }
3335
3336 =item subdir_x (o)
3337
3338 Helper subroutine for subdirs
3339
3340 =cut
3341
3342 sub subdir_x {
3343     my($self, $subdir) = @_;
3344     my(@m);
3345     if ($Is_Win32 && Win32::IsWin95()) {
3346         if ($Config{'make'} =~ /dmake/i) {
3347             # dmake-specific
3348             return <<EOT;
3349 subdirs ::
3350 @[
3351         cd $subdir
3352         \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3353         cd ..
3354 ]
3355 EOT
3356         } elsif ($Config{'make'} =~ /nmake/i) {
3357             # nmake-specific
3358             return <<EOT;
3359 subdirs ::
3360         cd $subdir
3361         \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3362         cd ..
3363 EOT
3364         }
3365     } else {
3366         return <<EOT;
3367
3368 subdirs ::
3369         $self->{NOECHO}cd $subdir && \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3370 EOT
3371     }
3372 }
3373
3374 =item subdirs (o)
3375
3376 Defines targets to process subdirectories.
3377
3378 =cut
3379
3380 sub subdirs {
3381 # --- Sub-directory Sections ---
3382     my($self) = shift;
3383     my(@m,$dir);
3384     # This method provides a mechanism to automatically deal with
3385     # subdirectories containing further Makefile.PL scripts.
3386     # It calls the subdir_x() method for each subdirectory.
3387     foreach $dir (@{$self->{DIR}}){
3388         push(@m, $self->subdir_x($dir));
3389 ####    print "Including $dir subdirectory\n";
3390     }
3391     if (@m){
3392         unshift(@m, "
3393 # The default clean, realclean and test targets in this Makefile
3394 # have automatically been given entries for each subdir.
3395
3396 ");
3397     } else {
3398         push(@m, "\n# none")
3399     }
3400     join('',@m);
3401 }
3402
3403 =item test (o)
3404
3405 Defines the test targets.
3406
3407 =cut
3408
3409 sub test {
3410 # --- Test and Installation Sections ---
3411
3412     my($self, %attribs) = @_;
3413     my $tests = $attribs{TESTS};
3414     if (!$tests && -d 't') {
3415         $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3416     }
3417     # note: 'test.pl' name is also hardcoded in init_dirscan()
3418     my(@m);
3419     push(@m,"
3420 TEST_VERBOSE=0
3421 TEST_TYPE=test_\$(LINKTYPE)
3422 TEST_FILE = test.pl
3423 TEST_FILES = $tests
3424 TESTDB_SW = -d
3425
3426 testdb :: testdb_\$(LINKTYPE)
3427
3428 test :: \$(TEST_TYPE)
3429 ");
3430     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3431                  @{$self->{DIR}}));
3432     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3433         unless $tests or -f "test.pl" or @{$self->{DIR}};
3434     push(@m, "\n");
3435
3436     push(@m, "test_dynamic :: pure_all\n");
3437     push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3438     push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3439     push(@m, "\n");
3440
3441     push(@m, "testdb_dynamic :: pure_all\n");
3442     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3443     push(@m, "\n");
3444
3445     # Occasionally we may face this degenerate target:
3446     push @m, "test_ : test_dynamic\n\n";
3447
3448     if ($self->needs_linking()) {
3449         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3450         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3451         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3452         push(@m, "\n");
3453         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3454         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3455         push(@m, "\n");
3456     } else {
3457         push @m, "test_static :: test_dynamic\n";
3458         push @m, "testdb_static :: testdb_dynamic\n";
3459     }
3460     join("", @m);
3461 }
3462
3463 =item test_via_harness (o)
3464
3465 Helper method to write the test targets
3466
3467 =cut
3468
3469 sub test_via_harness {
3470     my($self, $perl, $tests) = @_;
3471     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3472     "\t$perl".q! $(TEST_LIBS) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' !."$tests\n";
3473 }
3474
3475 =item test_via_script (o)
3476
3477 Other helper method for test.
3478
3479 =cut
3480
3481 sub test_via_script {
3482     my($self, $perl, $script) = @_;
3483     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3484     qq{\t$perl}.q{ $(TEST_LIBS) }.qq{$script
3485 };
3486 }
3487
3488 =item tool_autosplit (o)
3489
3490 Defines a simple perl call that runs autosplit. May be deprecated by
3491 pm_to_blib soon.
3492
3493 =cut
3494
3495 sub tool_autosplit {
3496 # --- Tool Sections ---
3497
3498     my($self, %attribs) = @_;
3499     my($asl) = "";
3500     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3501     q{
3502 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3503 AUTOSPLITFILE = $(PERLRUN) -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3504 };
3505 }
3506
3507 =item tools_other (o)
3508
3509 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3510 the Makefile. Also defines the perl programs MKPATH,
3511 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3512
3513 =cut
3514
3515 sub tools_other {
3516     my($self) = shift;
3517     my @m;
3518     my $bin_sh = $Config{sh} || '/bin/sh';
3519     push @m, qq{
3520 SHELL = $bin_sh
3521 };
3522
3523     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3524         push @m, "$_ = $self->{$_}\n";
3525     }
3526
3527     push @m, q{
3528 # The following is a portable way to say mkdir -p
3529 # To see which directories are created, change the if 0 to if 1
3530 MKPATH = $(PERLRUN) -MExtUtils::Command -e mkpath
3531
3532 # This helps us to minimize the effect of the .exists files A yet
3533 # better solution would be to have a stable file in the perl
3534 # distribution with a timestamp of zero. But this solution doesn't
3535 # need any changes to the core distribution and works with older perls
3536 EQUALIZE_TIMESTAMP = $(PERLRUN) -MExtUtils::Command -e eqtime
3537 };
3538
3539
3540     return join "", @m if $self->{PARENT};
3541
3542     push @m, q{
3543 # Here we warn users that an old packlist file was found somewhere,
3544 # and that they should call some uninstall routine
3545 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3546 -e 'print "WARNING: I have found an old package in\n";' \\
3547 -e 'print "\t$$ARGV[0].\n";' \\
3548 -e 'print "Please make sure the two installations are not conflicting\n";'
3549
3550 UNINST=0
3551 VERBINST=0
3552
3553 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3554 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3555
3556 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3557 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3558 -e 'print "=over 4";' \
3559 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3560 -e 'print "=back";'
3561
3562 UNINSTALL =   $(PERL) -MExtUtils::Install \
3563 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3564 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3565 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3566 };
3567
3568     return join "", @m;
3569 }
3570
3571 =item tool_xsubpp (o)
3572
3573 Determines typemaps, xsubpp version, prototype behaviour.
3574
3575 =cut
3576
3577 sub tool_xsubpp {
3578     my($self) = shift;
3579     return "" unless $self->needs_linking;
3580     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3581     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3582     if( $self->{TYPEMAPS} ){
3583         my $typemap;
3584         foreach $typemap (@{$self->{TYPEMAPS}}){
3585                 if( ! -f  $typemap ){
3586                         warn "Typemap $typemap not found.\n";
3587                 }
3588                 else{
3589                         push(@tmdeps,  $typemap);
3590                 }
3591         }
3592     }
3593     push(@tmdeps, "typemap") if -f "typemap";
3594     my(@tmargs) = map("-typemap $_", @tmdeps);
3595     if( exists $self->{XSOPT} ){
3596         unshift( @tmargs, $self->{XSOPT} );
3597     }
3598
3599
3600     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3601
3602     # What are the correct thresholds for version 1 && 2 Paul?
3603     if ( $xsubpp_version > 1.923 ){
3604         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3605     } else {
3606         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3607             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3608         Your version of xsubpp is $xsubpp_version and cannot handle this.
3609         Please upgrade to a more recent version of xsubpp.
3610 };
3611         } else {
3612             $self->{XSPROTOARG} = "";
3613         }
3614     }
3615
3616     my $xsubpp = "xsubpp";
3617
3618     return qq{
3619 XSUBPPDIR = $xsdir
3620 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3621 XSPROTOARG = $self->{XSPROTOARG}
3622 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3623 XSUBPPARGS = @tmargs
3624 XSUBPP_EXTRA_ARGS =
3625 };
3626 };
3627
3628 sub xsubpp_version
3629 {
3630     my($self,$xsubpp) = @_;
3631     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3632
3633     my ($version) ;
3634
3635     # try to figure out the version number of the xsubpp on the system
3636
3637     # first try the -v flag, introduced in 1.921 & 2.000a2
3638
3639     return "" unless $self->needs_linking;
3640
3641     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3642     print "Running $command\n" if $Verbose >= 2;
3643     $version = `$command` ;
3644     warn "Running '$command' exits with status " . ($?>>8) if $?;
3645     chop $version ;
3646
3647     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3648
3649     # nope, then try something else
3650
3651     my $counter = '000';
3652     my ($file) = 'temp' ;
3653     $counter++ while -e "$file$counter"; # don't overwrite anything
3654     $file .= $counter;
3655
3656     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3657     print F <<EOM ;
3658 MODULE = fred PACKAGE = fred
3659
3660 int
3661 fred(a)
3662         int     a;
3663 EOM
3664
3665     close F ;
3666
3667     $command = "$self->{PERL} $xsubpp $file 2>&1";
3668     print "Running $command\n" if $Verbose >= 2;
3669     my $text = `$command` ;
3670     warn "Running '$command' exits with status " . ($?>>8) if $?;
3671     unlink $file ;
3672
3673     # gets 1.2 -> 1.92 and 2.000a1
3674     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3675
3676     # it is either 1.0 or 1.1
3677     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3678
3679     # none of the above, so 1.0
3680     return $Xsubpp_Version = "1.0" ;
3681 }
3682
3683 =item top_targets (o)
3684
3685 Defines the targets all, subdirs, config, and O_FILES
3686
3687 =cut
3688
3689 sub top_targets {
3690 # --- Target Sections ---
3691
3692     my($self) = shift;
3693     my(@m);
3694     push @m, '
3695 #all :: config $(INST_PM) subdirs linkext manifypods
3696 ';
3697
3698     push @m, '
3699 all :: pure_all htmlifypods manifypods
3700         '.$self->{NOECHO}.'$(NOOP)
3701 '
3702           unless $self->{SKIPHASH}{'all'};
3703
3704     push @m, '
3705 pure_all :: config pm_to_blib subdirs linkext
3706         '.$self->{NOECHO}.'$(NOOP)
3707
3708 subdirs :: $(MYEXTLIB)
3709         '.$self->{NOECHO}.'$(NOOP)
3710
3711 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3712         '.$self->{NOECHO}.'$(NOOP)
3713
3714 config :: $(INST_ARCHAUTODIR)/.exists
3715         '.$self->{NOECHO}.'$(NOOP)
3716
3717 config :: $(INST_AUTODIR)/.exists
3718         '.$self->{NOECHO}.'$(NOOP)
3719 ';
3720
3721     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3722
3723     if (%{$self->{HTMLLIBPODS}}) {
3724         push @m, qq[
3725 config :: \$(INST_HTMLLIBDIR)/.exists
3726         $self->{NOECHO}\$(NOOP)
3727
3728 ];
3729         push @m, $self->dir_target(qw[$(INST_HTMLLIBDIR)]);
3730     }
3731
3732     if (%{$self->{HTMLSCRIPTPODS}}) {
3733         push @m, qq[
3734 config :: \$(INST_HTMLSCRIPTDIR)/.exists
3735         $self->{NOECHO}\$(NOOP)
3736
3737 ];
3738         push @m, $self->dir_target(qw[$(INST_HTMLSCRIPTDIR)]);
3739     }
3740
3741     if (%{$self->{MAN1PODS}}) {
3742         push @m, qq[
3743 config :: \$(INST_MAN1DIR)/.exists
3744         $self->{NOECHO}\$(NOOP)
3745
3746 ];
3747         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3748     }
3749     if (%{$self->{MAN3PODS}}) {
3750         push @m, qq[
3751 config :: \$(INST_MAN3DIR)/.exists
3752         $self->{NOECHO}\$(NOOP)
3753
3754 ];
3755         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3756     }
3757
3758     push @m, '
3759 $(O_FILES): $(H_FILES)
3760 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3761
3762     push @m, q{
3763 help:
3764         perldoc ExtUtils::MakeMaker
3765 };
3766
3767     push @m, q{
3768 Version_check:
3769         }.$self->{NOECHO}.q{$(PERLRUN) \
3770                 -MExtUtils::MakeMaker=Version_check \
3771                 -e "Version_check('$(MM_VERSION)')"
3772 };
3773
3774     join('',@m);
3775 }
3776
3777 =item writedoc
3778
3779 Obsolete, deprecated method. Not used since Version 5.21.
3780
3781 =cut
3782
3783 sub writedoc {
3784 # --- perllocal.pod section ---
3785     my($self,$what,$name,@attribs)=@_;
3786     my $time = localtime;
3787     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3788     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3789     print "\n\n=back\n\n";
3790 }
3791
3792 =item xs_c (o)
3793
3794 Defines the suffix rules to compile XS files to C.
3795
3796 =cut
3797
3798 sub xs_c {
3799     my($self) = shift;
3800     return '' unless $self->needs_linking();
3801     '
3802 .xs.c:
3803         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3804 ';
3805 }
3806
3807 =item xs_cpp (o)
3808
3809 Defines the suffix rules to compile XS files to C++.
3810
3811 =cut
3812
3813 sub xs_cpp {
3814     my($self) = shift;
3815     return '' unless $self->needs_linking();
3816     '
3817 .xs.cpp:
3818         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3819 ';
3820 }
3821
3822 =item xs_o (o)
3823
3824 Defines suffix rules to go from XS to object files directly. This is
3825 only intended for broken make implementations.
3826
3827 =cut
3828
3829 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3830     my($self) = shift;
3831     return '' unless $self->needs_linking();
3832     '
3833 .xs$(OBJ_EXT):
3834         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3835         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(PASTHRU_DEFINE) $(DEFINE) $*.c
3836 ';
3837 }
3838
3839 =item perl_archive
3840
3841 This is internal method that returns path to libperl.a equivalent
3842 to be linked to dynamic extensions. UNIX does not have one but OS2
3843 and Win32 do.
3844
3845 =cut
3846
3847 sub perl_archive
3848 {
3849  return '$(PERL_INC)' . "/$Config{libperl}" if $^O eq "beos";
3850  return "";
3851 }
3852
3853 =item perl_archive_after
3854
3855 This is an internal method that returns path to a library which
3856 should be put on the linker command line I<after> the external libraries
3857 to be linked to dynamic extensions.  This may be needed if the linker
3858 is one-pass, and Perl includes some overrides for C RTL functions,
3859 such as malloc().
3860
3861 =cut
3862
3863 sub perl_archive_after
3864 {
3865  return "";
3866 }
3867
3868 =item export_list
3869
3870 This is internal method that returns name of a file that is
3871 passed to linker to define symbols to be exported.
3872 UNIX does not have one but OS2 and Win32 do.
3873
3874 =cut
3875
3876 sub export_list
3877 {
3878  return "";
3879 }
3880
3881
3882 1;
3883
3884 =back
3885
3886 =head1 SEE ALSO
3887
3888 L<ExtUtils::MakeMaker>
3889
3890 =cut
3891
3892 __END__