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     my $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         my $target;
3126         foreach $target (@$list) {
3127         push @m, "
3128 all :: $target
3129         $self->{NOECHO}\$(NOOP)
3130
3131 $target :: $plfile
3132         \$(PERL) -I\$(INST_ARCHLIB) -I\$(INST_LIB) -I\$(PERL_ARCHLIB) -I\$(PERL_LIB) $plfile $target
3133 ";
3134         }
3135     }
3136     join "", @m;
3137 }
3138
3139 =item realclean (o)
3140
3141 Defines the realclean target.
3142
3143 =cut
3144
3145 sub realclean {
3146     my($self, %attribs) = @_;
3147     my(@m);
3148     push(@m,'
3149 # Delete temporary files (via clean) and also delete installed files
3150 realclean purge ::  clean
3151 ');
3152     # realclean subdirectories first (already cleaned)
3153     my $sub = ($Is_Win32  &&  Win32::IsWin95()) ?
3154       "\tcd %s\n\t\$(TEST_F) %s\n\t\$(MAKE) %s realclean\n\tcd ..\n" :
3155       "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
3156     foreach(@{$self->{DIR}}){
3157         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3158         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3159     }
3160     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3161     if( $self->has_link_code ){
3162         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3163         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
3164     }
3165     # Issue a several little RM_F commands rather than risk creating a
3166     # very long command line (useful for extensions such as Encode
3167     # that have many files).
3168     if (keys %{$self->{PM}}) {
3169         my $line = "";
3170         foreach (values %{$self->{PM}}) {
3171             if (length($line) + length($_) > 80) {
3172                 push @m, "\t$self->{RM_F} $line\n";
3173                 $line = $_;
3174             }
3175             else {
3176                 $line .= " $_";
3177             }
3178         }
3179     push @m, "\t$self->{RM_F} $line\n" if $line;
3180     }
3181     my(@otherfiles) = ($self->{MAKEFILE},
3182                        "$self->{MAKEFILE}.old"); # Makefiles last
3183     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3184     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
3185     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
3186     join("", @m);
3187 }
3188
3189 =item replace_manpage_separator
3190
3191 Takes the name of a package, which may be a nested package, in the
3192 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
3193
3194 =cut
3195
3196 sub replace_manpage_separator {
3197     my($self,$man) = @_;
3198         if ($^O eq 'uwin') {
3199             $man =~ s,/+,.,g;
3200         } elsif ($Is_Dos) {
3201             $man =~ s,/+,__,g;
3202         } else {
3203             $man =~ s,/+,::,g;
3204         }
3205     $man;
3206 }
3207
3208 =item static (o)
3209
3210 Defines the static target.
3211
3212 =cut
3213
3214 sub static {
3215 # --- Static Loading Sections ---
3216
3217     my($self) = shift;
3218     '
3219 ## $(INST_PM) has been moved to the all: target.
3220 ## It remains here for awhile to allow for old usage: "make static"
3221 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3222 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3223         '.$self->{NOECHO}.'$(NOOP)
3224 ';
3225 }
3226
3227 =item static_lib (o)
3228
3229 Defines how to produce the *.a (or equivalent) files.
3230
3231 =cut
3232
3233 sub static_lib {
3234     my($self) = @_;
3235 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3236 #    return '' unless $self->needs_linking(); #might be because of a subdir
3237
3238     return '' unless $self->has_link_code;
3239
3240     my(@m);
3241     push(@m, <<'END');
3242 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3243         $(RM_RF) $@
3244 END
3245     # If this extension has it's own library (eg SDBM_File)
3246     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3247     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3248
3249     my $ar;
3250     if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3251         # Prefer the absolute pathed ar if available so that PATH
3252         # doesn't confuse us.  Perl itself is built with the full_ar.
3253         $ar = 'FULL_AR';
3254     } else {
3255         $ar = 'AR';
3256     }
3257     push @m,
3258         "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3259     push @m,
3260 q{      $(CHMOD) $(PERM_RWX) $@
3261         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3262 };
3263     # Old mechanism - still available:
3264     push @m,
3265 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3266 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
3267     push @m, "\n";
3268
3269     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3270     join('', "\n",@m);
3271 }
3272
3273 =item staticmake (o)
3274
3275 Calls makeaperl.
3276
3277 =cut
3278
3279 sub staticmake {
3280     my($self, %attribs) = @_;
3281     my(@static);
3282
3283     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3284
3285     # And as it's not yet built, we add the current extension
3286     # but only if it has some C code (or XS code, which implies C code)
3287     if (@{$self->{C}}) {
3288         @static = $self->catfile($self->{INST_ARCHLIB},
3289                                  "auto",
3290                                  $self->{FULLEXT},
3291                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3292                                 );
3293     }
3294
3295     # Either we determine now, which libraries we will produce in the
3296     # subdirectories or we do it at runtime of the make.
3297
3298     # We could ask all subdir objects, but I cannot imagine, why it
3299     # would be necessary.
3300
3301     # Instead we determine all libraries for the new perl at
3302     # runtime.
3303     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3304
3305     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3306                      DIRS       => \@searchdirs,
3307                      STAT       => \@static,
3308                      INCL       => \@perlinc,
3309                      TARGET     => $self->{MAP_TARGET},
3310                      TMP        => "",
3311                      LIBPERL    => $self->{LIBPERL_A}
3312                     );
3313 }
3314
3315 =item subdir_x (o)
3316
3317 Helper subroutine for subdirs
3318
3319 =cut
3320
3321 sub subdir_x {
3322     my($self, $subdir) = @_;
3323     my(@m);
3324     if ($Is_Win32 && Win32::IsWin95()) {
3325         if ($Config{'make'} =~ /dmake/i) {
3326             # dmake-specific
3327             return <<EOT;
3328 subdirs ::
3329 @[
3330         cd $subdir
3331         \$(MAKE) all \$(PASTHRU)
3332         cd ..
3333 ]
3334 EOT
3335         } elsif ($Config{'make'} =~ /nmake/i) {
3336             # nmake-specific
3337             return <<EOT;
3338 subdirs ::
3339         cd $subdir
3340         \$(MAKE) all \$(PASTHRU)
3341         cd ..
3342 EOT
3343         }
3344     } else {
3345         return <<EOT;
3346
3347 subdirs ::
3348         $self->{NOECHO}cd $subdir && \$(MAKE) all \$(PASTHRU)
3349
3350 EOT
3351     }
3352 }
3353
3354 =item subdirs (o)
3355
3356 Defines targets to process subdirectories.
3357
3358 =cut
3359
3360 sub subdirs {
3361 # --- Sub-directory Sections ---
3362     my($self) = shift;
3363     my(@m,$dir);
3364     # This method provides a mechanism to automatically deal with
3365     # subdirectories containing further Makefile.PL scripts.
3366     # It calls the subdir_x() method for each subdirectory.
3367     foreach $dir (@{$self->{DIR}}){
3368         push(@m, $self->subdir_x($dir));
3369 ####    print "Including $dir subdirectory\n";
3370     }
3371     if (@m){
3372         unshift(@m, "
3373 # The default clean, realclean and test targets in this Makefile
3374 # have automatically been given entries for each subdir.
3375
3376 ");
3377     } else {
3378         push(@m, "\n# none")
3379     }
3380     join('',@m);
3381 }
3382
3383 =item test (o)
3384
3385 Defines the test targets.
3386
3387 =cut
3388
3389 sub test {
3390 # --- Test and Installation Sections ---
3391
3392     my($self, %attribs) = @_;
3393     my $tests = $attribs{TESTS};
3394     if (!$tests && -d 't') {
3395         $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3396     }
3397     # note: 'test.pl' name is also hardcoded in init_dirscan()
3398     my(@m);
3399     push(@m,"
3400 TEST_VERBOSE=0
3401 TEST_TYPE=test_\$(LINKTYPE)
3402 TEST_FILE = test.pl
3403 TEST_FILES = $tests
3404 TESTDB_SW = -d
3405
3406 testdb :: testdb_\$(LINKTYPE)
3407
3408 test :: \$(TEST_TYPE)
3409 ");
3410     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3411                  @{$self->{DIR}}));
3412     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3413         unless $tests or -f "test.pl" or @{$self->{DIR}};
3414     push(@m, "\n");
3415
3416     push(@m, "test_dynamic :: pure_all\n");
3417     push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3418     push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3419     push(@m, "\n");
3420
3421     push(@m, "testdb_dynamic :: pure_all\n");
3422     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3423     push(@m, "\n");
3424
3425     # Occasionally we may face this degenerate target:
3426     push @m, "test_ : test_dynamic\n\n";
3427
3428     if ($self->needs_linking()) {
3429         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3430         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3431         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3432         push(@m, "\n");
3433         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3434         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3435         push(@m, "\n");
3436     } else {
3437         push @m, "test_static :: test_dynamic\n";
3438         push @m, "testdb_static :: testdb_dynamic\n";
3439     }
3440     join("", @m);
3441 }
3442
3443 =item test_via_harness (o)
3444
3445 Helper method to write the test targets
3446
3447 =cut
3448
3449 sub test_via_harness {
3450     my($self, $perl, $tests) = @_;
3451     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3452     "\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";
3453 }
3454
3455 =item test_via_script (o)
3456
3457 Other helper method for test.
3458
3459 =cut
3460
3461 sub test_via_script {
3462     my($self, $perl, $script) = @_;
3463     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3464     qq{\t$perl}.q{ -I$(INST_ARCHLIB) -I$(INST_LIB) -I$(PERL_ARCHLIB) -I$(PERL_LIB) }.qq{$script
3465 };
3466 }
3467
3468 =item tool_autosplit (o)
3469
3470 Defines a simple perl call that runs autosplit. May be deprecated by
3471 pm_to_blib soon.
3472
3473 =cut
3474
3475 sub tool_autosplit {
3476 # --- Tool Sections ---
3477
3478     my($self, %attribs) = @_;
3479     my($asl) = "";
3480     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3481     q{
3482 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3483 AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3484 };
3485 }
3486
3487 =item tools_other (o)
3488
3489 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3490 the Makefile. Also defines the perl programs MKPATH,
3491 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3492
3493 =cut
3494
3495 sub tools_other {
3496     my($self) = shift;
3497     my @m;
3498     my $bin_sh = $Config{sh} || '/bin/sh';
3499     push @m, qq{
3500 SHELL = $bin_sh
3501 };
3502
3503     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3504         push @m, "$_ = $self->{$_}\n";
3505     }
3506
3507     push @m, q{
3508 # The following is a portable way to say mkdir -p
3509 # To see which directories are created, change the if 0 to if 1
3510 MKPATH = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e mkpath
3511
3512 # This helps us to minimize the effect of the .exists files A yet
3513 # better solution would be to have a stable file in the perl
3514 # distribution with a timestamp of zero. But this solution doesn't
3515 # need any changes to the core distribution and works with older perls
3516 EQUALIZE_TIMESTAMP = $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) -MExtUtils::Command -e eqtime
3517 };
3518
3519
3520     return join "", @m if $self->{PARENT};
3521
3522     push @m, q{
3523 # Here we warn users that an old packlist file was found somewhere,
3524 # and that they should call some uninstall routine
3525 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3526 -e 'print "WARNING: I have found an old package in\n";' \\
3527 -e 'print "\t$$ARGV[0].\n";' \\
3528 -e 'print "Please make sure the two installations are not conflicting\n";'
3529
3530 UNINST=0
3531 VERBINST=0
3532
3533 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3534 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3535
3536 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3537 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3538 -e 'print "=over 4";' \
3539 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3540 -e 'print "=back";'
3541
3542 UNINSTALL =   $(PERL) -MExtUtils::Install \
3543 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3544 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3545 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3546 };
3547
3548     return join "", @m;
3549 }
3550
3551 =item tool_xsubpp (o)
3552
3553 Determines typemaps, xsubpp version, prototype behaviour.
3554
3555 =cut
3556
3557 sub tool_xsubpp {
3558     my($self) = shift;
3559     return "" unless $self->needs_linking;
3560     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3561     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3562     if( $self->{TYPEMAPS} ){
3563         my $typemap;
3564         foreach $typemap (@{$self->{TYPEMAPS}}){
3565                 if( ! -f  $typemap ){
3566                         warn "Typemap $typemap not found.\n";
3567                 }
3568                 else{
3569                         push(@tmdeps,  $typemap);
3570                 }
3571         }
3572     }
3573     push(@tmdeps, "typemap") if -f "typemap";
3574     my(@tmargs) = map("-typemap $_", @tmdeps);
3575     if( exists $self->{XSOPT} ){
3576         unshift( @tmargs, $self->{XSOPT} );
3577     }
3578
3579
3580     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3581
3582     # What are the correct thresholds for version 1 && 2 Paul?
3583     if ( $xsubpp_version > 1.923 ){
3584         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3585     } else {
3586         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3587             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3588         Your version of xsubpp is $xsubpp_version and cannot handle this.
3589         Please upgrade to a more recent version of xsubpp.
3590 };
3591         } else {
3592             $self->{XSPROTOARG} = "";
3593         }
3594     }
3595
3596     my $xsubpp = "xsubpp";
3597
3598     return qq{
3599 XSUBPPDIR = $xsdir
3600 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3601 XSPROTOARG = $self->{XSPROTOARG}
3602 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3603 XSUBPPARGS = @tmargs
3604 };
3605 };
3606
3607 sub xsubpp_version
3608 {
3609     my($self,$xsubpp) = @_;
3610     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3611
3612     my ($version) ;
3613
3614     # try to figure out the version number of the xsubpp on the system
3615
3616     # first try the -v flag, introduced in 1.921 & 2.000a2
3617
3618     return "" unless $self->needs_linking;
3619
3620     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3621     print "Running $command\n" if $Verbose >= 2;
3622     $version = `$command` ;
3623     warn "Running '$command' exits with status " . ($?>>8) if $?;
3624     chop $version ;
3625
3626     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3627
3628     # nope, then try something else
3629
3630     my $counter = '000';
3631     my ($file) = 'temp' ;
3632     $counter++ while -e "$file$counter"; # don't overwrite anything
3633     $file .= $counter;
3634
3635     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3636     print F <<EOM ;
3637 MODULE = fred PACKAGE = fred
3638
3639 int
3640 fred(a)
3641         int     a;
3642 EOM
3643
3644     close F ;
3645
3646     $command = "$self->{PERL} $xsubpp $file 2>&1";
3647     print "Running $command\n" if $Verbose >= 2;
3648     my $text = `$command` ;
3649     warn "Running '$command' exits with status " . ($?>>8) if $?;
3650     unlink $file ;
3651
3652     # gets 1.2 -> 1.92 and 2.000a1
3653     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3654
3655     # it is either 1.0 or 1.1
3656     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3657
3658     # none of the above, so 1.0
3659     return $Xsubpp_Version = "1.0" ;
3660 }
3661
3662 =item top_targets (o)
3663
3664 Defines the targets all, subdirs, config, and O_FILES
3665
3666 =cut
3667
3668 sub top_targets {
3669 # --- Target Sections ---
3670
3671     my($self) = shift;
3672     my(@m);
3673     push @m, '
3674 #all :: config $(INST_PM) subdirs linkext manifypods
3675 ';
3676
3677     push @m, '
3678 all :: pure_all htmlifypods manifypods
3679         '.$self->{NOECHO}.'$(NOOP)
3680 '
3681           unless $self->{SKIPHASH}{'all'};
3682
3683     push @m, '
3684 pure_all :: config pm_to_blib subdirs linkext
3685         '.$self->{NOECHO}.'$(NOOP)
3686
3687 subdirs :: $(MYEXTLIB)
3688         '.$self->{NOECHO}.'$(NOOP)
3689
3690 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3691         '.$self->{NOECHO}.'$(NOOP)
3692
3693 config :: $(INST_ARCHAUTODIR)/.exists
3694         '.$self->{NOECHO}.'$(NOOP)
3695
3696 config :: $(INST_AUTODIR)/.exists
3697         '.$self->{NOECHO}.'$(NOOP)
3698 ';
3699
3700     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3701
3702     if (%{$self->{HTMLLIBPODS}}) {
3703         push @m, qq[
3704 config :: \$(INST_HTMLLIBDIR)/.exists
3705         $self->{NOECHO}\$(NOOP)
3706
3707 ];
3708         push @m, $self->dir_target(qw[$(INST_HTMLLIBDIR)]);
3709     }
3710
3711     if (%{$self->{HTMLSCRIPTPODS}}) {
3712         push @m, qq[
3713 config :: \$(INST_HTMLSCRIPTDIR)/.exists
3714         $self->{NOECHO}\$(NOOP)
3715
3716 ];
3717         push @m, $self->dir_target(qw[$(INST_HTMLSCRIPTDIR)]);
3718     }
3719
3720     if (%{$self->{MAN1PODS}}) {
3721         push @m, qq[
3722 config :: \$(INST_MAN1DIR)/.exists
3723         $self->{NOECHO}\$(NOOP)
3724
3725 ];
3726         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3727     }
3728     if (%{$self->{MAN3PODS}}) {
3729         push @m, qq[
3730 config :: \$(INST_MAN3DIR)/.exists
3731         $self->{NOECHO}\$(NOOP)
3732
3733 ];
3734         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3735     }
3736
3737     push @m, '
3738 $(O_FILES): $(H_FILES)
3739 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3740
3741     push @m, q{
3742 help:
3743         perldoc ExtUtils::MakeMaker
3744 };
3745
3746     push @m, q{
3747 Version_check:
3748         }.$self->{NOECHO}.q{$(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) \
3749                 -MExtUtils::MakeMaker=Version_check \
3750                 -e "Version_check('$(MM_VERSION)')"
3751 };
3752
3753     join('',@m);
3754 }
3755
3756 =item writedoc
3757
3758 Obsolete, deprecated method. Not used since Version 5.21.
3759
3760 =cut
3761
3762 sub writedoc {
3763 # --- perllocal.pod section ---
3764     my($self,$what,$name,@attribs)=@_;
3765     my $time = localtime;
3766     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3767     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3768     print "\n\n=back\n\n";
3769 }
3770
3771 =item xs_c (o)
3772
3773 Defines the suffix rules to compile XS files to C.
3774
3775 =cut
3776
3777 sub xs_c {
3778     my($self) = shift;
3779     return '' unless $self->needs_linking();
3780     '
3781 .xs.c:
3782         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3783 ';
3784 }
3785
3786 =item xs_cpp (o)
3787
3788 Defines the suffix rules to compile XS files to C++.
3789
3790 =cut
3791
3792 sub xs_cpp {
3793     my($self) = shift;
3794     return '' unless $self->needs_linking();
3795     '
3796 .xs.cpp:
3797         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3798 ';
3799 }
3800
3801 =item xs_o (o)
3802
3803 Defines suffix rules to go from XS to object files directly. This is
3804 only intended for broken make implementations.
3805
3806 =cut
3807
3808 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3809     my($self) = shift;
3810     return '' unless $self->needs_linking();
3811     '
3812 .xs$(OBJ_EXT):
3813         $(PERL) -I$(PERL_ARCHLIB) -I$(PERL_LIB) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3814         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(DEFINE) $*.c
3815 ';
3816 }
3817
3818 =item perl_archive
3819
3820 This is internal method that returns path to libperl.a equivalent
3821 to be linked to dynamic extensions. UNIX does not have one but OS2
3822 and Win32 do.
3823
3824 =cut
3825
3826 sub perl_archive
3827 {
3828  return '$(PERL_INC)' . "/$Config{libperl}" if $^O eq "beos";
3829  return "";
3830 }
3831
3832 =item export_list
3833
3834 This is internal method that returns name of a file that is
3835 passed to linker to define symbols to be exported.
3836 UNIX does not have one but OS2 and Win32 do.
3837
3838 =cut
3839
3840 sub export_list
3841 {
3842  return "";
3843 }
3844
3845
3846 1;
3847
3848 =back
3849
3850 =head1 SEE ALSO
3851
3852 L<ExtUtils::MakeMaker>
3853
3854 =cut
3855
3856 __END__