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