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