lib/ExtUtils/MM_Unix.pm

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