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