lib/ExtUtils/MM_Unix.pm

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