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