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
2070     # How do we run perl when installing libraries?
2071     $self->{PERLRUNINST} .= $self->{PERL}. ' -I$(INST_ARCHLIB) -I$(INST_LIB)';
2072
2073     # What extra library dirs do we need when running the tests?
2074     $self->{TEST_LIBS}   .= ' -I$(INST_ARCHLIB) -I$(INST_LIB)';
2075
2076     # When building the core, we need to add some helper libs since
2077     # perl's @INC won't work (we're not installed yet).
2078     foreach my $targ (qw(PERLRUN PERLRUNINST TEST_LIBS)) {
2079         $self->{$targ} .= ' -I$(PERL_ARCHLIB) -I$(PERL_LIB)'
2080           if $self->{PERL_CORE};
2081     }
2082 }
2083
2084 =item init_others
2085
2086 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH,
2087 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, NOOP, FIRST_MAKEFILE,
2088 MAKEFILE, NOECHO, RM_F, RM_RF, TEST_F, TOUCH, CP, MV, CHMOD, UMASK_NULL
2089
2090 =cut
2091
2092 sub init_others {       # --- Initialize Other Attributes
2093     my($self) = shift;
2094
2095     # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS}
2096     # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or
2097     # undefined. In any case we turn it into an anon array:
2098
2099     # May check $Config{libs} too, thus not empty.
2100     $self->{LIBS}=[''] unless $self->{LIBS};
2101
2102     $self->{LIBS}=[$self->{LIBS}] if ref \$self->{LIBS} eq 'SCALAR';
2103     $self->{LD_RUN_PATH} = "";
2104     my($libs);
2105     foreach $libs ( @{$self->{LIBS}} ){
2106         $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace
2107         my(@libs) = $self->extliblist($libs);
2108         if ($libs[0] or $libs[1] or $libs[2]){
2109             # LD_RUN_PATH now computed by ExtUtils::Liblist
2110             ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs;
2111             last;
2112         }
2113     }
2114
2115     if ( $self->{OBJECT} ) {
2116         $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g;
2117     } else {
2118         # init_dirscan should have found out, if we have C files
2119         $self->{OBJECT} = "";
2120         $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]};
2121     }
2122     $self->{OBJECT} =~ s/\n+/ \\\n\t/g;
2123     $self->{BOOTDEP}  = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : "";
2124     $self->{PERLMAINCC} ||= '$(CC)';
2125     $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM};
2126
2127     # Sanity check: don't define LINKTYPE = dynamic if we're skipping
2128     # the 'dynamic' section of MM.  We don't have this problem with
2129     # 'static', since we either must use it (%Config says we can't
2130     # use dynamic loading) or the caller asked for it explicitly.
2131     if (!$self->{LINKTYPE}) {
2132        $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'}
2133                         ? 'static'
2134                         : ($Config::Config{usedl} ? 'dynamic' : 'static');
2135     };
2136
2137     # These get overridden for VMS and maybe some other systems
2138     $self->{NOOP}  ||= '$(SHELL) -c true';
2139     $self->{FIRST_MAKEFILE} ||= "Makefile";
2140     $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
2141     $self->{MAKE_APERL_FILE} ||= "Makefile.aperl";
2142     $self->{NOECHO} = '@' unless defined $self->{NOECHO};
2143     $self->{RM_F}  ||= "rm -f";
2144     $self->{RM_RF} ||= "rm -rf";
2145     $self->{TOUCH} ||= "touch";
2146     $self->{TEST_F} ||= "test -f";
2147     $self->{CP} ||= "cp";
2148     $self->{MV} ||= "mv";
2149     $self->{CHMOD} ||= "chmod";
2150     $self->{UMASK_NULL} ||= "umask 0";
2151     $self->{DEV_NULL} ||= "> /dev/null 2>&1";
2152 }
2153
2154 =item install (o)
2155
2156 Defines the install target.
2157
2158 =cut
2159
2160 sub install {
2161     my($self, %attribs) = @_;
2162     my(@m);
2163
2164     push @m, q{
2165 install :: all pure_install doc_install
2166
2167 install_perl :: all pure_perl_install doc_perl_install
2168
2169 install_site :: all pure_site_install doc_site_install
2170
2171 install_ :: install_site
2172         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2173
2174 pure_install :: pure_$(INSTALLDIRS)_install
2175
2176 doc_install :: doc_$(INSTALLDIRS)_install
2177         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2178
2179 pure__install : pure_site_install
2180         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2181
2182 doc__install : doc_site_install
2183         @echo INSTALLDIRS not defined, defaulting to INSTALLDIRS=site
2184
2185 pure_perl_install ::
2186         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2187                 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2188                 write }.$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \
2189                 $(INST_LIB) $(INSTALLPRIVLIB) \
2190                 $(INST_ARCHLIB) $(INSTALLARCHLIB) \
2191                 $(INST_BIN) $(INSTALLBIN) \
2192                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2193                 $(INST_HTMLLIBDIR) $(INSTALLHTMLPRIVLIBDIR) \
2194                 $(INST_HTMLSCRIPTDIR) $(INSTALLHTMLSCRIPTDIR) \
2195                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2196                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2197         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2198                 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{
2199
2200
2201 pure_site_install ::
2202         }.$self->{NOECHO}.q{$(MOD_INSTALL) \
2203                 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \
2204                 write }.$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \
2205                 $(INST_LIB) $(INSTALLSITELIB) \
2206                 $(INST_ARCHLIB) $(INSTALLSITEARCH) \
2207                 $(INST_BIN) $(INSTALLBIN) \
2208                 $(INST_SCRIPT) $(INSTALLSCRIPT) \
2209                 $(INST_HTMLLIBDIR) $(INSTALLHTMLSITELIBDIR) \
2210                 $(INST_HTMLSCRIPTDIR) $(INSTALLHTMLSCRIPTDIR) \
2211                 $(INST_MAN1DIR) $(INSTALLMAN1DIR) \
2212                 $(INST_MAN3DIR) $(INSTALLMAN3DIR)
2213         }.$self->{NOECHO}.q{$(WARN_IF_OLD_PACKLIST) \
2214                 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{
2215
2216 doc_perl_install ::
2217         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2218         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2219                 "Module" "$(NAME)" \
2220                 "installed into" "$(INSTALLPRIVLIB)" \
2221                 LINKTYPE "$(LINKTYPE)" \
2222                 VERSION "$(VERSION)" \
2223                 EXE_FILES "$(EXE_FILES)" \
2224                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2225
2226 doc_site_install ::
2227         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2228         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2229                 "Module" "$(NAME)" \
2230                 "installed into" "$(INSTALLSITELIB)" \
2231                 LINKTYPE "$(LINKTYPE)" \
2232                 VERSION "$(VERSION)" \
2233                 EXE_FILES "$(EXE_FILES)" \
2234                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2235
2236 };
2237
2238     push @m, q{
2239 uninstall :: uninstall_from_$(INSTALLDIRS)dirs
2240
2241 uninstall_from_perldirs ::
2242         }.$self->{NOECHO}.
2243         q{$(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{
2244
2245 uninstall_from_sitedirs ::
2246         }.$self->{NOECHO}.
2247         q{$(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{
2248 };
2249
2250     join("",@m);
2251 }
2252
2253 =item installbin (o)
2254
2255 Defines targets to make and to install EXE_FILES.
2256
2257 =cut
2258
2259 sub installbin {
2260     my($self) = shift;
2261     return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
2262     return "" unless @{$self->{EXE_FILES}};
2263     my(@m, $from, $to, %fromto, @to);
2264     push @m, $self->dir_target(qw[$(INST_SCRIPT)]);
2265     for $from (@{$self->{EXE_FILES}}) {
2266         my($path)= $self->catfile('$(INST_SCRIPT)', basename($from));
2267         local($_) = $path; # for backwards compatibility
2268         $to = $self->libscan($path);
2269         print "libscan($from) => '$to'\n" if ($Verbose >=2);
2270         $fromto{$from}=$to;
2271     }
2272     @to   = values %fromto;
2273     push(@m, qq{
2274 EXE_FILES = @{$self->{EXE_FILES}}
2275
2276 } . ($Is_Win32
2277   ? q{FIXIN = $(PERLRUN) \
2278     -e "system qq[pl2bat.bat ].shift"
2279 } : q{FIXIN = $(PERLRUN) -MExtUtils::MakeMaker \
2280     -e "MY->fixin(shift)"
2281 }).qq{
2282 pure_all :: @to
2283         $self->{NOECHO}\$(NOOP)
2284
2285 realclean ::
2286         $self->{RM_F} @to
2287 });
2288
2289     while (($from,$to) = each %fromto) {
2290         last unless defined $from;
2291         my $todir = dirname($to);
2292         push @m, "
2293 $to: $from $self->{MAKEFILE} " . $self->catdir($todir,'.exists') . "
2294         $self->{NOECHO}$self->{RM_F} $to
2295         $self->{CP} $from $to
2296         \$(FIXIN) $to
2297         -$self->{NOECHO}\$(CHMOD) \$(PERM_RWX) $to
2298 ";
2299     }
2300     join "", @m;
2301 }
2302
2303 =item libscan (o)
2304
2305 Takes a path to a file that is found by init_dirscan and returns false
2306 if we don't want to include this file in the library. Mainly used to
2307 exclude RCS, CVS, and SCCS directories from installation.
2308
2309 =cut
2310
2311 # ';
2312
2313 sub libscan {
2314     my($self,$path) = @_;
2315     return '' if $path =~ m:\b(RCS|CVS|SCCS)\b: ;
2316     $path;
2317 }
2318
2319 =item linkext (o)
2320
2321 Defines the linkext target which in turn defines the LINKTYPE.
2322
2323 =cut
2324
2325 sub linkext {
2326     my($self, %attribs) = @_;
2327     # LINKTYPE => static or dynamic or ''
2328     my($linktype) = defined $attribs{LINKTYPE} ?
2329       $attribs{LINKTYPE} : '$(LINKTYPE)';
2330     "
2331 linkext :: $linktype
2332         $self->{NOECHO}\$(NOOP)
2333 ";
2334 }
2335
2336 =item lsdir
2337
2338 Takes as arguments a directory name and a regular expression. Returns
2339 all entries in the directory that match the regular expression.
2340
2341 =cut
2342
2343 sub lsdir {
2344     my($self) = shift;
2345     my($dir, $regex) = @_;
2346     my(@ls);
2347     my $dh = new DirHandle;
2348     $dh->open($dir || ".") or return ();
2349     @ls = $dh->read;
2350     $dh->close;
2351     @ls = grep(/$regex/, @ls) if $regex;
2352     @ls;
2353 }
2354
2355 =item macro (o)
2356
2357 Simple subroutine to insert the macros defined by the macro attribute
2358 into the Makefile.
2359
2360 =cut
2361
2362 sub macro {
2363     my($self,%attribs) = @_;
2364     my(@m,$key,$val);
2365     while (($key,$val) = each %attribs){
2366         last unless defined $key;
2367         push @m, "$key = $val\n";
2368     }
2369     join "", @m;
2370 }
2371
2372 =item makeaperl (o)
2373
2374 Called by staticmake. Defines how to write the Makefile to produce a
2375 static new perl.
2376
2377 By default the Makefile produced includes all the static extensions in
2378 the perl library. (Purified versions of library files, e.g.,
2379 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.)
2380
2381 =cut
2382
2383 sub makeaperl {
2384     my($self, %attribs) = @_;
2385     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) =
2386         @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
2387     my(@m);
2388     push @m, "
2389 # --- MakeMaker makeaperl section ---
2390 MAP_TARGET    = $target
2391 FULLPERL      = $self->{FULLPERL}
2392 ";
2393     return join '', @m if $self->{PARENT};
2394
2395     my($dir) = join ":", @{$self->{DIR}};
2396
2397     unless ($self->{MAKEAPERL}) {
2398         push @m, q{
2399 $(MAP_TARGET) :: static $(MAKE_APERL_FILE)
2400         $(MAKE) -f $(MAKE_APERL_FILE) $@
2401
2402 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
2403         }.$self->{NOECHO}.q{echo Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET)
2404         }.$self->{NOECHO}.q{$(PERLRUNINST) \
2405                 Makefile.PL DIR=}, $dir, q{ \
2406                 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
2407                 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=};
2408
2409         foreach (@ARGV){
2410                 if( /\s/ ){
2411                         s/=(.*)/='$1'/;
2412                 }
2413                 push @m, " \\\n\t\t$_";
2414         }
2415 #       push @m, map( " \\\n\t\t$_", @ARGV );
2416         push @m, "\n";
2417
2418         return join '', @m;
2419     }
2420
2421
2422
2423     my($cccmd, $linkcmd, $lperl);
2424
2425
2426     $cccmd = $self->const_cccmd($libperl);
2427     $cccmd =~ s/^CCCMD\s*=\s*//;
2428     $cccmd =~ s/\$\(INC\)/ -I$self->{PERL_INC} /;
2429     $cccmd .= " $Config::Config{cccdlflags}"
2430         if ($Config::Config{useshrplib} eq 'true');
2431     $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/;
2432
2433     # The front matter of the linkcommand...
2434     $linkcmd = join ' ', "\$(CC)",
2435             grep($_, @Config{qw(ldflags ccdlflags)});
2436     $linkcmd =~ s/\s+/ /g;
2437     $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,;
2438
2439     # Which *.a files could we make use of...
2440     local(%static);
2441     require File::Find;
2442     File::Find::find(sub {
2443         return unless m/\Q$self->{LIB_EXT}\E$/;
2444         return if m/^libperl/;
2445         # Skip purified versions of libraries (e.g., DynaLoader_pure_p1_c0_032.a)
2446         return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure";
2447
2448         if( exists $self->{INCLUDE_EXT} ){
2449                 my $found = 0;
2450                 my $incl;
2451                 my $xx;
2452
2453                 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2454                 $xx =~ s,/?$_,,;
2455                 $xx =~ s,/,::,g;
2456
2457                 # Throw away anything not explicitly marked for inclusion.
2458                 # DynaLoader is implied.
2459                 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
2460                         if( $xx eq $incl ){
2461                                 $found++;
2462                                 last;
2463                         }
2464                 }
2465                 return unless $found;
2466         }
2467         elsif( exists $self->{EXCLUDE_EXT} ){
2468                 my $excl;
2469                 my $xx;
2470
2471                 ($xx = $File::Find::name) =~ s,.*?/auto/,,s;
2472                 $xx =~ s,/?$_,,;
2473                 $xx =~ s,/,::,g;
2474
2475                 # Throw away anything explicitly marked for exclusion
2476                 foreach $excl (@{$self->{EXCLUDE_EXT}}){
2477                         return if( $xx eq $excl );
2478                 }
2479         }
2480
2481         # don't include the installed version of this extension. I
2482         # leave this line here, although it is not necessary anymore:
2483         # I patched minimod.PL instead, so that Miniperl.pm won't
2484         # enclude duplicates
2485
2486         # Once the patch to minimod.PL is in the distribution, I can
2487         # drop it
2488         return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:;
2489         use Cwd 'cwd';
2490         $static{cwd() . "/" . $_}++;
2491     }, grep( -d $_, @{$searchdirs || []}) );
2492
2493     # We trust that what has been handed in as argument, will be buildable
2494     $static = [] unless $static;
2495     @static{@{$static}} = (1) x @{$static};
2496
2497     $extra = [] unless $extra && ref $extra eq 'ARRAY';
2498     for (sort keys %static) {
2499         next unless /\Q$self->{LIB_EXT}\E\z/;
2500         $_ = dirname($_) . "/extralibs.ld";
2501         push @$extra, $_;
2502     }
2503
2504     grep(s/^/-I/, @{$perlinc || []});
2505
2506     $target = "perl" unless $target;
2507     $tmp = "." unless $tmp;
2508
2509 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we
2510 # regenerate the Makefiles, MAP_STATIC and the dependencies for
2511 # extralibs.all are computed correctly
2512     push @m, "
2513 MAP_LINKCMD   = $linkcmd
2514 MAP_PERLINC   = @{$perlinc || []}
2515 MAP_STATIC    = ",
2516 join(" \\\n\t", reverse sort keys %static), "
2517
2518 MAP_PRELIBS   = $Config::Config{perllibs} $Config::Config{cryptlib}
2519 ";
2520
2521     if (defined $libperl) {
2522         ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/;
2523     }
2524     unless ($libperl && -f $lperl) { # Ilya's code...
2525         my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE";
2526         $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL};
2527         $libperl ||= "libperl$self->{LIB_EXT}";
2528         $libperl   = "$dir/$libperl";
2529         $lperl   ||= "libperl$self->{LIB_EXT}";
2530         $lperl     = "$dir/$lperl";
2531
2532         if (! -f $libperl and ! -f $lperl) {
2533           # We did not find a static libperl. Maybe there is a shared one?
2534           if ($^O eq 'solaris' or $^O eq 'sunos') {
2535             $lperl  = $libperl = "$dir/$Config::Config{libperl}";
2536             # SUNOS ld does not take the full path to a shared library
2537             $libperl = '' if $^O eq 'sunos';
2538           }
2539         }
2540
2541         print STDOUT "Warning: $libperl not found
2542     If you're going to build a static perl binary, make sure perl is installed
2543     otherwise ignore this warning\n"
2544                 unless (-f $lperl || defined($self->{PERL_SRC}));
2545     }
2546
2547     push @m, "
2548 MAP_LIBPERL = $libperl
2549 ";
2550
2551     push @m, "
2552 \$(INST_ARCHAUTODIR)/extralibs.all: \$(INST_ARCHAUTODIR)/.exists ".join(" \\\n\t", @$extra)."
2553         $self->{NOECHO}$self->{RM_F} \$\@
2554         $self->{NOECHO}\$(TOUCH) \$\@
2555 ";
2556
2557     my $catfile;
2558     foreach $catfile (@$extra){
2559         push @m, "\tcat $catfile >> \$\@\n";
2560     }
2561     # SUNOS ld does not take the full path to a shared library
2562     my $llibperl = ($libperl)?'$(MAP_LIBPERL)':'-lperl';
2563
2564 push @m, "
2565 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all
2566         \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) $llibperl `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS)
2567         $self->{NOECHO}echo 'To install the new \"\$(MAP_TARGET)\" binary, call'
2568         $self->{NOECHO}echo '    make -f $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)'
2569         $self->{NOECHO}echo 'To remove the intermediate files say'
2570         $self->{NOECHO}echo '    make -f $makefilename map_clean'
2571
2572 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c
2573 ";
2574     push @m, "\tcd $tmp && $cccmd -I\$(PERL_INC) perlmain.c\n";
2575
2576     push @m, qq{
2577 $tmp/perlmain.c: $makefilename}, q{
2578         }.$self->{NOECHO}.q{echo Writing $@
2579         }.$self->{NOECHO}.q{$(PERL) $(MAP_PERLINC) -MExtUtils::Miniperl \\
2580                 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@
2581
2582 };
2583     push @m, "\t",$self->{NOECHO}.q{$(PERL) $(INSTALLSCRIPT)/fixpmain
2584 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0);
2585
2586
2587     push @m, q{
2588 doc_inst_perl:
2589         }.$self->{NOECHO}.q{echo Appending installation info to $(INSTALLARCHLIB)/perllocal.pod
2590         -}.$self->{NOECHO}.q{$(MKPATH) $(INSTALLARCHLIB)
2591         -}.$self->{NOECHO}.q{$(DOC_INSTALL) \
2592                 "Perl binary" "$(MAP_TARGET)" \
2593                 MAP_STATIC "$(MAP_STATIC)" \
2594                 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \
2595                 MAP_LIBPERL "$(MAP_LIBPERL)" \
2596                 >> }.$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q{
2597
2598 };
2599
2600     push @m, q{
2601 inst_perl: pure_inst_perl doc_inst_perl
2602
2603 pure_inst_perl: $(MAP_TARGET)
2604         }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(INSTALLBIN)','$(MAP_TARGET)').q{
2605
2606 clean :: map_clean
2607
2608 map_clean :
2609         }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all
2610 };
2611
2612     join '', @m;
2613 }
2614
2615 =item makefile (o)
2616
2617 Defines how to rewrite the Makefile.
2618
2619 =cut
2620
2621 sub makefile {
2622     my($self) = shift;
2623     my @m;
2624     # We do not know what target was originally specified so we
2625     # must force a manual rerun to be sure. But as it should only
2626     # happen very rarely it is not a significant problem.
2627     push @m, '
2628 $(OBJECT) : $(FIRST_MAKEFILE)
2629 ' if $self->{OBJECT};
2630
2631     push @m, q{
2632 # We take a very conservative approach here, but it\'s worth it.
2633 # We move Makefile to Makefile.old here to avoid gnu make looping.
2634 }.$self->{MAKEFILE}.q{ : Makefile.PL $(CONFIGDEP)
2635         }.$self->{NOECHO}.q{echo "Makefile out-of-date with respect to $?"
2636         }.$self->{NOECHO}.q{echo "Cleaning current config before rebuilding Makefile..."
2637         -}.$self->{NOECHO}.q{$(RM_F) }."$self->{MAKEFILE}.old".q{
2638         -}.$self->{NOECHO}.q{$(MV) }."$self->{MAKEFILE} $self->{MAKEFILE}.old".q{
2639         -$(MAKE) -f }.$self->{MAKEFILE}.q{.old clean $(DEV_NULL) || $(NOOP)
2640         $(PERLRUN) Makefile.PL }.join(" ",map(qq["$_"],@ARGV)).q{
2641         }.$self->{NOECHO}.q{echo "==> Your Makefile has been rebuilt. <=="
2642         }.$self->{NOECHO}.q{echo "==> Please rerun the make command.  <=="
2643         false
2644
2645 # To change behavior to :: would be nice, but would break Tk b9.02
2646 # so you find such a warning below the dist target.
2647 #}.$self->{MAKEFILE}.q{ :: $(VERSION_FROM)
2648 #       }.$self->{NOECHO}.q{echo "Warning: Makefile possibly out of date with $(VERSION_FROM)"
2649 };
2650
2651     join "", @m;
2652 }
2653
2654 =item manifypods (o)
2655
2656 Defines targets and routines to translate the pods into manpages and
2657 put them into the INST_* directories.
2658
2659 =cut
2660
2661 sub manifypods {
2662     my($self, %attribs) = @_;
2663     return "\nmanifypods : pure_all\n\t$self->{NOECHO}\$(NOOP)\n" unless
2664         %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
2665     my($dist);
2666     my($pod2man_exe);
2667     if (defined $self->{PERL_SRC}) {
2668         $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
2669     } else {
2670         $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
2671     }
2672     unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2673       # Maybe a build by uninstalled Perl?
2674       $pod2man_exe = $self->catfile($self->{PERL_INC}, "pod", "pod2man");
2675     }
2676     unless ($pod2man_exe = $self->perl_script($pod2man_exe)) {
2677         # No pod2man but some MAN3PODS to be installed
2678         print <<END;
2679
2680 Warning: I could not locate your pod2man program. Please make sure,
2681          your pod2man program is in your PATH before you execute 'make'
2682
2683 END
2684         $pod2man_exe = "-S pod2man";
2685     }
2686     my(@m);
2687     push @m,
2688 qq[POD2MAN_EXE = $pod2man_exe\n],
2689 qq[POD2MAN = \$(PERL) -we '%m=\@ARGV;for (keys %m){' \\\n],
2690 q[-e 'next if -e $$m{$$_} && -M $$m{$$_} < -M $$_ && -M $$m{$$_} < -M "],
2691  $self->{MAKEFILE}, q[";' \\
2692 -e 'print "Manifying $$m{$$_}\n";' \\
2693 -e 'system(q[$(PERLRUN) $(POD2MAN_EXE) ].qq[$$_>$$m{$$_}])==0 or warn "Couldn\\047t install $$m{$$_}\n";' \\
2694 -e 'chmod(oct($(PERM_RW))), $$m{$$_} or warn "chmod $(PERM_RW) $$m{$$_}: $$!\n";}'
2695 ];
2696     push @m, "\nmanifypods : pure_all ";
2697     push @m, join " \\\n\t", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
2698
2699     push(@m,"\n");
2700     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
2701         push @m, "\t$self->{NOECHO}\$(POD2MAN) \\\n\t";
2702         push @m, join " \\\n\t", %{$self->{MAN1PODS}}, %{$self->{MAN3PODS}};
2703     }
2704     join('', @m);
2705 }
2706
2707 =item maybe_command
2708
2709 Returns true, if the argument is likely to be a command.
2710
2711 =cut
2712
2713 sub maybe_command {
2714     my($self,$file) = @_;
2715     return $file if -x $file && ! -d $file;
2716     return;
2717 }
2718
2719 =item maybe_command_in_dirs
2720
2721 method under development. Not yet used. Ask Ilya :-)
2722
2723 =cut
2724
2725 sub maybe_command_in_dirs {     # $ver is optional argument if looking for perl
2726 # Ilya's suggestion. Not yet used, want to understand it first, but at least the code is here
2727     my($self, $names, $dirs, $trace, $ver) = @_;
2728     my($name, $dir);
2729     foreach $dir (@$dirs){
2730         next unless defined $dir; # $self->{PERL_SRC} may be undefined
2731         foreach $name (@$names){
2732             my($abs,$tryabs);
2733             if ($self->file_name_is_absolute($name)) { # /foo/bar
2734                 $abs = $name;
2735             } elsif ($self->canonpath($name) eq $self->canonpath(basename($name))) { # bar
2736                 $abs = $self->catfile($dir, $name);
2737             } else { # foo/bar
2738                 $abs = $self->catfile($self->curdir, $name);
2739             }
2740             print "Checking $abs for $name\n" if ($trace >= 2);
2741             next unless $tryabs = $self->maybe_command($abs);
2742             print "Substituting $tryabs instead of $abs\n"
2743                 if ($trace >= 2 and $tryabs ne $abs);
2744             $abs = $tryabs;
2745             if (defined $ver) {
2746                 print "Executing $abs\n" if ($trace >= 2);
2747                 if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
2748                     print "Using PERL=$abs\n" if $trace;
2749                     return $abs;
2750                 }
2751             } else { # Do not look for perl
2752                 return $abs;
2753             }
2754         }
2755     }
2756 }
2757
2758 =item needs_linking (o)
2759
2760 Does this module need linking? Looks into subdirectory objects (see
2761 also has_link_code())
2762
2763 =cut
2764
2765 sub needs_linking {
2766     my($self) = shift;
2767     my($child,$caller);
2768     $caller = (caller(0))[3];
2769     Carp::confess("Needs_linking called too early") if $caller =~ /^ExtUtils::MakeMaker::/;
2770     return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING};
2771     if ($self->has_link_code or $self->{MAKEAPERL}){
2772         $self->{NEEDS_LINKING} = 1;
2773         return 1;
2774     }
2775     foreach $child (keys %{$self->{CHILDREN}}) {
2776         if ($self->{CHILDREN}->{$child}->needs_linking) {
2777             $self->{NEEDS_LINKING} = 1;
2778             return 1;
2779         }
2780     }
2781     return $self->{NEEDS_LINKING} = 0;
2782 }
2783
2784 =item nicetext
2785
2786 misnamed method (will have to be changed). The MM_Unix method just
2787 returns the argument without further processing.
2788
2789 On VMS used to insure that colons marking targets are preceded by
2790 space - most Unix Makes don't need this, but it's necessary under VMS
2791 to distinguish the target delimiter from a colon appearing as part of
2792 a filespec.
2793
2794 =cut
2795
2796 sub nicetext {
2797     my($self,$text) = @_;
2798     $text;
2799 }
2800
2801 =item parse_version
2802
2803 parse a file and return what you think is $VERSION in this file set to.
2804 It will return the string "undef" if it can't figure out what $VERSION
2805 is.
2806
2807 =cut
2808
2809 sub parse_version {
2810     my($self,$parsefile) = @_;
2811     my $result;
2812     local *FH;
2813     local $/ = "\n";
2814     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2815     my $inpod = 0;
2816     while (<FH>) {
2817         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2818         next if $inpod || /^\s*#/;
2819         chop;
2820         # next unless /\$(([\w\:\']*)\bVERSION)\b.*\=/;
2821         next unless /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/;
2822         my $eval = qq{
2823             package ExtUtils::MakeMaker::_version;
2824             no strict;
2825
2826             local $1$2;
2827             \$$2=undef; do {
2828                 $_
2829             }; \$$2
2830         };
2831         no warnings;
2832         $result = eval($eval);
2833         warn "Could not eval '$eval' in $parsefile: $@" if $@;
2834         $result = "undef" unless defined $result;
2835         last;
2836     }
2837     close FH;
2838     return $result;
2839 }
2840
2841 =item parse_abstract
2842
2843 parse a file and return what you think is the ABSTRACT
2844
2845 =cut
2846
2847 sub parse_abstract {
2848     my($self,$parsefile) = @_;
2849     my $result;
2850     local *FH;
2851     local $/ = "\n";
2852     open(FH,$parsefile) or die "Could not open '$parsefile': $!";
2853     my $inpod = 0;
2854     my $package = $self->{DISTNAME};
2855     $package =~ s/-/::/g;
2856     while (<FH>) {
2857         $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod;
2858         next if !$inpod;
2859         chop;
2860         next unless /^($package\s-\s)(.*)/;
2861         $result = $2;
2862         last;
2863     }
2864     close FH;
2865     return $result;
2866 }
2867
2868 =item pasthru (o)
2869
2870 Defines the string that is passed to recursive make calls in
2871 subdirectories.
2872
2873 =cut
2874
2875 sub pasthru {
2876     my($self) = shift;
2877     my(@m,$key);
2878
2879     my(@pasthru);
2880     my($sep) = $Is_VMS ? ',' : '';
2881     $sep .= "\\\n\t";
2882
2883     foreach $key (qw(LIB LIBPERL_A LINKTYPE PREFIX OPTIMIZE)) {
2884         push @pasthru, "$key=\"\$($key)\"";
2885     }
2886
2887     foreach $key (qw(DEFINE INC)) {
2888         push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\"";
2889     }
2890
2891     push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n";
2892     join "", @m;
2893 }
2894
2895 =item path
2896
2897 Takes no argument, returns the environment variable PATH as an array.
2898
2899 =cut
2900
2901 sub path {
2902     my($self) = @_;
2903     my $path_sep = ($Is_OS2 || $Is_Dos) ? ";" : ":";
2904     my $path = $ENV{PATH};
2905     $path =~ s:\\:/:g if $Is_OS2;
2906     my @path = split $path_sep, $path;
2907     foreach(@path) { $_ = '.' if $_ eq '' }
2908     @path;
2909 }
2910
2911 =item perl_script
2912
2913 Takes one argument, a file name, and returns the file name, if the
2914 argument is likely to be a perl script. On MM_Unix this is true for
2915 any ordinary, readable file.
2916
2917 =cut
2918
2919 sub perl_script {
2920     my($self,$file) = @_;
2921     return $file if -r $file && -f _;
2922     return;
2923 }
2924
2925 =item perldepend (o)
2926
2927 Defines the dependency from all *.h files that come with the perl
2928 distribution.
2929
2930 =cut
2931
2932 sub perldepend {
2933     my($self) = shift;
2934     my(@m);
2935     push @m, q{
2936 # Check for unpropogated config.sh changes. Should never happen.
2937 # We do NOT just update config.h because that is not sufficient.
2938 # An out of date config.h is not fatal but complains loudly!
2939 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh
2940         -}.$self->{NOECHO}.q{echo "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false
2941
2942 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh
2943         }.$self->{NOECHO}.q{echo "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh"
2944         cd $(PERL_SRC) && $(MAKE) lib/Config.pm
2945 } if $self->{PERL_SRC};
2946
2947     return join "", @m unless $self->needs_linking;
2948
2949     push @m, q{
2950 PERL_HDRS = \
2951         $(PERL_INC)/EXTERN.h            \
2952         $(PERL_INC)/INTERN.h            \
2953         $(PERL_INC)/XSUB.h              \
2954         $(PERL_INC)/av.h                \
2955         $(PERL_INC)/cc_runtime.h        \
2956         $(PERL_INC)/config.h            \
2957         $(PERL_INC)/cop.h               \
2958         $(PERL_INC)/cv.h                \
2959         $(PERL_INC)/dosish.h            \
2960         $(PERL_INC)/embed.h             \
2961         $(PERL_INC)/embedvar.h          \
2962         $(PERL_INC)/fakethr.h           \
2963         $(PERL_INC)/form.h              \
2964         $(PERL_INC)/gv.h                \
2965         $(PERL_INC)/handy.h             \
2966         $(PERL_INC)/hv.h                \
2967         $(PERL_INC)/intrpvar.h          \
2968         $(PERL_INC)/iperlsys.h          \
2969         $(PERL_INC)/keywords.h          \
2970         $(PERL_INC)/mg.h                \
2971         $(PERL_INC)/nostdio.h           \
2972         $(PERL_INC)/op.h                \
2973         $(PERL_INC)/opcode.h            \
2974         $(PERL_INC)/opnames.h           \
2975         $(PERL_INC)/patchlevel.h        \
2976         $(PERL_INC)/perl.h              \
2977         $(PERL_INC)/perlapi.h           \
2978         $(PERL_INC)/perlio.h            \
2979         $(PERL_INC)/perlsdio.h          \
2980         $(PERL_INC)/perlsfio.h          \
2981         $(PERL_INC)/perlvars.h          \
2982         $(PERL_INC)/perly.h             \
2983         $(PERL_INC)/pp.h                \
2984         $(PERL_INC)/pp_proto.h          \
2985         $(PERL_INC)/proto.h             \
2986         $(PERL_INC)/regcomp.h           \
2987         $(PERL_INC)/regexp.h            \
2988         $(PERL_INC)/regnodes.h          \
2989         $(PERL_INC)/scope.h             \
2990         $(PERL_INC)/sv.h                \
2991         $(PERL_INC)/thrdvar.h           \
2992         $(PERL_INC)/thread.h            \
2993         $(PERL_INC)/unixish.h           \
2994         $(PERL_INC)/utf8.h              \
2995         $(PERL_INC)/util.h              \
2996         $(PERL_INC)/warnings.h
2997
2998 $(OBJECT) : $(PERL_HDRS)
2999 } if $self->{OBJECT};
3000
3001     push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n"  if %{$self->{XS}};
3002
3003     join "\n", @m;
3004 }
3005
3006 =item ppd
3007
3008 Defines target that creates a PPD (Perl Package Description) file
3009 for a binary distribution.
3010
3011 =cut
3012
3013 sub ppd {
3014     my($self) = @_;
3015     my(@m);
3016     if ($self->{ABSTRACT_FROM}){
3017         $self->{ABSTRACT} = $self->parse_abstract($self->{ABSTRACT_FROM}) or
3018             Carp::carp "WARNING: Setting ABSTRACT via file '$self->{ABSTRACT_FROM}' failed\n";
3019     }
3020     my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0) x 4) [0 .. 3];
3021     push(@m, "# Creates a PPD (Perl Package Description) for a binary distribution.\n");
3022     push(@m, "ppd:\n");
3023     push(@m, "\t\@\$(PERL) -e \"print qq{<SOFTPKG NAME=\\\"$self->{DISTNAME}\\\" VERSION=\\\"$pack_ver\\\">\\n}");
3024     push(@m, ". qq{\\t<TITLE>$self->{DISTNAME}</TITLE>\\n}");
3025     my $abstract = $self->{ABSTRACT};
3026     $abstract =~ s/\n/\\n/sg;
3027     $abstract =~ s/</&lt;/g;
3028     $abstract =~ s/>/&gt;/g;
3029     push(@m, ". qq{\\t<ABSTRACT>$abstract</ABSTRACT>\\n}");
3030     my ($author) = $self->{AUTHOR};
3031     $author =~ s/</&lt;/g;
3032     $author =~ s/>/&gt;/g;
3033     $author =~ s/@/\\@/g;
3034     push(@m, ". qq{\\t<AUTHOR>$author</AUTHOR>\\n}");
3035     push(@m, ". qq{\\t<IMPLEMENTATION>\\n}");
3036     my ($prereq);
3037     foreach $prereq (sort keys %{$self->{PREREQ_PM}}) {
3038         my $pre_req = $prereq;
3039         $pre_req =~ s/::/-/g;
3040         my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}), (0) x 4) [0 .. 3];
3041         push(@m, ". qq{\\t\\t<DEPENDENCY NAME=\\\"$pre_req\\\" VERSION=\\\"$dep_ver\\\" />\\n}");
3042     }
3043     push(@m, ". qq{\\t\\t<OS NAME=\\\"\$(OSNAME)\\\" />\\n}");
3044     push(@m, ". qq{\\t\\t<ARCHITECTURE NAME=\\\"$Config{'archname'}\\\" />\\n}");
3045     my ($bin_location) = $self->{BINARY_LOCATION};
3046     $bin_location =~ s/\\/\\\\/g;
3047     if ($self->{PPM_INSTALL_SCRIPT}) {
3048         if ($self->{PPM_INSTALL_EXEC}) {
3049             push(@m, " . qq{\\t\\t<INSTALL EXEC=\\\"$self->{PPM_INSTALL_EXEC}\\\">$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3050         }
3051         else {
3052             push(@m, " . qq{\\t\\t<INSTALL>$self->{PPM_INSTALL_SCRIPT}</INSTALL>\\n}");
3053         }
3054     }
3055     push(@m, ". qq{\\t\\t<CODEBASE HREF=\\\"$bin_location\\\" />\\n}");
3056     push(@m, ". qq{\\t</IMPLEMENTATION>\\n}");
3057     push(@m, ". qq{</SOFTPKG>\\n}\" > $self->{DISTNAME}.ppd");
3058
3059     join("", @m);
3060 }
3061
3062 =item perm_rw (o)
3063
3064 Returns the attribute C<PERM_RW> or the string C<644>.
3065 Used as the string that is passed
3066 to the C<chmod> command to set the permissions for read/writeable files.
3067 MakeMaker chooses C<644> because it has turned out in the past that
3068 relying on the umask provokes hard-to-track bug reports.
3069 When the return value is used by the perl function C<chmod>, it is
3070 interpreted as an octal value.
3071
3072 =cut
3073
3074 sub perm_rw {
3075     shift->{PERM_RW} || "644";
3076 }
3077
3078 =item perm_rwx (o)
3079
3080 Returns the attribute C<PERM_RWX> or the string C<755>,
3081 i.e. the string that is passed
3082 to the C<chmod> command to set the permissions for executable files.
3083 See also perl_rw.
3084
3085 =cut
3086
3087 sub perm_rwx {
3088     shift->{PERM_RWX} || "755";
3089 }
3090
3091 =item pm_to_blib
3092
3093 Defines target that copies all files in the hash PM to their
3094 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION>
3095
3096 =cut
3097
3098 sub _pm_to_blib_flush {
3099     my ($self, $autodir, $rr, $ra, $rl) = @_;
3100     $$rr .=
3101 q{      }.$self->{NOECHO}.q[$(PERLRUNINST) -MExtUtils::Install \
3102         -e "pm_to_blib({qw{].qq[@$ra].q[}},'].$autodir.q{','$(PM_FILTER)')"
3103 };
3104     @$ra = ();
3105     $$rl = 0;
3106 }
3107
3108 sub pm_to_blib {
3109     my $self = shift;
3110     my($autodir) = $self->catdir('$(INST_LIB)','auto');
3111     my $r = q{
3112 pm_to_blib: $(TO_INST_PM)
3113 };
3114     my %pm_to_blib = %{$self->{PM}};
3115     my @a;
3116     my $l;
3117     while (my ($pm, $blib) = each %pm_to_blib) {
3118         my $la = length $pm;
3119         my $lb = length $blib;
3120         if ($l + $la + $lb + @a / 2 > 200) { # limit line length
3121             _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
3122         }
3123         push @a, $pm, $blib;
3124         $l += $la + $lb;
3125     }
3126     _pm_to_blib_flush($self, $autodir, \$r, \@a, \$l);
3127     return $r.q{        }.$self->{NOECHO}.q{$(TOUCH) $@};
3128 }
3129
3130 =item post_constants (o)
3131
3132 Returns an empty string per default. Dedicated to overrides from
3133 within Makefile.PL after all constants have been defined.
3134
3135 =cut
3136
3137 sub post_constants{
3138     my($self) = shift;
3139     "";
3140 }
3141
3142 =item post_initialize (o)
3143
3144 Returns an empty string per default. Used in Makefile.PLs to add some
3145 chunk of text to the Makefile after the object is initialized.
3146
3147 =cut
3148
3149 sub post_initialize {
3150     my($self) = shift;
3151     "";
3152 }
3153
3154 =item postamble (o)
3155
3156 Returns an empty string. Can be used in Makefile.PLs to write some
3157 text to the Makefile at the end.
3158
3159 =cut
3160
3161 sub postamble {
3162     my($self) = shift;
3163     "";
3164 }
3165
3166 =item prefixify
3167
3168 Check a path variable in $self from %Config, if it contains a prefix,
3169 and replace it with another one.
3170
3171 Takes as arguments an attribute name, a search prefix and a
3172 replacement prefix. Changes the attribute in the object.
3173
3174 =cut
3175
3176 sub prefixify {
3177     my($self,$var,$sprefix,$rprefix) = @_;
3178     $self->{uc $var} ||= $Config{lc $var};
3179     $self->{uc $var} = VMS::Filespec::unixpath($self->{uc $var}) if $Is_VMS;
3180     $self->{uc $var} =~ s,^\Q$sprefix\E(?=/|\z),$rprefix,s;
3181 }
3182
3183 =item processPL (o)
3184
3185 Defines targets to run *.PL files.
3186
3187 =cut
3188
3189 sub processPL {
3190     my($self) = shift;
3191     return "" unless $self->{PL_FILES};
3192     my(@m, $plfile);
3193     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
3194         my $list = ref($self->{PL_FILES}->{$plfile})
3195                 ? $self->{PL_FILES}->{$plfile}
3196                 : [$self->{PL_FILES}->{$plfile}];
3197         my $target;
3198         foreach $target (@$list) {
3199         push @m, "
3200 all :: $target
3201         $self->{NOECHO}\$(NOOP)
3202
3203 $target :: $plfile
3204         \$(PERLRUNINST) $plfile $target
3205 ";
3206         }
3207     }
3208     join "", @m;
3209 }
3210
3211 =item quote_paren
3212
3213 Backslashes parentheses C<()> in command line arguments.
3214 Doesn't handle recursive Makefile C<$(...)> constructs,
3215 but handles simple ones.
3216
3217 =cut
3218
3219 sub quote_paren {
3220     local $_ = shift;
3221     s/\$\((.+?)\)/\$\\\\($1\\\\)/g;     # protect $(...)
3222     s/(?<!\\)([()])/\\$1/g;             # quote unprotected
3223     s/\$\\\\\((.+?)\\\\\)/\$($1)/g;     # unprotect $(...)
3224     return $_;
3225 }
3226
3227 =item realclean (o)
3228
3229 Defines the realclean target.
3230
3231 =cut
3232
3233 sub realclean {
3234     my($self, %attribs) = @_;
3235     my(@m);
3236
3237     push(@m,'LLIBPERL = '.$llibperl."\n");
3238
3239     push(@m,'
3240 # Delete temporary files (via clean) and also delete installed files
3241 realclean purge ::  clean
3242 ');
3243     # realclean subdirectories first (already cleaned)
3244     my $sub = ($Is_Win32  &&  Win32::IsWin95()) ?
3245       "\tcd %s\n\t\$(TEST_F) %s\n\t\$(MAKE) %s realclean\n\tcd ..\n" :
3246       "\t-cd %s && \$(TEST_F) %s && \$(MAKE) %s realclean\n";
3247     foreach(@{$self->{DIR}}){
3248         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}.old","-f $self->{MAKEFILE}.old"));
3249         push(@m, sprintf($sub,$_,"$self->{MAKEFILE}",''));
3250     }
3251     push(@m, "  $self->{RM_RF} \$(INST_AUTODIR) \$(INST_ARCHAUTODIR)\n");
3252     if( $self->has_link_code ){
3253         push(@m, "      $self->{RM_F} \$(INST_DYNAMIC) \$(INST_BOOT)\n");
3254         push(@m, "      $self->{RM_F} \$(INST_STATIC)\n");
3255     }
3256     # Issue a several little RM_F commands rather than risk creating a
3257     # very long command line (useful for extensions such as Encode
3258     # that have many files).
3259     if (keys %{$self->{PM}}) {
3260         my $line = "";
3261         foreach (values %{$self->{PM}}) {
3262             if (length($line) + length($_) > 80) {
3263                 push @m, "\t$self->{RM_F} $line\n";
3264                 $line = $_;
3265             }
3266             else {
3267                 $line .= " $_";
3268             }
3269         }
3270     push @m, "\t$self->{RM_F} $line\n" if $line;
3271     }
3272     my(@otherfiles) = ($self->{MAKEFILE},
3273                        "$self->{MAKEFILE}.old"); # Makefiles last
3274     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
3275     push(@m, "  $self->{RM_RF} @otherfiles\n") if @otherfiles;
3276     push(@m, "  $attribs{POSTOP}\n")       if $attribs{POSTOP};
3277     join("", @m);
3278 }
3279
3280 =item replace_manpage_separator
3281
3282 Takes the name of a package, which may be a nested package, in the
3283 form Foo/Bar and replaces the slash with C<::>. Returns the replacement.
3284
3285 =cut
3286
3287 sub replace_manpage_separator {
3288     my($self,$man) = @_;
3289         if ($^O eq 'uwin') {
3290             $man =~ s,/+,.,g;
3291         } elsif ($Is_Dos) {
3292             $man =~ s,/+,__,g;
3293         } else {
3294             $man =~ s,/+,::,g;
3295         }
3296     $man;
3297 }
3298
3299 =item static (o)
3300
3301 Defines the static target.
3302
3303 =cut
3304
3305 sub static {
3306 # --- Static Loading Sections ---
3307
3308     my($self) = shift;
3309     '
3310 ## $(INST_PM) has been moved to the all: target.
3311 ## It remains here for awhile to allow for old usage: "make static"
3312 #static :: '.$self->{MAKEFILE}.' $(INST_STATIC) $(INST_PM)
3313 static :: '.$self->{MAKEFILE}.' $(INST_STATIC)
3314         '.$self->{NOECHO}.'$(NOOP)
3315 ';
3316 }
3317
3318 =item static_lib (o)
3319
3320 Defines how to produce the *.a (or equivalent) files.
3321
3322 =cut
3323
3324 sub static_lib {
3325     my($self) = @_;
3326 # Come to think of it, if there are subdirs with linkcode, we still have no INST_STATIC
3327 #    return '' unless $self->needs_linking(); #might be because of a subdir
3328
3329     return '' unless $self->has_link_code;
3330
3331     my(@m);
3332     push(@m, <<'END');
3333 $(INST_STATIC): $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)/.exists
3334         $(RM_RF) $@
3335 END
3336     # If this extension has its own library (eg SDBM_File)
3337     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
3338     push(@m, "\t$self->{CP} \$(MYEXTLIB) \$\@\n") if $self->{MYEXTLIB};
3339
3340     my $ar;
3341     if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) {
3342         # Prefer the absolute pathed ar if available so that PATH
3343         # doesn't confuse us.  Perl itself is built with the full_ar.
3344         $ar = 'FULL_AR';
3345     } else {
3346         $ar = 'AR';
3347     }
3348     push @m,
3349         "\t\$($ar) ".'$(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@'."\n";
3350     push @m,
3351 q{      $(CHMOD) $(PERM_RWX) $@
3352         }.$self->{NOECHO}.q{echo "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld
3353 };
3354     # Old mechanism - still available:
3355     push @m,
3356 "\t$self->{NOECHO}".q{echo "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs
3357 }       if $self->{PERL_SRC} && $self->{EXTRALIBS};
3358     push @m, "\n";
3359
3360     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
3361     join('', "\n",@m);
3362 }
3363
3364 =item staticmake (o)
3365
3366 Calls makeaperl.
3367
3368 =cut
3369
3370 sub staticmake {
3371     my($self, %attribs) = @_;
3372     my(@static);
3373
3374     my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP},  $self->{INST_ARCHLIB});
3375
3376     # And as it's not yet built, we add the current extension
3377     # but only if it has some C code (or XS code, which implies C code)
3378     if (@{$self->{C}}) {
3379         @static = $self->catfile($self->{INST_ARCHLIB},
3380                                  "auto",
3381                                  $self->{FULLEXT},
3382                                  "$self->{BASEEXT}$self->{LIB_EXT}"
3383                                 );
3384     }
3385
3386     # Either we determine now, which libraries we will produce in the
3387     # subdirectories or we do it at runtime of the make.
3388
3389     # We could ask all subdir objects, but I cannot imagine, why it
3390     # would be necessary.
3391
3392     # Instead we determine all libraries for the new perl at
3393     # runtime.
3394     my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB});
3395
3396     $self->makeaperl(MAKE       => $self->{MAKEFILE},
3397                      DIRS       => \@searchdirs,
3398                      STAT       => \@static,
3399                      INCL       => \@perlinc,
3400                      TARGET     => $self->{MAP_TARGET},
3401                      TMP        => "",
3402                      LIBPERL    => $self->{LIBPERL_A}
3403                     );
3404 }
3405
3406 =item subdir_x (o)
3407
3408 Helper subroutine for subdirs
3409
3410 =cut
3411
3412 sub subdir_x {
3413     my($self, $subdir) = @_;
3414     my(@m);
3415     if ($Is_Win32 && Win32::IsWin95()) {
3416         if ($Config{'make'} =~ /dmake/i) {
3417             # dmake-specific
3418             return <<EOT;
3419 subdirs ::
3420 @[
3421         cd $subdir
3422         \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3423         cd ..
3424 ]
3425 EOT
3426         } elsif ($Config{'make'} =~ /nmake/i) {
3427             # nmake-specific
3428             return <<EOT;
3429 subdirs ::
3430         cd $subdir
3431         \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3432         cd ..
3433 EOT
3434         }
3435     } else {
3436         return <<EOT;
3437
3438 subdirs ::
3439         $self->{NOECHO}cd $subdir && \$(MAKE) -f \$(FIRST_MAKEFILE) all \$(PASTHRU)
3440 EOT
3441     }
3442 }
3443
3444 =item subdirs (o)
3445
3446 Defines targets to process subdirectories.
3447
3448 =cut
3449
3450 sub subdirs {
3451 # --- Sub-directory Sections ---
3452     my($self) = shift;
3453     my(@m,$dir);
3454     # This method provides a mechanism to automatically deal with
3455     # subdirectories containing further Makefile.PL scripts.
3456     # It calls the subdir_x() method for each subdirectory.
3457     foreach $dir (@{$self->{DIR}}){
3458         push(@m, $self->subdir_x($dir));
3459 ####    print "Including $dir subdirectory\n";
3460     }
3461     if (@m){
3462         unshift(@m, "
3463 # The default clean, realclean and test targets in this Makefile
3464 # have automatically been given entries for each subdir.
3465
3466 ");
3467     } else {
3468         push(@m, "\n# none")
3469     }
3470     join('',@m);
3471 }
3472
3473 =item test (o)
3474
3475 Defines the test targets.
3476
3477 =cut
3478
3479 sub test {
3480 # --- Test and Installation Sections ---
3481
3482     my($self, %attribs) = @_;
3483     my $tests = $attribs{TESTS};
3484     if (!$tests && -d 't') {
3485         $tests = $Is_Win32 ? join(' ', <t\\*.t>) : 't/*.t';
3486     }
3487     # note: 'test.pl' name is also hardcoded in init_dirscan()
3488     my(@m);
3489     push(@m,"
3490 TEST_VERBOSE=0
3491 TEST_TYPE=test_\$(LINKTYPE)
3492 TEST_FILE = test.pl
3493 TEST_FILES = $tests
3494 TESTDB_SW = -d
3495
3496 testdb :: testdb_\$(LINKTYPE)
3497
3498 test :: \$(TEST_TYPE)
3499 ");
3500     push(@m, map("\t$self->{NOECHO}cd $_ && \$(TEST_F) $self->{MAKEFILE} && \$(MAKE) test \$(PASTHRU)\n",
3501                  @{$self->{DIR}}));
3502     push(@m, "\t$self->{NOECHO}echo 'No tests defined for \$(NAME) extension.'\n")
3503         unless $tests or -f "test.pl" or @{$self->{DIR}};
3504     push(@m, "\n");
3505
3506     push(@m, "test_dynamic :: pure_all\n");
3507     push(@m, $self->test_via_harness('$(FULLPERL)', '$(TEST_FILES)')) if $tests;
3508     push(@m, $self->test_via_script('$(FULLPERL)', '$(TEST_FILE)')) if -f "test.pl";
3509     push(@m, "\n");
3510
3511     push(@m, "testdb_dynamic :: pure_all\n");
3512     push(@m, $self->test_via_script('$(FULLPERL) $(TESTDB_SW)', '$(TEST_FILE)'));
3513     push(@m, "\n");
3514
3515     # Occasionally we may face this degenerate target:
3516     push @m, "test_ : test_dynamic\n\n";
3517
3518     if ($self->needs_linking()) {
3519         push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
3520         push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests;
3521         push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl";
3522         push(@m, "\n");
3523         push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
3524         push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
3525         push(@m, "\n");
3526     } else {
3527         push @m, "test_static :: test_dynamic\n";
3528         push @m, "testdb_static :: testdb_dynamic\n";
3529     }
3530     join("", @m);
3531 }
3532
3533 =item test_via_harness (o)
3534
3535 Helper method to write the test targets
3536
3537 =cut
3538
3539 sub test_via_harness {
3540     my($self, $perl, $tests) = @_;
3541     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3542     "\t$perl".q! $(TEST_LIBS) -e 'use Test::Harness qw(&runtests $$verbose); $$verbose=$(TEST_VERBOSE); runtests @ARGV;' !."$tests\n";
3543 }
3544
3545 =item test_via_script (o)
3546
3547 Other helper method for test.
3548
3549 =cut
3550
3551 sub test_via_script {
3552     my($self, $perl, $script) = @_;
3553     $perl = "PERL_DL_NONLAZY=1 $perl" unless $Is_Win32;
3554     qq{\t$perl}.q{ $(TEST_LIBS) }.qq{$script
3555 };
3556 }
3557
3558 =item tool_autosplit (o)
3559
3560 Defines a simple perl call that runs autosplit. May be deprecated by
3561 pm_to_blib soon.
3562
3563 =cut
3564
3565 sub tool_autosplit {
3566 # --- Tool Sections ---
3567
3568     my($self, %attribs) = @_;
3569     my($asl) = "";
3570     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
3571     q{
3572 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
3573 AUTOSPLITFILE = $(PERLRUN) -e 'use AutoSplit;}.$asl.q{autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) ;'
3574 };
3575 }
3576
3577 =item tools_other (o)
3578
3579 Defines SHELL, LD, TOUCH, CP, MV, RM_F, RM_RF, CHMOD, UMASK_NULL in
3580 the Makefile. Also defines the perl programs MKPATH,
3581 WARN_IF_OLD_PACKLIST, MOD_INSTALL. DOC_INSTALL, and UNINSTALL.
3582
3583 =cut
3584
3585 sub tools_other {
3586     my($self) = shift;
3587     my @m;
3588     my $bin_sh = $Config{sh} || '/bin/sh';
3589     push @m, qq{
3590 SHELL = $bin_sh
3591 };
3592
3593     for (qw/ CHMOD CP LD MV NOOP RM_F RM_RF TEST_F TOUCH UMASK_NULL DEV_NULL/ ) {
3594         push @m, "$_ = $self->{$_}\n";
3595     }
3596
3597     push @m, q{
3598 # The following is a portable way to say mkdir -p
3599 # To see which directories are created, change the if 0 to if 1
3600 MKPATH = $(PERLRUN) -MExtUtils::Command -e mkpath
3601
3602 # This helps us to minimize the effect of the .exists files A yet
3603 # better solution would be to have a stable file in the perl
3604 # distribution with a timestamp of zero. But this solution doesn't
3605 # need any changes to the core distribution and works with older perls
3606 EQUALIZE_TIMESTAMP = $(PERLRUN) -MExtUtils::Command -e eqtime
3607 };
3608
3609
3610     return join "", @m if $self->{PARENT};
3611
3612     push @m, q{
3613 # Here we warn users that an old packlist file was found somewhere,
3614 # and that they should call some uninstall routine
3615 WARN_IF_OLD_PACKLIST = $(PERL) -we 'exit unless -f $$ARGV[0];' \\
3616 -e 'print "WARNING: I have found an old package in\n";' \\
3617 -e 'print "\t$$ARGV[0].\n";' \\
3618 -e 'print "Please make sure the two installations are not conflicting\n";'
3619
3620 UNINST=0
3621 VERBINST=0
3622
3623 MOD_INSTALL = $(PERL) -I$(INST_LIB) -I$(PERL_LIB) -MExtUtils::Install \
3624 -e "install({@ARGV},'$(VERBINST)',0,'$(UNINST)');"
3625
3626 DOC_INSTALL = $(PERL) -e '$$\="\n\n";' \
3627 -e 'print "=head2 ", scalar(localtime), ": C<", shift, ">", " L<", $$arg=shift, "|", $$arg, ">";' \
3628 -e 'print "=over 4";' \
3629 -e 'while (defined($$key = shift) and defined($$val = shift)){print "=item *";print "C<$$key: $$val>";}' \
3630 -e 'print "=back";'
3631
3632 UNINSTALL =   $(PERL) -MExtUtils::Install \
3633 -e 'uninstall($$ARGV[0],1,1); print "\nUninstall is deprecated. Please check the";' \
3634 -e 'print " packlist above carefully.\n  There may be errors. Remove the";' \
3635 -e 'print " appropriate files manually.\n  Sorry for the inconveniences.\n"'
3636 };
3637
3638     return join "", @m;
3639 }
3640
3641 =item tool_xsubpp (o)
3642
3643 Determines typemaps, xsubpp version, prototype behaviour.
3644
3645 =cut
3646
3647 sub tool_xsubpp {
3648     my($self) = shift;
3649     return "" unless $self->needs_linking;
3650     my($xsdir)  = $self->catdir($self->{PERL_LIB},"ExtUtils");
3651     my(@tmdeps) = $self->catdir('$(XSUBPPDIR)','typemap');
3652     if( $self->{TYPEMAPS} ){
3653         my $typemap;
3654         foreach $typemap (@{$self->{TYPEMAPS}}){
3655                 if( ! -f  $typemap ){
3656                         warn "Typemap $typemap not found.\n";
3657                 }
3658                 else{
3659                         push(@tmdeps,  $typemap);
3660                 }
3661         }
3662     }
3663     push(@tmdeps, "typemap") if -f "typemap";
3664     my(@tmargs) = map("-typemap $_", @tmdeps);
3665     if( exists $self->{XSOPT} ){
3666         unshift( @tmargs, $self->{XSOPT} );
3667     }
3668
3669
3670     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,"xsubpp"));
3671
3672     # What are the correct thresholds for version 1 && 2 Paul?
3673     if ( $xsubpp_version > 1.923 ){
3674         $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG};
3675     } else {
3676         if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
3677             print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
3678         Your version of xsubpp is $xsubpp_version and cannot handle this.
3679         Please upgrade to a more recent version of xsubpp.
3680 };
3681         } else {
3682             $self->{XSPROTOARG} = "";
3683         }
3684     }
3685
3686     my $xsubpp = "xsubpp";
3687
3688     return qq{
3689 XSUBPPDIR = $xsdir
3690 XSUBPP = \$(XSUBPPDIR)/$xsubpp
3691 XSPROTOARG = $self->{XSPROTOARG}
3692 XSUBPPDEPS = @tmdeps \$(XSUBPP)
3693 XSUBPPARGS = @tmargs
3694 XSUBPP_EXTRA_ARGS =
3695 };
3696 };
3697
3698 sub xsubpp_version
3699 {
3700     my($self,$xsubpp) = @_;
3701     return $Xsubpp_Version if defined $Xsubpp_Version; # global variable
3702
3703     my ($version) ;
3704
3705     # try to figure out the version number of the xsubpp on the system
3706
3707     # first try the -v flag, introduced in 1.921 & 2.000a2
3708
3709     return "" unless $self->needs_linking;
3710
3711     my $command = "$self->{PERL} -I$self->{PERL_LIB} $xsubpp -v 2>&1";
3712     print "Running $command\n" if $Verbose >= 2;
3713     $version = `$command` ;
3714     warn "Running '$command' exits with status " . ($?>>8) if $?;
3715     chop $version ;
3716
3717     return $Xsubpp_Version = $1 if $version =~ /^xsubpp version (.*)/ ;
3718
3719     # nope, then try something else
3720
3721     my $counter = '000';
3722     my ($file) = 'temp' ;
3723     $counter++ while -e "$file$counter"; # don't overwrite anything
3724     $file .= $counter;
3725
3726     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
3727     print F <<EOM ;
3728 MODULE = fred PACKAGE = fred
3729
3730 int
3731 fred(a)
3732         int     a;
3733 EOM
3734
3735     close F ;
3736
3737     $command = "$self->{PERL} $xsubpp $file 2>&1";
3738     print "Running $command\n" if $Verbose >= 2;
3739     my $text = `$command` ;
3740     warn "Running '$command' exits with status " . ($?>>8) if $?;
3741     unlink $file ;
3742
3743     # gets 1.2 -> 1.92 and 2.000a1
3744     return $Xsubpp_Version = $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
3745
3746     # it is either 1.0 or 1.1
3747     return $Xsubpp_Version = 1.1 if $text =~ /^Warning: ignored semicolon/ ;
3748
3749     # none of the above, so 1.0
3750     return $Xsubpp_Version = "1.0" ;
3751 }
3752
3753 =item top_targets (o)
3754
3755 Defines the targets all, subdirs, config, and O_FILES
3756
3757 =cut
3758
3759 sub top_targets {
3760 # --- Target Sections ---
3761
3762     my($self) = shift;
3763     my(@m);
3764     push @m, '
3765 #all :: config $(INST_PM) subdirs linkext manifypods
3766 ';
3767
3768     push @m, '
3769 all :: pure_all htmlifypods manifypods
3770         '.$self->{NOECHO}.'$(NOOP)
3771 '
3772           unless $self->{SKIPHASH}{'all'};
3773
3774     push @m, '
3775 pure_all :: config pm_to_blib subdirs linkext
3776         '.$self->{NOECHO}.'$(NOOP)
3777
3778 subdirs :: $(MYEXTLIB)
3779         '.$self->{NOECHO}.'$(NOOP)
3780
3781 config :: '.$self->{MAKEFILE}.' $(INST_LIBDIR)/.exists
3782         '.$self->{NOECHO}.'$(NOOP)
3783
3784 config :: $(INST_ARCHAUTODIR)/.exists
3785         '.$self->{NOECHO}.'$(NOOP)
3786
3787 config :: $(INST_AUTODIR)/.exists
3788         '.$self->{NOECHO}.'$(NOOP)
3789 ';
3790
3791     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
3792
3793     if (%{$self->{HTMLLIBPODS}}) {
3794         push @m, qq[
3795 config :: \$(INST_HTMLLIBDIR)/.exists
3796         $self->{NOECHO}\$(NOOP)
3797
3798 ];
3799         push @m, $self->dir_target(qw[$(INST_HTMLLIBDIR)]);
3800     }
3801
3802     if (%{$self->{HTMLSCRIPTPODS}}) {
3803         push @m, qq[
3804 config :: \$(INST_HTMLSCRIPTDIR)/.exists
3805         $self->{NOECHO}\$(NOOP)
3806
3807 ];
3808         push @m, $self->dir_target(qw[$(INST_HTMLSCRIPTDIR)]);
3809     }
3810
3811     if (%{$self->{MAN1PODS}}) {
3812         push @m, qq[
3813 config :: \$(INST_MAN1DIR)/.exists
3814         $self->{NOECHO}\$(NOOP)
3815
3816 ];
3817         push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
3818     }
3819     if (%{$self->{MAN3PODS}}) {
3820         push @m, qq[
3821 config :: \$(INST_MAN3DIR)/.exists
3822         $self->{NOECHO}\$(NOOP)
3823
3824 ];
3825         push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
3826     }
3827
3828     push @m, '
3829 $(O_FILES): $(H_FILES)
3830 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
3831
3832     push @m, q{
3833 help:
3834         perldoc ExtUtils::MakeMaker
3835 };
3836
3837     push @m, q{
3838 Version_check:
3839         }.$self->{NOECHO}.q{$(PERLRUN) \
3840                 -MExtUtils::MakeMaker=Version_check \
3841                 -e "Version_check('$(MM_VERSION)')"
3842 };
3843
3844     join('',@m);
3845 }
3846
3847 =item writedoc
3848
3849 Obsolete, deprecated method. Not used since Version 5.21.
3850
3851 =cut
3852
3853 sub writedoc {
3854 # --- perllocal.pod section ---
3855     my($self,$what,$name,@attribs)=@_;
3856     my $time = localtime;
3857     print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n";
3858     print join "\n\n=item *\n\n", map("C<$_>",@attribs);
3859     print "\n\n=back\n\n";
3860 }
3861
3862 =item xs_c (o)
3863
3864 Defines the suffix rules to compile XS files to C.
3865
3866 =cut
3867
3868 sub xs_c {
3869     my($self) = shift;
3870     return '' unless $self->needs_linking();
3871     '
3872 .xs.c:
3873         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3874 ';
3875 }
3876
3877 =item xs_cpp (o)
3878
3879 Defines the suffix rules to compile XS files to C++.
3880
3881 =cut
3882
3883 sub xs_cpp {
3884     my($self) = shift;
3885     return '' unless $self->needs_linking();
3886     '
3887 .xs.cpp:
3888         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp
3889 ';
3890 }
3891
3892 =item xs_o (o)
3893
3894 Defines suffix rules to go from XS to object files directly. This is
3895 only intended for broken make implementations.
3896
3897 =cut
3898
3899 sub xs_o {      # many makes are too dumb to use xs_c then c_o
3900     my($self) = shift;
3901     return '' unless $self->needs_linking();
3902     '
3903 .xs$(OBJ_EXT):
3904         $(PERLRUN) $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c
3905         $(CCCMD) $(CCCDLFLAGS) -I$(PERL_INC) $(PASTHRU_DEFINE) $(DEFINE) $*.c
3906 ';
3907 }
3908
3909 =item perl_archive
3910
3911 This is internal method that returns path to libperl.a equivalent
3912 to be linked to dynamic extensions. UNIX does not have one but OS2
3913 and Win32 do.
3914
3915 =cut
3916
3917 sub perl_archive
3918 {
3919  return '$(PERL_INC)' . "/$Config{libperl}" if $^O eq "beos";
3920  return "";
3921 }
3922
3923 =item perl_archive_after
3924
3925 This is an internal method that returns path to a library which
3926 should be put on the linker command line I<after> the external libraries
3927 to be linked to dynamic extensions.  This may be needed if the linker
3928 is one-pass, and Perl includes some overrides for C RTL functions,
3929 such as malloc().
3930
3931 =cut
3932
3933 sub perl_archive_after
3934 {
3935  return "";
3936 }
3937
3938 =item export_list
3939
3940 This is internal method that returns name of a file that is
3941 passed to linker to define symbols to be exported.
3942 UNIX does not have one but OS2 and Win32 do.
3943
3944 =cut
3945
3946 sub export_list
3947 {
3948  return "";
3949 }
3950
3951
3952 1;
3953
3954 =back
3955
3956 =head1 SEE ALSO
3957
3958 L<ExtUtils::MakeMaker>
3959
3960 =cut
3961
3962 __END__