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