lib/ExtUtils/MM_Unix.pm

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