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